@jinn-network/client 0.1.2 → 0.1.3-canary.24b69ea4

package/dist/cli/commands/plugin-install.js

@@ -1,803 +0,0 @@
-import { parseArgs } from 'node:util';
-import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, copyFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { execSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { platform, homedir } from 'node:os';
-import { emitResult } from '../output.js';
-import { emitEnvelope } from '../../errors/envelope.js';
-// ---------------------------------------------------------------------------
-// Skill content resolution
-// ---------------------------------------------------------------------------
-const SKILL_DIR = fileURLToPath(new URL('../../../skills/jinn-operator', import.meta.url));
-function loadSkillContent() {
-    return readFileSync(join(SKILL_DIR, 'SKILL.md'), 'utf-8');
-}
-function stripFrontmatter(content) {
-    const match = content.match(/^---\n[\s\S]*?\n---\n/);
-    if (!match)
-        return content;
-    return content.slice(match[0].length).trimStart();
-}
-// ---------------------------------------------------------------------------
-// Helpers — JSON MCP config
-// ---------------------------------------------------------------------------
-function readJsonFile(filePath) {
-    if (!existsSync(filePath))
-        return {};
-    try {
-        return JSON.parse(readFileSync(filePath, 'utf-8'));
-    }
-    catch {
-        return {};
-    }
-}
-function writeJsonFile(filePath, data) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
-}
-function hasJsonMcpServer(filePath, rootKey) {
-    const data = readJsonFile(filePath);
-    const section = data[rootKey];
-    return section !== undefined && 'jinn' in section;
-}
-function upsertJsonMcpServer(filePath, rootKey) {
-    const data = readJsonFile(filePath);
-    const section = (data[rootKey] ?? {});
-    if ('jinn' in section) {
-        return { ok: true, detail: `Already configured in ${filePath}` };
-    }
-    section['jinn'] = { command: 'jinn', args: ['mcp'] };
-    data[rootKey] = section;
-    writeJsonFile(filePath, data);
-    return { ok: true, detail: `Wrote MCP entry to ${filePath}` };
-}
-function removeJsonMcpServer(filePath, rootKey) {
-    if (!existsSync(filePath)) {
-        return { ok: true, detail: 'Config file does not exist' };
-    }
-    const data = readJsonFile(filePath);
-    const section = (data[rootKey] ?? {});
-    if (!('jinn' in section)) {
-        return { ok: true, detail: 'Not configured' };
-    }
-    delete section['jinn'];
-    data[rootKey] = section;
-    writeJsonFile(filePath, data);
-    return { ok: true, detail: `Removed MCP entry from ${filePath}` };
-}
-// ---------------------------------------------------------------------------
-// Helpers — TOML MCP config (Codex)
-// ---------------------------------------------------------------------------
-const TOML_BLOCK = `[mcp_servers.jinn]\ncommand = "jinn"\nargs = ["mcp"]`;
-function hasTomlMcpServer(filePath) {
-    if (!existsSync(filePath))
-        return false;
-    return readFileSync(filePath, 'utf-8').includes('[mcp_servers.jinn]');
-}
-function upsertTomlMcpServer(filePath) {
-    if (hasTomlMcpServer(filePath)) {
-        return { ok: true, detail: `Already configured in ${filePath}` };
-    }
-    mkdirSync(dirname(filePath), { recursive: true });
-    const existing = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '';
-    const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n\n' : existing.length > 0 ? '\n' : '';
-    writeFileSync(filePath, existing + separator + TOML_BLOCK + '\n', 'utf-8');
-    return { ok: true, detail: `Wrote MCP entry to ${filePath}` };
-}
-function removeTomlMcpServer(filePath) {
-    if (!existsSync(filePath)) {
-        return { ok: true, detail: 'Config file does not exist' };
-    }
-    const content = readFileSync(filePath, 'utf-8');
-    if (!content.includes('[mcp_servers.jinn]')) {
-        return { ok: true, detail: 'Not configured' };
-    }
-    // Remove the block: header line + command line (and optional trailing blank line)
-    const updated = content
-        .replace(/\n?\[mcp_servers\.jinn\]\ncommand = "jinn"\nargs = \["mcp"\]\n?/g, '\n')
-        .replace(/\n?\[mcp_servers\.jinn\]\ncommand = "jinn-mcp"\n?/g, '\n')
-        .replace(/\n{3,}/g, '\n\n')
-        .trim() + '\n';
-    writeFileSync(filePath, updated, 'utf-8');
-    return { ok: true, detail: `Removed MCP entry from ${filePath}` };
-}
-// ---------------------------------------------------------------------------
-// Helpers — Skill block (delimited append for VS Code, Gemini, Codex)
-// ---------------------------------------------------------------------------
-const BLOCK_START = '<!-- jinn-operator-start -->';
-const BLOCK_END = '<!-- jinn-operator-end -->';
-function hasSkillBlock(filePath) {
-    if (!existsSync(filePath))
-        return false;
-    return readFileSync(filePath, 'utf-8').includes(BLOCK_START);
-}
-function upsertSkillBlock(filePath, content) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    const block = `${BLOCK_START}\n${content}\n${BLOCK_END}\n`;
-    if (hasSkillBlock(filePath)) {
-        // Replace existing block so `jinn plugin install` propagates updates
-        const existing = readFileSync(filePath, 'utf-8');
-        const re = new RegExp(BLOCK_START.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
-            '[\\s\\S]*?' +
-            BLOCK_END.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
-            '\\n?');
-        writeFileSync(filePath, existing.replace(re, block), 'utf-8');
-        return { ok: true, detail: `Updated skill block in ${filePath}` };
-    }
-    const existing = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '';
-    const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n\n' : existing.length > 0 ? '\n' : '';
-    writeFileSync(filePath, existing + separator + block, 'utf-8');
-    return { ok: true, detail: `Appended skill block to ${filePath}` };
-}
-function removeSkillBlock(filePath) {
-    if (!existsSync(filePath)) {
-        return { ok: true, detail: 'File does not exist' };
-    }
-    const content = readFileSync(filePath, 'utf-8');
-    if (!content.includes(BLOCK_START)) {
-        return { ok: true, detail: 'Skill block not present' };
-    }
-    const regex = new RegExp(`\\n?${BLOCK_START}[\\s\\S]*?${BLOCK_END}\\n?`, 'g');
-    const updated = content.replace(regex, '\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
-    writeFileSync(filePath, updated, 'utf-8');
-    return { ok: true, detail: `Removed skill block from ${filePath}` };
-}
-// ---------------------------------------------------------------------------
-// Helpers — Claude skill directory (copy/delete)
-// ---------------------------------------------------------------------------
-function hasClaudeSkill(targetDir) {
-    return existsSync(join(targetDir, 'SKILL.md'));
-}
-function installClaudeSkill(targetDir) {
-    const verb = hasClaudeSkill(targetDir) ? 'Updated' : 'Copied';
-    mkdirSync(targetDir, { recursive: true });
-    copyFileSync(join(SKILL_DIR, 'SKILL.md'), join(targetDir, 'SKILL.md'));
-    return { ok: true, detail: `${verb} skill at ${targetDir}` };
-}
-function removeClaudeSkill(targetDir) {
-    if (!hasClaudeSkill(targetDir)) {
-        return { ok: true, detail: 'Skill not installed' };
-    }
-    rmSync(targetDir, { recursive: true, force: true });
-    return { ok: true, detail: `Removed skill from ${targetDir}` };
-}
-// ---------------------------------------------------------------------------
-// Helpers — Cursor rule file
-// ---------------------------------------------------------------------------
-function hasCursorRule(targetPath) {
-    return existsSync(targetPath);
-}
-function installCursorRule(targetPath, content) {
-    const verb = hasCursorRule(targetPath) ? 'Updated' : 'Wrote';
-    mkdirSync(dirname(targetPath), { recursive: true });
-    writeFileSync(targetPath, content, 'utf-8');
-    return { ok: true, detail: `${verb} rule at ${targetPath}` };
-}
-function removeCursorRule(targetPath) {
-    if (!hasCursorRule(targetPath)) {
-        return { ok: true, detail: 'Rule not installed' };
-    }
-    rmSync(targetPath, { force: true });
-    return { ok: true, detail: `Removed rule from ${targetPath}` };
-}
-// ---------------------------------------------------------------------------
-// Helpers — command detection
-// ---------------------------------------------------------------------------
-function commandExists(cmd) {
-    try {
-        execSync(`which ${cmd}`, { stdio: 'ignore' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// ---------------------------------------------------------------------------
-// Platform paths
-// ---------------------------------------------------------------------------
-function claudeDesktopConfigDir() {
-    if (platform() === 'darwin') {
-        return join(homedir(), 'Library', 'Application Support', 'Claude');
-    }
-    return join(homedir(), '.config', 'claude-desktop');
-}
-function claudeSkillDir(scope) {
-    if (scope === 'user')
-        return join(homedir(), '.claude', 'skills', 'jinn-operator');
-    return join(process.cwd(), '.claude', 'skills', 'jinn-operator');
-}
-const TARGETS = [
-    // ---- claude-code ----
-    {
-        id: 'claude-code',
-        name: 'Claude Code',
-        detect: () => commandExists('claude'),
-        isMcpConfigured(scope) {
-            // We can't easily check this without parsing claude's internal config.
-            // Attempt to list MCP servers and check for jinn.
-            try {
-                const out = execSync(`claude mcp list --scope ${scope}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
-                return out.includes('jinn');
-            }
-            catch {
-                return false;
-            }
-        },
-        isSkillConfigured(scope) {
-            return hasClaudeSkill(claudeSkillDir(scope));
-        },
-        async installMcp(scope) {
-            try {
-                const out = execSync(`claude mcp list --scope ${scope}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
-                if (out.includes('jinn')) {
-                    return { ok: true, detail: 'Already configured via claude CLI' };
-                }
-            }
-            catch { /* proceed */ }
-            try {
-                execSync(`claude mcp add --scope ${scope} jinn -- jinn mcp`, { stdio: 'ignore' });
-                return { ok: true, detail: `Added jinn MCP via claude CLI (scope: ${scope})` };
-            }
-            catch (err) {
-                return { ok: false, detail: `Failed to add MCP: ${err instanceof Error ? err.message : String(err)}` };
-            }
-        },
-        async installSkill(scope) {
-            return installClaudeSkill(claudeSkillDir(scope));
-        },
-        async removeMcp(scope) {
-            try {
-                execSync(`claude mcp remove --scope ${scope} jinn`, { stdio: 'ignore' });
-                return { ok: true, detail: `Removed jinn MCP via claude CLI (scope: ${scope})` };
-            }
-            catch (err) {
-                return { ok: false, detail: `Failed to remove MCP: ${err instanceof Error ? err.message : String(err)}` };
-            }
-        },
-        async removeSkill(scope) {
-            return removeClaudeSkill(claudeSkillDir(scope));
-        },
-    },
-    // ---- claude-desktop ----
-    {
-        id: 'claude-desktop',
-        name: 'Claude Desktop',
-        detect: () => existsSync(claudeDesktopConfigDir()),
-        isMcpConfigured(_scope) {
-            const cfgPath = join(claudeDesktopConfigDir(), 'claude_desktop_config.json');
-            return hasJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        isSkillConfigured(scope) {
-            // Claude Desktop uses same skill directory as Claude Code (user scope always)
-            return hasClaudeSkill(claudeSkillDir(scope === 'project' ? 'user' : scope));
-        },
-        async installMcp(_scope) {
-            const cfgPath = join(claudeDesktopConfigDir(), 'claude_desktop_config.json');
-            return upsertJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        async installSkill(scope) {
-            // Claude Desktop always uses user scope for skills
-            return installClaudeSkill(claudeSkillDir(scope === 'project' ? 'user' : scope));
-        },
-        async removeMcp(_scope) {
-            const cfgPath = join(claudeDesktopConfigDir(), 'claude_desktop_config.json');
-            return removeJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        async removeSkill(scope) {
-            return removeClaudeSkill(claudeSkillDir(scope === 'project' ? 'user' : scope));
-        },
-    },
-    // ---- cursor ----
-    {
-        id: 'cursor',
-        name: 'Cursor',
-        detect: () => existsSync(join(homedir(), '.cursor')),
-        isMcpConfigured(scope) {
-            const cfgPath = scope === 'user'
-                ? join(homedir(), '.cursor', 'mcp.json')
-                : join(process.cwd(), '.cursor', 'mcp.json');
-            return hasJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        isSkillConfigured(scope) {
-            const rulePath = scope === 'user'
-                ? join(homedir(), '.cursor', 'rules', 'jinn.md')
-                : join(process.cwd(), '.cursor', 'rules', 'jinn.md');
-            return hasCursorRule(rulePath);
-        },
-        async installMcp(scope) {
-            const cfgPath = scope === 'user'
-                ? join(homedir(), '.cursor', 'mcp.json')
-                : join(process.cwd(), '.cursor', 'mcp.json');
-            return upsertJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        async installSkill(scope, skillContent) {
-            const rulePath = scope === 'user'
-                ? join(homedir(), '.cursor', 'rules', 'jinn.md')
-                : join(process.cwd(), '.cursor', 'rules', 'jinn.md');
-            return installCursorRule(rulePath, skillContent);
-        },
-        async removeMcp(scope) {
-            const cfgPath = scope === 'user'
-                ? join(homedir(), '.cursor', 'mcp.json')
-                : join(process.cwd(), '.cursor', 'mcp.json');
-            return removeJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        async removeSkill(scope) {
-            const rulePath = scope === 'user'
-                ? join(homedir(), '.cursor', 'rules', 'jinn.md')
-                : join(process.cwd(), '.cursor', 'rules', 'jinn.md');
-            return removeCursorRule(rulePath);
-        },
-    },
-    // ---- vscode ----
-    {
-        id: 'vscode',
-        name: 'VS Code',
-        detect: () => commandExists('code'),
-        isMcpConfigured(scope) {
-            if (scope === 'user')
-                return false; // VS Code MCP is project-scoped only via .vscode/mcp.json
-            const cfgPath = join(process.cwd(), '.vscode', 'mcp.json');
-            return hasJsonMcpServer(cfgPath, 'servers');
-        },
-        isSkillConfigured(scope) {
-            if (scope === 'user')
-                return false;
-            const instrPath = join(process.cwd(), '.github', 'copilot-instructions.md');
-            return hasSkillBlock(instrPath);
-        },
-        async installMcp(scope) {
-            if (scope === 'user') {
-                return { ok: true, detail: 'VS Code MCP requires project scope (--scope project)' };
-            }
-            const cfgPath = join(process.cwd(), '.vscode', 'mcp.json');
-            return upsertJsonMcpServer(cfgPath, 'servers');
-        },
-        async installSkill(scope, skillContent) {
-            if (scope === 'user') {
-                return { ok: true, detail: 'VS Code skill requires project scope (--scope project)' };
-            }
-            const instrPath = join(process.cwd(), '.github', 'copilot-instructions.md');
-            return upsertSkillBlock(instrPath, stripFrontmatter(skillContent));
-        },
-        async removeMcp(scope) {
-            if (scope === 'user') {
-                return { ok: true, detail: 'Not configured at user scope' };
-            }
-            const cfgPath = join(process.cwd(), '.vscode', 'mcp.json');
-            return removeJsonMcpServer(cfgPath, 'servers');
-        },
-        async removeSkill(scope) {
-            if (scope === 'user') {
-                return { ok: true, detail: 'Not configured at user scope' };
-            }
-            const instrPath = join(process.cwd(), '.github', 'copilot-instructions.md');
-            return removeSkillBlock(instrPath);
-        },
-    },
-    // ---- gemini-cli ----
-    {
-        id: 'gemini-cli',
-        name: 'Gemini CLI',
-        detect: () => existsSync(join(homedir(), '.gemini')),
-        isMcpConfigured(scope) {
-            const cfgPath = scope === 'user'
-                ? join(homedir(), '.gemini', 'settings.json')
-                : join(process.cwd(), '.gemini', 'settings.json');
-            return hasJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        isSkillConfigured(scope) {
-            const instrPath = scope === 'user'
-                ? join(homedir(), '.gemini', 'GEMINI.md')
-                : join(process.cwd(), 'GEMINI.md');
-            return hasSkillBlock(instrPath);
-        },
-        async installMcp(scope) {
-            const cfgPath = scope === 'user'
-                ? join(homedir(), '.gemini', 'settings.json')
-                : join(process.cwd(), '.gemini', 'settings.json');
-            return upsertJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        async installSkill(scope, skillContent) {
-            const instrPath = scope === 'user'
-                ? join(homedir(), '.gemini', 'GEMINI.md')
-                : join(process.cwd(), 'GEMINI.md');
-            return upsertSkillBlock(instrPath, stripFrontmatter(skillContent));
-        },
-        async removeMcp(scope) {
-            const cfgPath = scope === 'user'
-                ? join(homedir(), '.gemini', 'settings.json')
-                : join(process.cwd(), '.gemini', 'settings.json');
-            return removeJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        async removeSkill(scope) {
-            const instrPath = scope === 'user'
-                ? join(homedir(), '.gemini', 'GEMINI.md')
-                : join(process.cwd(), 'GEMINI.md');
-            return removeSkillBlock(instrPath);
-        },
-    },
-    // ---- antigravity ----
-    {
-        id: 'antigravity',
-        name: 'Antigravity',
-        detect: () => existsSync(join(homedir(), '.gemini', 'antigravity')),
-        isMcpConfigured(_scope) {
-            const cfgPath = join(homedir(), '.gemini', 'antigravity', 'mcp_config.json');
-            return hasJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        isSkillConfigured(_scope) {
-            const instrPath = join(homedir(), '.gemini', 'GEMINI.md');
-            return hasSkillBlock(instrPath);
-        },
-        async installMcp(_scope) {
-            const cfgPath = join(homedir(), '.gemini', 'antigravity', 'mcp_config.json');
-            return upsertJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        async installSkill(_scope, skillContent) {
-            const instrPath = join(homedir(), '.gemini', 'GEMINI.md');
-            return upsertSkillBlock(instrPath, stripFrontmatter(skillContent));
-        },
-        async removeMcp(_scope) {
-            const cfgPath = join(homedir(), '.gemini', 'antigravity', 'mcp_config.json');
-            return removeJsonMcpServer(cfgPath, 'mcpServers');
-        },
-        async removeSkill(_scope) {
-            const instrPath = join(homedir(), '.gemini', 'GEMINI.md');
-            return removeSkillBlock(instrPath);
-        },
-    },
-    // ---- codex ----
-    {
-        id: 'codex',
-        name: 'Codex',
-        detect: () => existsSync(join(homedir(), '.codex')),
-        isMcpConfigured(scope) {
-            const cfgPath = scope === 'user'
-                ? join(homedir(), '.codex', 'config.toml')
-                : join(process.cwd(), '.codex', 'config.toml');
-            return hasTomlMcpServer(cfgPath);
-        },
-        isSkillConfigured(scope) {
-            const instrPath = scope === 'user'
-                ? join(homedir(), '.codex', 'AGENTS.md')
-                : join(process.cwd(), 'AGENTS.md');
-            return hasSkillBlock(instrPath);
-        },
-        async installMcp(scope) {
-            const cfgPath = scope === 'user'
-                ? join(homedir(), '.codex', 'config.toml')
-                : join(process.cwd(), '.codex', 'config.toml');
-            return upsertTomlMcpServer(cfgPath);
-        },
-        async installSkill(scope, skillContent) {
-            const instrPath = scope === 'user'
-                ? join(homedir(), '.codex', 'AGENTS.md')
-                : join(process.cwd(), 'AGENTS.md');
-            return upsertSkillBlock(instrPath, stripFrontmatter(skillContent));
-        },
-        async removeMcp(scope) {
-            const cfgPath = scope === 'user'
-                ? join(homedir(), '.codex', 'config.toml')
-                : join(process.cwd(), '.codex', 'config.toml');
-            return removeTomlMcpServer(cfgPath);
-        },
-        async removeSkill(scope) {
-            const instrPath = scope === 'user'
-                ? join(homedir(), '.codex', 'AGENTS.md')
-                : join(process.cwd(), 'AGENTS.md');
-            return removeSkillBlock(instrPath);
-        },
-    },
-];
-async function runInstall(ctx, rest) {
-    let parsed;
-    try {
-        parsed = parseArgs({
-            args: rest,
-            options: {
-                scope: { type: 'string', default: 'user' },
-                target: { type: 'string' },
-                json: { type: 'boolean', default: false },
-                human: { type: 'boolean', default: false },
-            },
-            allowPositionals: false,
-        });
-    }
-    catch (err) {
-        emitEnvelope({
-            code: 'invalid_invocation',
-            message: err instanceof Error ? err.message : String(err),
-            exampleCli: 'jinn plugin install --scope user',
-            details: { field: 'flags' },
-        }, { writer: ctx.writer, exit: ctx.exit });
-        return;
-    }
-    const scope = parsed.values.scope === 'project' ? 'project' : 'user';
-    const targetFilter = parsed.values.target;
-    let skillContent;
-    try {
-        skillContent = loadSkillContent();
-    }
-    catch (err) {
-        emitEnvelope({
-            code: 'fatal',
-            message: `Failed to load skill content: ${err instanceof Error ? err.message : String(err)}`,
-            details: { skillDir: SKILL_DIR },
-        }, { writer: ctx.writer, exit: ctx.exit });
-        return;
-    }
-    const targets = targetFilter
-        ? TARGETS.filter((t) => t.id === targetFilter)
-        : TARGETS;
-    if (targetFilter && targets.length === 0) {
-        emitEnvelope({
-            code: 'invalid_invocation',
-            message: `Unknown target: ${targetFilter}`,
-            exampleCli: 'jinn plugin list',
-            details: { field: '--target', expected: TARGETS.map((t) => t.id).join('|') },
-        }, { writer: ctx.writer, exit: ctx.exit });
-        return;
-    }
-    const results = [];
-    for (const target of targets) {
-        if (!target.detect()) {
-            if (targetFilter) {
-                results.push({
-                    target: target.id,
-                    mcp: { status: 'not_found', detail: `${target.name} not detected` },
-                    skill: { status: 'not_found', detail: `${target.name} not detected` },
-                });
-            }
-            continue;
-        }
-        let mcpResult;
-        if (target.isMcpConfigured(scope)) {
-            mcpResult = { status: 'skipped', detail: 'Already configured' };
-        }
-        else {
-            const r = await target.installMcp(scope);
-            mcpResult = { status: r.ok ? 'configured' : 'error', detail: r.detail };
-        }
-        // Always run installSkill — the helpers handle both fresh installs and
-        // updates (replacing existing content), so skill changes propagate when
-        // the package is upgraded and `jinn plugin install` is re-run.
-        const sr = await target.installSkill(scope, skillContent);
-        const skillResult = { status: sr.ok ? 'configured' : 'error', detail: sr.detail };
-        results.push({ target: target.id, mcp: mcpResult, skill: skillResult });
-    }
-    emitResult({
-        schemaVersion: 1,
-        generatedAt: new Date().toISOString(),
-        verb: 'plugin install',
-        results,
-    }, (v) => {
-        const data = v;
-        if (data.results.length === 0)
-            return 'No targets detected.';
-        const maxLen = Math.max(...data.results.map((r) => r.target.length));
-        return data.results
-            .map((r) => `${r.target.padEnd(maxLen + 2)}MCP: ${r.mcp.status.padEnd(12)}Skill: ${r.skill.status}`)
-            .join('\n');
-    }, {
-        json: Boolean(parsed.values.json),
-        human: Boolean(parsed.values.human),
-        writer: ctx.writer,
-        stdoutIsTty: ctx.stdoutIsTty,
-        noColor: Boolean(ctx.env['NO_COLOR']),
-    });
-}
-// ---------------------------------------------------------------------------
-// Subverb: remove
-// ---------------------------------------------------------------------------
-async function runRemove(ctx, rest) {
-    let parsed;
-    try {
-        parsed = parseArgs({
-            args: rest,
-            options: {
-                scope: { type: 'string', default: 'user' },
-                target: { type: 'string' },
-                json: { type: 'boolean', default: false },
-                human: { type: 'boolean', default: false },
-            },
-            allowPositionals: false,
-        });
-    }
-    catch (err) {
-        emitEnvelope({
-            code: 'invalid_invocation',
-            message: err instanceof Error ? err.message : String(err),
-            exampleCli: 'jinn plugin remove --target claude-code',
-            details: { field: 'flags' },
-        }, { writer: ctx.writer, exit: ctx.exit });
-        return;
-    }
-    const scope = parsed.values.scope === 'project' ? 'project' : 'user';
-    const targetFilter = parsed.values.target;
-    const targets = targetFilter
-        ? TARGETS.filter((t) => t.id === targetFilter)
-        : TARGETS;
-    if (targetFilter && targets.length === 0) {
-        emitEnvelope({
-            code: 'invalid_invocation',
-            message: `Unknown target: ${targetFilter}`,
-            exampleCli: 'jinn plugin list',
-            details: { field: '--target', expected: TARGETS.map((t) => t.id).join('|') },
-        }, { writer: ctx.writer, exit: ctx.exit });
-        return;
-    }
-    const results = [];
-    for (const target of targets) {
-        if (!target.detect()) {
-            if (targetFilter) {
-                results.push({
-                    target: target.id,
-                    mcp: { status: 'not_found', detail: `${target.name} not detected` },
-                    skill: { status: 'not_found', detail: `${target.name} not detected` },
-                });
-            }
-            continue;
-        }
-        let mcpResult;
-        if (!target.isMcpConfigured(scope)) {
-            mcpResult = { status: 'skipped', detail: 'Not configured' };
-        }
-        else {
-            const r = await target.removeMcp(scope);
-            mcpResult = { status: r.ok ? 'removed' : 'error', detail: r.detail };
-        }
-        let skillResult;
-        if (!target.isSkillConfigured(scope)) {
-            skillResult = { status: 'skipped', detail: 'Not configured' };
-        }
-        else {
-            const r = await target.removeSkill(scope);
-            skillResult = { status: r.ok ? 'removed' : 'error', detail: r.detail };
-        }
-        results.push({ target: target.id, mcp: mcpResult, skill: skillResult });
-    }
-    emitResult({
-        schemaVersion: 1,
-        generatedAt: new Date().toISOString(),
-        verb: 'plugin remove',
-        results,
-    }, (v) => {
-        const data = v;
-        if (data.results.length === 0)
-            return 'No targets detected.';
-        const maxLen = Math.max(...data.results.map((r) => r.target.length));
-        return data.results
-            .map((r) => `${r.target.padEnd(maxLen + 2)}MCP: ${r.mcp.status.padEnd(12)}Skill: ${r.skill.status}`)
-            .join('\n');
-    }, {
-        json: Boolean(parsed.values.json),
-        human: Boolean(parsed.values.human),
-        writer: ctx.writer,
-        stdoutIsTty: ctx.stdoutIsTty,
-        noColor: Boolean(ctx.env['NO_COLOR']),
-    });
-}
-async function runList(ctx, rest) {
-    let parsed;
-    try {
-        parsed = parseArgs({
-            args: rest,
-            options: {
-                scope: { type: 'string', default: 'user' },
-                json: { type: 'boolean', default: false },
-                human: { type: 'boolean', default: false },
-            },
-            allowPositionals: false,
-        });
-    }
-    catch (err) {
-        emitEnvelope({
-            code: 'invalid_invocation',
-            message: err instanceof Error ? err.message : String(err),
-            exampleCli: 'jinn plugin list',
-            details: { field: 'flags' },
-        }, { writer: ctx.writer, exit: ctx.exit });
-        return;
-    }
-    const scope = parsed.values.scope === 'project' ? 'project' : 'user';
-    const targets = TARGETS.map((t) => {
-        const detected = t.detect();
-        return {
-            id: t.id,
-            name: t.name,
-            detected,
-            mcpConfigured: detected ? t.isMcpConfigured(scope) : false,
-            skillConfigured: detected ? t.isSkillConfigured(scope) : false,
-        };
-    });
-    emitResult({
-        schemaVersion: 1,
-        generatedAt: new Date().toISOString(),
-        verb: 'plugin list',
-        targets,
-    }, (v) => {
-        const data = v;
-        const maxLen = Math.max(...data.targets.map((t) => t.id.length));
-        return data.targets
-            .map((t) => {
-            if (!t.detected)
-                return `${t.id.padEnd(maxLen + 2)}not found`;
-            return `${t.id.padEnd(maxLen + 2)}detected   MCP: ${t.mcpConfigured ? 'yes' : 'no'}    Skill: ${t.skillConfigured ? 'yes' : 'no'}`;
-        })
-            .join('\n');
-    }, {
-        json: Boolean(parsed.values.json),
-        human: Boolean(parsed.values.human),
-        writer: ctx.writer,
-        stdoutIsTty: ctx.stdoutIsTty,
-        noColor: Boolean(ctx.env['NO_COLOR']),
-    });
-}
-// ---------------------------------------------------------------------------
-// Verb dispatcher
-// ---------------------------------------------------------------------------
-async function run(ctx) {
-    const [subverb, ...rest] = ctx.argv;
-    if (!subverb) {
-        emitEnvelope({
-            code: 'invalid_invocation',
-            message: 'jinn plugin requires a subverb: install, remove, list',
-            exampleCli: 'jinn plugin install',
-            details: { field: 'subverb', expected: 'install|remove|list' },
-        }, { writer: ctx.writer, exit: ctx.exit });
-        return;
-    }
-    switch (subverb) {
-        case 'install':
-            return runInstall(ctx, rest);
-        case 'remove':
-            return runRemove(ctx, rest);
-        case 'list':
-            return runList(ctx, rest);
-        default:
-            emitEnvelope({
-                code: 'invalid_invocation',
-                message: `Unknown plugin subverb: ${subverb}`,
-                exampleCli: 'jinn plugin install',
-                details: { field: 'subverb', expected: 'install|remove|list' },
-            }, { writer: ctx.writer, exit: ctx.exit });
-    }
-}
-const command = {
-    name: 'plugin',
-    summary: 'Configure AI tools to use Jinn MCP server and operator skill',
-    helpText: `Usage: jinn plugin <install|remove|list> [options]
-
-Subcommands:
-  install   Configure detected AI tools with Jinn MCP server and operator skill
-  remove    Remove Jinn configuration from AI tools
-  list      Show detected AI tools and their configuration status
-
-Options:
-  --scope <user|project>   Install scope (default: user)
-  --target <id>            Configure only this target
-  --json                   JSON output (default)
-  --human                  Human-readable output
-
-Supported targets:
-  claude-code      Claude Code CLI
-  claude-desktop   Claude Desktop app
-  cursor           Cursor editor
-  vscode           VS Code (Copilot)
-  gemini-cli       Gemini CLI
-  antigravity      Antigravity (Gemini)
-  codex            OpenAI Codex CLI
-
-Examples:
-  jinn plugin list --human
-  jinn plugin install --human
-  jinn plugin install --target claude-code --human
-  jinn plugin install --scope project --target cursor
-  jinn plugin remove --target claude-code
-`,
-    run,
-};
-export default command;
-//# sourceMappingURL=plugin-install.js.map