@mintlify/cli 4.0.1379 → 4.0.1380

package/bin/indexSetup/clients.js

@@ -0,0 +1,173 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs-extra';
+import path from 'path';
+import { CURSOR_RULE, RULE_BODY, VSCODE_RULE } from './rule.js';
+export const INDEX_MCP_URL = 'https://index.mintlify.com/mcp';
+export const SERVER_NAME = 'mintlify-index';
+function claudeConfigDir(ctx) {
+    const override = ctx.env.CLAUDE_CONFIG_DIR;
+    return override !== undefined && override !== '' ? override : path.join(ctx.home, '.claude');
+}
+function claudeGlobalConfigPath(ctx) {
+    const override = ctx.env.CLAUDE_CONFIG_DIR;
+    return override !== undefined && override !== ''
+        ? path.join(override, '.claude.json')
+        : path.join(ctx.home, '.claude.json');
+}
+function zedUserDir(ctx) {
+    if (ctx.platform === 'win32') {
+        const appData = ctx.env.APPDATA;
+        const base = appData !== undefined && appData !== '' ? appData : path.join(ctx.home, 'AppData', 'Roaming');
+        return path.join(base, 'Zed');
+    }
+    return path.join(ctx.home, '.config', 'zed');
+}
+function vscodeUserDir(ctx) {
+    if (ctx.platform === 'darwin') {
+        return path.join(ctx.home, 'Library', 'Application Support', 'Code', 'User');
+    }
+    if (ctx.platform === 'win32') {
+        const appData = ctx.env.APPDATA;
+        const base = appData !== undefined && appData !== '' ? appData : path.join(ctx.home, 'AppData', 'Roaming');
+        return path.join(base, 'Code', 'User');
+    }
+    return path.join(ctx.home, '.config', 'Code', 'User');
+}
+export const CLIENTS = {
+    claude: {
+        name: 'claude',
+        displayName: 'Claude Code',
+        format: 'json',
+        configKey: 'mcpServers',
+        globalConfigPaths: (ctx) => [claudeGlobalConfigPath(ctx)],
+        projectConfigPaths: (ctx) => [path.join(ctx.cwd, '.mcp.json')],
+        buildEntry: () => ({ type: 'http', url: INDEX_MCP_URL }),
+        rule: {
+            kind: 'file',
+            content: RULE_BODY,
+            globalPath: (ctx) => path.join(claudeConfigDir(ctx), 'rules', 'mintlify-index.md'),
+            projectPath: (ctx) => path.join(ctx.cwd, '.claude', 'rules', 'mintlify-index.md'),
+        },
+        detectPaths: (ctx) => [claudeConfigDir(ctx)],
+    },
+    cursor: {
+        name: 'cursor',
+        displayName: 'Cursor',
+        format: 'json',
+        configKey: 'mcpServers',
+        globalConfigPaths: (ctx) => [path.join(ctx.home, '.cursor', 'mcp.json')],
+        projectConfigPaths: (ctx) => [path.join(ctx.cwd, '.cursor', 'mcp.json')],
+        buildEntry: () => ({ url: INDEX_MCP_URL }),
+        rule: {
+            kind: 'file',
+            content: CURSOR_RULE,
+            globalPath: (ctx) => path.join(ctx.home, '.cursor', 'rules', 'mintlify-index.mdc'),
+            projectPath: (ctx) => path.join(ctx.cwd, '.cursor', 'rules', 'mintlify-index.mdc'),
+        },
+        detectPaths: (ctx) => [path.join(ctx.home, '.cursor')],
+    },
+    vscode: {
+        name: 'vscode',
+        displayName: 'VS Code',
+        format: 'json',
+        configKey: 'servers',
+        globalConfigPaths: (ctx) => [path.join(vscodeUserDir(ctx), 'mcp.json')],
+        projectConfigPaths: (ctx) => [path.join(ctx.cwd, '.vscode', 'mcp.json')],
+        buildEntry: () => ({ type: 'http', url: INDEX_MCP_URL }),
+        rule: {
+            kind: 'file',
+            content: VSCODE_RULE,
+            globalPath: (ctx) => path.join(vscodeUserDir(ctx), 'prompts', 'mintlify-index.instructions.md'),
+            projectPath: (ctx) => path.join(ctx.cwd, '.github', 'instructions', 'mintlify-index.instructions.md'),
+        },
+        detectPaths: (ctx) => [vscodeUserDir(ctx)],
+    },
+    codex: {
+        name: 'codex',
+        displayName: 'Codex',
+        format: 'toml',
+        configKey: 'mcp_servers',
+        globalConfigPaths: (ctx) => [path.join(ctx.home, '.codex', 'config.toml')],
+        projectConfigPaths: (ctx) => [path.join(ctx.cwd, '.codex', 'config.toml')],
+        buildEntry: () => ({ type: 'http', url: INDEX_MCP_URL }),
+        rule: {
+            kind: 'append',
+            content: RULE_BODY,
+            globalPath: (ctx) => path.join(ctx.home, '.codex', 'AGENTS.md'),
+            projectPath: (ctx) => path.join(ctx.cwd, 'AGENTS.md'),
+        },
+        detectPaths: (ctx) => [path.join(ctx.home, '.codex')],
+    },
+    opencode: {
+        name: 'opencode',
+        displayName: 'OpenCode',
+        format: 'json',
+        configKey: 'mcp',
+        globalConfigPaths: (ctx) => [path.join(ctx.home, '.config', 'opencode', 'opencode.json')],
+        projectConfigPaths: (ctx) => [path.join(ctx.cwd, 'opencode.json')],
+        buildEntry: () => ({ type: 'remote', url: INDEX_MCP_URL, enabled: true }),
+        rule: {
+            kind: 'append',
+            content: RULE_BODY,
+            globalPath: (ctx) => path.join(ctx.home, '.config', 'opencode', 'AGENTS.md'),
+            projectPath: (ctx) => path.join(ctx.cwd, 'AGENTS.md'),
+        },
+        detectPaths: (ctx) => [path.join(ctx.home, '.config', 'opencode')],
+    },
+    windsurf: {
+        name: 'windsurf',
+        displayName: 'Windsurf',
+        format: 'json',
+        configKey: 'mcpServers',
+        globalConfigPaths: (ctx) => [path.join(ctx.home, '.codeium', 'windsurf', 'mcp_config.json')],
+        buildEntry: () => ({ serverUrl: INDEX_MCP_URL }),
+        rule: {
+            kind: 'append',
+            content: RULE_BODY,
+            globalPath: (ctx) => path.join(ctx.home, '.codeium', 'windsurf', 'memories', 'global_rules.md'),
+            projectPath: (ctx) => path.join(ctx.cwd, '.windsurf', 'rules', 'mintlify-index.md'),
+        },
+        detectPaths: (ctx) => [path.join(ctx.home, '.codeium', 'windsurf')],
+    },
+    zed: {
+        name: 'zed',
+        displayName: 'Zed',
+        format: 'json',
+        configKey: 'context_servers',
+        globalConfigPaths: (ctx) => [path.join(zedUserDir(ctx), 'settings.json')],
+        projectConfigPaths: (ctx) => [path.join(ctx.cwd, '.zed', 'settings.json')],
+        buildEntry: () => ({ url: INDEX_MCP_URL }),
+        detectPaths: (ctx) => [zedUserDir(ctx)],
+    },
+};
+export const ALL_CLIENT_NAMES = [
+    'claude',
+    'cursor',
+    'vscode',
+    'codex',
+    'opencode',
+    'windsurf',
+    'zed',
+];
+export function detectClients(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const detected = [];
+        for (const name of ALL_CLIENT_NAMES) {
+            for (const candidate of CLIENTS[name].detectPaths(ctx)) {
+                if (yield fs.pathExists(candidate)) {
+                    detected.push(name);
+                    break;
+                }
+            }
+        }
+        return detected;
+    });
+}

package/bin/indexSetup/configFile.js

@@ -0,0 +1,126 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs-extra';
+import { applyEdits, modify, parse } from 'jsonc-parser';
+import path from 'path';
+function isEnoent(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+export function readJsonConfig(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let raw;
+        try {
+            raw = yield fs.readFile(filePath, 'utf-8');
+        }
+        catch (error) {
+            if (isEnoent(error)) {
+                return {};
+            }
+            throw error;
+        }
+        if (raw.trim() === '') {
+            return {};
+        }
+        const errors = [];
+        const parsed = parse(raw, errors, { allowTrailingComma: true });
+        if (errors.length > 0) {
+            throw new Error(`invalid JSON at ${filePath}`);
+        }
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            throw new Error(`expected a JSON object at ${filePath}`);
+        }
+        return parsed;
+    });
+}
+export function mergeServerEntry(config, configKey, serverName, entry) {
+    const section = config[configKey];
+    const servers = {};
+    if (typeof section === 'object' && section !== null && !Array.isArray(section)) {
+        Object.assign(servers, section);
+    }
+    const alreadyExists = serverName in servers;
+    servers[serverName] = entry;
+    return { config: Object.assign(Object.assign({}, config), { [configKey]: servers }), alreadyExists };
+}
+export function writeJsonConfig(filePath, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield fs.mkdirp(path.dirname(filePath));
+        yield fs.writeFile(filePath, `${JSON.stringify(config, null, 2)}\n`);
+    });
+}
+export function writeJsonServerEntry(filePath, configKey, serverName, entry) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let raw;
+        try {
+            raw = yield fs.readFile(filePath, 'utf-8');
+        }
+        catch (error) {
+            if (!isEnoent(error)) {
+                throw error;
+            }
+        }
+        if (raw === undefined || raw.trim() === '') {
+            const { config } = mergeServerEntry({}, configKey, serverName, entry);
+            yield writeJsonConfig(filePath, config);
+            return { status: 'configured' };
+        }
+        const errors = [];
+        const parsed = parse(raw, errors, { allowTrailingComma: true });
+        if (errors.length > 0 || typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            throw new Error(`unable to parse existing config at ${filePath}`);
+        }
+        const section = parsed[configKey];
+        const sectionIsObject = typeof section === 'object' && section !== null && !Array.isArray(section);
+        const alreadyExists = sectionIsObject && serverName in section;
+        const edits = sectionIsObject
+            ? modify(raw, [configKey, serverName], entry, {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            })
+            : modify(raw, [configKey], { [serverName]: entry }, {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            });
+        yield fs.mkdirp(path.dirname(filePath));
+        yield fs.writeFile(filePath, applyEdits(raw, edits));
+        return { status: alreadyExists ? 'reconfigured' : 'configured' };
+    });
+}
+export function resolveConfigPath(candidates) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const candidate of candidates) {
+            if (yield fs.pathExists(candidate)) {
+                return candidate;
+            }
+        }
+        const fallback = candidates[0];
+        if (fallback === undefined) {
+            throw new Error('no config path candidates');
+        }
+        return fallback;
+    });
+}
+export function upsertTomlServer(content, serverName, entry) {
+    const header = `[mcp_servers.${serverName}]`;
+    const escapedName = serverName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const headerPattern = new RegExp(`^[ \\t]*\\[mcp_servers\\.${escapedName}\\][ \\t]*(?:#.*)?$`, 'm');
+    const lines = Object.entries(entry).map(([key, value]) => `${key} = ${JSON.stringify(value)}`);
+    const block = `${[header, ...lines].join('\n')}\n`;
+    const match = headerPattern.exec(content);
+    if (match === null) {
+        const separator = content.length === 0 ? '' : content.endsWith('\n') ? '\n' : '\n\n';
+        return { content: `${content}${separator}${block}`, alreadyExists: false };
+    }
+    const headerIndex = match.index + match[0].indexOf('[');
+    const rest = content.slice(headerIndex + header.length);
+    const nextTable = rest.search(/\n\s*\[/);
+    const end = nextTable === -1 ? content.length : headerIndex + header.length + nextTable + 1;
+    const before = content.slice(0, headerIndex);
+    const after = content.slice(end).replace(/^\n+/, '\n');
+    return { content: `${before}${block}${after}`, alreadyExists: true };
+}

package/bin/indexSetup/engine.js

@@ -0,0 +1,92 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs-extra';
+import path from 'path';
+import { SERVER_NAME, } from './clients.js';
+import { resolveConfigPath, upsertTomlServer, writeJsonServerEntry } from './configFile.js';
+import { appendRuleSection, writeRuleFile } from './rule.js';
+function writeMcpEntry(definition, scope, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const projectPaths = (_b = (_a = definition.projectConfigPaths) === null || _a === void 0 ? void 0 : _a.call(definition, ctx)) !== null && _b !== void 0 ? _b : [];
+        const candidates = scope === 'project' && projectPaths.length > 0
+            ? projectPaths
+            : definition.globalConfigPaths(ctx);
+        const configPath = yield resolveConfigPath(candidates);
+        if (definition.format === 'toml') {
+            let existing = '';
+            try {
+                existing = yield fs.readFile(configPath, 'utf-8');
+            }
+            catch (error) {
+                if (!(typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT')) {
+                    throw error;
+                }
+            }
+            const entry = {};
+            for (const [key, value] of Object.entries(definition.buildEntry())) {
+                if (typeof value === 'string') {
+                    entry[key] = value;
+                }
+            }
+            const { content, alreadyExists } = upsertTomlServer(existing, SERVER_NAME, entry);
+            yield fs.mkdirp(path.dirname(configPath));
+            yield fs.writeFile(configPath, content);
+            return { status: alreadyExists ? 'reconfigured' : 'configured', configPath };
+        }
+        const { status } = yield writeJsonServerEntry(configPath, definition.configKey, SERVER_NAME, definition.buildEntry());
+        return { status, configPath };
+    });
+}
+function writeRule(definition, scope, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const rule = definition.rule;
+        if (rule === undefined) {
+            return { status: 'none', rulePath: '' };
+        }
+        const projectPath = (_a = rule.projectPath) === null || _a === void 0 ? void 0 : _a.call(rule, ctx);
+        const rulePath = scope === 'project' && projectPath !== undefined ? projectPath : rule.globalPath(ctx);
+        const status = rule.kind === 'file'
+            ? yield writeRuleFile(rulePath, rule.content)
+            : yield appendRuleSection(rulePath, rule.content);
+        return { status, rulePath };
+    });
+}
+export function setupClient(definition, scope, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = {
+            client: definition.name,
+            displayName: definition.displayName,
+            mcpStatus: 'failed',
+            mcpDetail: '',
+            ruleStatus: 'none',
+            ruleDetail: '',
+        };
+        try {
+            const { status, configPath } = yield writeMcpEntry(definition, scope, ctx);
+            result.mcpStatus = status;
+            result.mcpDetail = configPath;
+        }
+        catch (error) {
+            result.mcpDetail = error instanceof Error ? error.message : String(error);
+        }
+        try {
+            const { status, rulePath } = yield writeRule(definition, scope, ctx);
+            result.ruleStatus = status;
+            result.ruleDetail = rulePath;
+        }
+        catch (error) {
+            result.ruleStatus = 'failed';
+            result.ruleDetail = error instanceof Error ? error.message : String(error);
+        }
+        return result;
+    });
+}

package/bin/indexSetup/rule.js

@@ -0,0 +1,56 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs-extra';
+import path from 'path';
+export const RULE_MARKER = '<!-- mintlify-index -->';
+export const RULE_BODY = `Use the Mintlify index \`context\` tool whenever you research how to use a library, framework, SDK, API, or CLI tool, including syntax, configuration, migration, and setup questions. Use it even for well-known libraries, since training data may be stale, and prefer it over web search for developer documentation. Do not use it for general programming concepts or for debugging business logic.
+`;
+export const CURSOR_RULE = `---
+alwaysApply: true
+---
+
+${RULE_BODY}`;
+export const VSCODE_RULE = `---
+applyTo: '**'
+---
+
+${RULE_BODY}`;
+export function writeRuleFile(filePath, content) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const exists = yield fs.pathExists(filePath);
+        yield fs.mkdirp(path.dirname(filePath));
+        yield fs.writeFile(filePath, content);
+        return exists ? 'updated' : 'installed';
+    });
+}
+export function appendRuleSection(filePath, content) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const section = `${RULE_MARKER}\n${content}${RULE_MARKER}`;
+        let existing = '';
+        try {
+            existing = yield fs.readFile(filePath, 'utf-8');
+        }
+        catch (error) {
+            if (!(typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT')) {
+                throw error;
+            }
+        }
+        const escaped = RULE_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const pattern = new RegExp(`${escaped}\\n[\\s\\S]*?${escaped}`);
+        if (pattern.test(existing)) {
+            yield fs.writeFile(filePath, existing.replace(pattern, section));
+            return 'updated';
+        }
+        const separator = existing.length === 0 ? '' : existing.endsWith('\n') ? '\n' : '\n\n';
+        yield fs.mkdirp(path.dirname(filePath));
+        yield fs.writeFile(filePath, `${existing}${separator}${section}\n`);
+        return 'installed';
+    });
+}

package/bin/indexSetup/setup.js

@@ -0,0 +1,94 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { checkbox } from '@inquirer/prompts';
+import { addLog, ErrorLog, WarningLog } from '@mintlify/previewing';
+import { Text } from 'ink';
+import os from 'os';
+import { trackEvent } from '../telemetry/track.js';
+import { ALL_CLIENT_NAMES, CLIENTS, detectClients, } from './clients.js';
+import { setupClient } from './engine.js';
+export function resolveExplicitClients(options) {
+    return ALL_CLIENT_NAMES.filter((name) => options[name] === true);
+}
+function promptClients(detected) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield checkbox({
+                message: 'Which coding agents do you want to set up?',
+                loop: false,
+                choices: ALL_CLIENT_NAMES.map((name) => ({
+                    name: CLIENTS[name].displayName,
+                    value: name,
+                    checked: detected.includes(name),
+                })),
+            });
+        }
+        catch (_a) {
+            return undefined;
+        }
+    });
+}
+function logResult(result) {
+    addLog(_jsx(Text, { bold: true, children: result.displayName }));
+    if (result.mcpStatus === 'failed') {
+        addLog(_jsx(ErrorLog, { message: `  MCP server failed: ${result.mcpDetail}` }));
+    }
+    else {
+        addLog(_jsxs(Text, { children: ['  ', "MCP server ", result.mcpStatus, " ", _jsx(Text, { dimColor: true, children: result.mcpDetail })] }));
+    }
+    if (result.ruleStatus === 'failed') {
+        addLog(_jsx(ErrorLog, { message: `  Rule failed: ${result.ruleDetail}` }));
+    }
+    else if (result.ruleStatus !== 'none') {
+        addLog(_jsxs(Text, { children: ['  ', "Rule ", result.ruleStatus, " ", _jsx(Text, { dimColor: true, children: result.ruleDetail })] }));
+    }
+}
+export function runIndexSetup(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ctx = {
+            home: os.homedir(),
+            cwd: process.cwd(),
+            platform: process.platform,
+            env: process.env,
+        };
+        const scope = options.project === true ? 'project' : 'global';
+        let selected = resolveExplicitClients(options);
+        if (selected.length === 0) {
+            const detected = yield detectClients(ctx);
+            if (options.yes === true) {
+                if (detected.length === 0) {
+                    addLog(_jsx(ErrorLog, { message: "no coding agents detected; pass flags like --claude or --cursor" }));
+                    return 1;
+                }
+                selected = detected;
+            }
+            else {
+                const picked = yield promptClients(detected);
+                if (picked === undefined || picked.length === 0) {
+                    addLog(_jsx(WarningLog, { message: "setup cancelled" }));
+                    return 1;
+                }
+                selected = picked;
+            }
+        }
+        const results = [];
+        for (const name of selected) {
+            results.push(yield setupClient(CLIENTS[name], scope, ctx));
+        }
+        for (const result of results) {
+            logResult(result);
+        }
+        const succeeded = results.filter((result) => result.mcpStatus !== 'failed');
+        addLog(_jsxs(Text, { children: ["Mintlify index MCP set up for ", succeeded.length, "/", results.length, " agents"] }));
+        void trackEvent('cli.index.completed', { clients: selected, scope });
+        return succeeded.length > 0 ? 0 : 1;
+    });
+}