brainctl 0.1.18 → 0.1.20

package/dist/cli.d.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { type DoctorService } from './services/doctor-service.js';
-import { type ProfileApplyService } from './services/profile-apply-service.js';
-import { type ProfileExportService } from './services/profile-export-service.js';
-import { type ProfileImportService } from './services/profile-import-service.js';
-import { type ProfileService } from './services/profile-service.js';
-import { type ProfileSnapshotService } from './services/profile-snapshot-service.js';
-import { type StatusService } from './services/status-service.js';
+import { type DoctorService } from './services/platform/doctor-service.js';
+import { type ProfileApplyService } from './services/profile/profile-apply-service.js';
+import { type ProfileExportService } from './services/profile/profile-export-service.js';
+import { type ProfileImportService } from './services/profile/profile-import-service.js';
+import { type ProfileService } from './services/profile/profile-service.js';
+import { type ProfileSnapshotService } from './services/profile/profile-snapshot-service.js';
+import { type StatusService } from './services/platform/status-service.js';
 export interface CliServices {
     statusService: StatusService;
     doctorService: DoctorService;

package/dist/cli.js

@@ -10,15 +10,15 @@ import { registerProfileCommand } from './commands/profile.js';
 import { registerStatusCommand } from './commands/status.js';
 import { registerUiCommand } from './commands/ui.js';
 import { printError } from './output.js';
-import { createUpdateCheckService } from './services/update-check-service.js';
-import { createDoctorService } from './services/doctor-service.js';
-import { createProfileApplyService } from './services/profile-apply-service.js';
-import { createProfileExportService } from './services/profile-export-service.js';
-import { createProfileImportService } from './services/profile-import-service.js';
-import { createProfileService } from './services/profile-service.js';
-import { createProfileSnapshotService } from './services/profile-snapshot-service.js';
-import { createStatusService } from './services/status-service.js';
-import { createAgentAvailabilityService } from './services/agent-availability-service.js';
+import { createUpdateCheckService } from './services/platform/update-check-service.js';
+import { createDoctorService } from './services/platform/doctor-service.js';
+import { createProfileApplyService } from './services/profile/profile-apply-service.js';
+import { createProfileExportService } from './services/profile/profile-export-service.js';
+import { createProfileImportService } from './services/profile/profile-import-service.js';
+import { createProfileService } from './services/profile/profile-service.js';
+import { createProfileSnapshotService } from './services/profile/profile-snapshot-service.js';
+import { createStatusService } from './services/platform/status-service.js';
+import { createAgentAvailabilityService } from './services/agent/agent-availability-service.js';
 const packageVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export function createProgram(overrides = {}) {
     const services = createDefaultServices(overrides);

package/dist/commands/doctor.d.ts

@@ -1,3 +1,3 @@
 import type { Command } from 'commander';
-import type { DoctorService } from '../services/doctor-service.js';
+import type { DoctorService } from '../services/platform/doctor-service.js';
 export declare function registerDoctorCommand(program: Command, doctorService: DoctorService): void;

package/dist/commands/mcp.js

@@ -1,44 +1,57 @@
-import { spawn } from 'node:child_process';
-import { startMcpServer } from '../mcp/server.js';
-import { createUpdateCheckService } from '../services/update-check-service.js';
+import { spawnSync } from 'node:child_process';
+import { startMcpServer } from '../mcp-server.js';
+import { createUpdateCheckService } from '../services/platform/update-check-service.js';
 export function registerMcpCommand(program) {
     program
         .command('mcp')
         .description('Start the brainctl MCP server (stdio transport)')
         .action(async () => {
+        killPriorMcpServers();
+        process.stdin.on('end', () => process.exit(0));
+        process.stdin.on('close', () => process.exit(0));
+        await startMcpServer({ cwd: process.cwd() });
         if (!process.env.BRAINCTL_NO_UPDATE_CHECK) {
-            await autoUpdateIfNeeded();
+            // Fire-and-forget after the server is up so cold-start isn't blocked
+            // on a network round-trip (or `npm install brainctl@latest`).
+            void notifyIfOutdated();
         }
-        await startMcpServer({ cwd: process.cwd() });
     });
 }
-async function autoUpdateIfNeeded() {
+function killPriorMcpServers() {
+    const self = process.pid;
+    const ppid = process.ppid;
     try {
-        const service = createUpdateCheckService();
-        const check = await service.check();
-        if (!check.isOutdated)
-            return;
-        const result = await service.selfUpdate();
-        if (result.success) {
-            // Re-exec with the updated binary
-            const child = spawn(process.execPath, process.argv.slice(1), {
-                stdio: 'inherit',
-            });
-            await new Promise((resolve) => {
-                child.on('exit', (code) => {
-                    process.exit(code ?? 0);
-                });
-                child.on('error', () => {
-                    resolve(); // fall through to current version
-                });
-            });
+        const result = spawnSync('pgrep', ['-f', 'brainctl/dist/cli\\.js mcp'], {
+            encoding: 'utf8',
+        });
+        if (result.status !== 0 || !result.stdout)
             return;
+        const pids = result.stdout
+            .split('\n')
+            .map((line) => Number.parseInt(line.trim(), 10))
+            .filter((pid) => Number.isFinite(pid) && pid !== self && pid !== ppid);
+        for (const pid of pids) {
+            try {
+                process.kill(pid, 'SIGTERM');
+            }
+            catch {
+                // already gone
+            }
         }
-        if (result.error) {
-            process.stderr.write(`brainctl: auto-update failed: ${result.error}\n`);
+    }
+    catch {
+        // pgrep unavailable — skip
+    }
+}
+async function notifyIfOutdated() {
+    try {
+        const service = createUpdateCheckService();
+        const check = await service.check();
+        if (check.isOutdated) {
+            process.stderr.write(`brainctl: a newer version is available (${check.latest}). Run \`npm i -g brainctl@latest\` to update.\n`);
         }
     }
     catch {
-        // Update check failed entirely — continue silently
+        // Update check failed — stay silent
     }
 }

package/dist/commands/profile.d.ts

@@ -1,9 +1,9 @@
 import type { Command } from 'commander';
-import type { ProfileApplyService } from '../services/profile-apply-service.js';
-import type { ProfileExportService } from '../services/profile-export-service.js';
-import type { ProfileImportService } from '../services/profile-import-service.js';
-import type { ProfileService } from '../services/profile-service.js';
-import type { ProfileSnapshotService } from '../services/profile-snapshot-service.js';
+import type { ProfileApplyService } from '../services/profile/profile-apply-service.js';
+import type { ProfileExportService } from '../services/profile/profile-export-service.js';
+import type { ProfileImportService } from '../services/profile/profile-import-service.js';
+import type { ProfileService } from '../services/profile/profile-service.js';
+import type { ProfileSnapshotService } from '../services/profile/profile-snapshot-service.js';
 export interface ProfileCommandServices {
     profileService: ProfileService;
     profileExportService: ProfileExportService;

package/dist/commands/profile.js

@@ -131,7 +131,7 @@ export function registerProfileCommand(program, services) {
             throw new Error('Provide --agent <claude|codex|gemini>.');
         }
         const agent = options.agent;
-        const { defaultBackupProfileName } = await import('../services/profile-snapshot-service.js');
+        const { defaultBackupProfileName } = await import('../services/profile/profile-snapshot-service.js');
         const profileName = options.as ?? defaultBackupProfileName(agent);
         const result = await profileSnapshotService.execute({
             cwd: process.cwd(),

package/dist/commands/status.d.ts

@@ -1,3 +1,3 @@
 import type { Command } from 'commander';
-import type { StatusService } from '../services/status-service.js';
+import type { StatusService } from '../services/platform/status-service.js';
 export declare function registerStatusCommand(program: Command, statusService: StatusService): void;

package/dist/{mcp/server.d.ts → mcp-server.d.ts}

@@ -1,5 +1,5 @@
 import { FastMCP } from 'fastmcp';
-import { type UiServer } from '../ui/server.js';
+import { type UiServer } from './ui/server.js';
 export interface UiServerState {
     current: UiServer | null;
 }

package/dist/{mcp/server.js → mcp-server.js}

@@ -2,17 +2,17 @@ import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { FastMCP } from 'fastmcp';
 import { z } from 'zod';
-import { createAgentConfigService } from '../services/agent-config-service.js';
-import { createDoctorService } from '../services/doctor-service.js';
-import { startUiServer } from '../ui/server.js';
-import { createProfileExportService } from '../services/profile-export-service.js';
-import { createProfileImportService } from '../services/profile-import-service.js';
-import { createProfileApplyService } from '../services/profile-apply-service.js';
-import { createProfileService } from '../services/profile-service.js';
-import { createProfileSnapshotService, defaultBackupProfileName, } from '../services/profile-snapshot-service.js';
-import { createStatusService } from '../services/status-service.js';
+import { createAgentConfigService } from './services/agent/agent-config-service.js';
+import { createDoctorService } from './services/platform/doctor-service.js';
+import { startUiServer } from './ui/server.js';
+import { createProfileExportService } from './services/profile/profile-export-service.js';
+import { createProfileImportService } from './services/profile/profile-import-service.js';
+import { createProfileApplyService } from './services/profile/profile-apply-service.js';
+import { createProfileService } from './services/profile/profile-service.js';
+import { createProfileSnapshotService, defaultBackupProfileName, } from './services/profile/profile-snapshot-service.js';
+import { createStatusService } from './services/platform/status-service.js';
 const ALL_AGENTS = ['claude', 'codex', 'gemini'];
-const packageVersion = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+const packageVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export function createMcpServer(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const uiState = options.uiServerState ?? { current: null };

package/dist/services/agent/agent-asset-installer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentName, PortablePluginSnapshot, PortableUserSkillSnapshot } from '../../types.js';
+export declare function installPlugin(sourceDir: string, plugin: PortablePluginSnapshot, targetAgent?: AgentName): Promise<void>;
+export declare function installUserSkill(sourceDir: string, skill: PortableUserSkillSnapshot, targetAgent?: PortableUserSkillSnapshot['agent']): Promise<void>;

package/dist/services/{agent-asset-installer.js → agent/agent-asset-installer.js}

@@ -1,15 +1,23 @@
 import { copyFile, cp, mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
-import { ProfileError } from '../errors.js';
-import { formatTimestamp } from './sync/agent-writer.js';
-export async function installPlugin(sourceDir, plugin) {
+import { ProfileError } from '../../errors.js';
+import { defaultReadInstalledPluginBundle, isAgentInstallableOnTarget, isCommandInstallableOnTarget, } from '../plugin/plugin-install-bundle.js';
+import { defaultCopySkillDirectory, defaultInstallAgent, defaultInstallCommand, } from '../plugin/plugin-install-fs.js';
+import { writeManagedPluginInstall } from '../sync/managed-plugin-registry.js';
+import { formatTimestamp } from '../sync/agent-writer.js';
+export async function installPlugin(sourceDir, plugin, targetAgent) {
     try {
         await stat(sourceDir);
     }
     catch {
         throw new ProfileError(`Bundled plugin "${plugin.name}" source missing at ${sourceDir}.`);
     }
+    const target = targetAgent ?? plugin.agent;
+    if (target !== plugin.agent) {
+        await installPluginCrossAgent(sourceDir, plugin, target);
+        return;
+    }
     if (plugin.agent === 'gemini') {
         return;
     }
@@ -34,14 +42,52 @@ export async function installPlugin(sourceDir, plugin) {
         });
     }
 }
-export async function installUserSkill(sourceDir, skill) {
+async function installPluginCrossAgent(sourceDir, plugin, targetAgent) {
+    const bundle = await defaultReadInstalledPluginBundle(sourceDir);
+    for (const skillName of bundle.skills) {
+        await defaultCopySkillDirectory({
+            sourceInstallPath: sourceDir,
+            skillName,
+            targetAgent,
+        });
+    }
+    const installedAgents = [];
+    if (isAgentInstallableOnTarget(targetAgent)) {
+        for (const agent of bundle.agents) {
+            await defaultInstallAgent({ targetAgent, agent });
+            installedAgents.push(agent.name);
+        }
+    }
+    const installedCommands = [];
+    if (isCommandInstallableOnTarget(targetAgent)) {
+        for (const command of bundle.commands) {
+            await defaultInstallCommand({ targetAgent, command });
+            installedCommands.push(command.name);
+        }
+    }
+    await writeManagedPluginInstall({
+        agent: targetAgent,
+        plugin: {
+            name: plugin.name,
+            kind: 'plugin',
+            managed: true,
+            source: plugin.source,
+            pluginSkills: bundle.skills,
+            pluginMcps: Object.keys(bundle.mcps),
+            pluginAgents: installedAgents,
+            pluginCommands: installedCommands,
+        },
+    });
+}
+export async function installUserSkill(sourceDir, skill, targetAgent) {
     try {
         await stat(sourceDir);
     }
     catch {
         throw new ProfileError(`Bundled user skill "${skill.name}" source missing at ${sourceDir}.`);
     }
-    const targetDir = path.join(homedir(), `.${skill.agent}`, 'skills', skill.name);
+    const agent = targetAgent ?? skill.agent;
+    const targetDir = path.join(homedir(), `.${agent}`, 'skills', skill.name);
     await rm(targetDir, { recursive: true, force: true });
     await mkdir(path.dirname(targetDir), { recursive: true });
     await cp(sourceDir, targetDir, { recursive: true });

package/dist/services/{agent-availability-service.d.ts → agent/agent-availability-service.d.ts}

@@ -1,4 +1,4 @@
-import type { AgentName } from '../types.js';
+import type { AgentName } from '../../types.js';
 export interface AgentAvailability {
     agent: AgentName;
     available: boolean;

package/dist/services/{agent-availability-service.js → agent/agent-availability-service.js}

@@ -1,4 +1,4 @@
-import { findExecutable } from '../system/executables.js';
+import { findExecutable } from '../../executables.js';
 const SUPPORTED_AGENTS = ['claude', 'codex', 'gemini'];
 const AGENT_COMMANDS = {
     claude: 'claude',

package/dist/services/{agent-config-service.d.ts → agent/agent-config-service.d.ts}

@@ -1,9 +1,9 @@
-import type { AgentName } from '../types.js';
-import { type AgentLiveConfig, type AgentMcpEntry, type PortableRemoteMcpMetadata } from './sync/agent-reader.js';
-import { type McpPreflightService } from './mcp-preflight-service.js';
-import { type SkillPreflightService } from './skill-preflight-service.js';
-export type { AgentLiveConfig, AgentMcpEntry, AgentSkillEntry } from './sync/agent-reader.js';
-export type { PortableRemoteMcpMetadata } from './sync/agent-reader.js';
+import type { AgentName } from '../../types.js';
+import { type AgentLiveConfig, type AgentMcpEntry, type PortableRemoteMcpMetadata } from '../sync/agent-reader.js';
+import { type McpPreflightService } from '../platform/mcp-preflight-service.js';
+import { type SkillPreflightService } from '../plugin/skill-preflight-service.js';
+export type { AgentLiveConfig, AgentMcpEntry, AgentSkillEntry } from '../sync/agent-reader.js';
+export type { PortableRemoteMcpMetadata } from '../sync/agent-reader.js';
 export interface AgentConfigService {
     readAll(options: {
         cwd: string;

package/dist/services/{agent-config-service.js → agent/agent-config-service.js}

@@ -1,12 +1,12 @@
 import { copyFile, cp, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
-import { ValidationError } from '../errors.js';
-import { createClaudeReader, createCodexReader, createGeminiReader, } from './sync/agent-reader.js';
-import { formatTimestamp } from './sync/agent-writer.js';
-import { createMcpPreflightService } from './mcp-preflight-service.js';
-import { createSkillPreflightService } from './skill-preflight-service.js';
-import { getSkillDir } from './skill-paths.js';
+import { ValidationError } from '../../errors.js';
+import { createClaudeReader, createCodexReader, createGeminiReader, } from '../sync/agent-reader.js';
+import { formatTimestamp } from '../sync/agent-writer.js';
+import { createMcpPreflightService } from '../platform/mcp-preflight-service.js';
+import { createSkillPreflightService } from '../plugin/skill-preflight-service.js';
+import { getSkillDir } from '../plugin/skill-paths.js';
 const readers = {
     claude: createClaudeReader(),
     codex: createCodexReader(),

package/dist/services/{credential-redaction-service.d.ts → credential/credential-redaction-service.d.ts}

@@ -1,4 +1,4 @@
-import type { McpServerConfig, PortableCredentialSpec } from '../types.js';
+import type { McpServerConfig, PortableCredentialSpec } from '../../types.js';
 export interface CredentialRedactionResult<T extends McpServerConfig> {
     redacted: T;
     credentials: PortableCredentialSpec[];

package/dist/services/{credential-resolution-service.d.ts → credential/credential-resolution-service.d.ts}

@@ -1,4 +1,4 @@
-import type { McpServerConfig, PortableCredentialPlaceholder, PortableCredentialSpec } from '../types.js';
+import type { McpServerConfig, PortableCredentialPlaceholder, PortableCredentialSpec } from '../../types.js';
 export interface CredentialResolutionResult<T extends McpServerConfig> {
     resolved: T;
     missing: PortableCredentialSpec[];

package/dist/services/{doctor-service.d.ts → platform/doctor-service.d.ts}

@@ -1,5 +1,5 @@
-import { type AgentAvailabilityService } from './agent-availability-service.js';
-import type { DiagnosticCheck } from '../types.js';
+import { type AgentAvailabilityService } from '../agent/agent-availability-service.js';
+import type { DiagnosticCheck } from '../../types.js';
 export interface DoctorResult {
     checks: DiagnosticCheck[];
     hasIssues: boolean;

package/dist/services/{doctor-service.js → platform/doctor-service.js}

@@ -1,4 +1,4 @@
-import { createAgentAvailabilityService, } from './agent-availability-service.js';
+import { createAgentAvailabilityService, } from '../agent/agent-availability-service.js';
 export function createDoctorService(dependencies = {}) {
     const availabilityService = dependencies.availabilityService ?? createAgentAvailabilityService();
     return {

package/dist/services/{mcp-preflight-service.d.ts → platform/mcp-preflight-service.d.ts}

@@ -1,5 +1,5 @@
-import type { AgentName } from '../types.js';
-import type { AgentMcpEntry, PortableRemoteMcpMetadata } from './agent-config-service.js';
+import type { AgentName } from '../../types.js';
+import type { AgentMcpEntry, PortableRemoteMcpMetadata } from '../agent/agent-config-service.js';
 export interface McpPreflightCheck {
     label: string;
     status: 'ok' | 'warn' | 'error';

package/dist/services/{mcp-preflight-service.js → platform/mcp-preflight-service.js}

@@ -1,6 +1,6 @@
 import { stat } from 'node:fs/promises';
 import path from 'node:path';
-import { findExecutable } from '../system/executables.js';
+import { findExecutable } from '../../executables.js';
 const ENTRYPOINT_RUNNERS = new Set(['node', 'nodejs', 'python', 'python3', 'bash', 'sh', 'zsh', 'deno', 'bun']);
 const SUPPORTED_LOCAL_LAUNCHERS = ['npx', 'uvx', 'node', 'python', 'python3', 'java -jar', 'go run', 'cargo run', 'and local binaries/scripts'];
 export function createMcpPreflightService(dependencies = {}) {

package/dist/services/{runtime-detector.d.ts → platform/runtime-detector.d.ts}

@@ -1,4 +1,4 @@
-import type { McpRuntime } from '../types.js';
+import type { McpRuntime } from '../../types.js';
 export declare function detectMcpRuntime(command: string): McpRuntime | null;
 export declare function extractEntrypoint(command: string, args: string[]): string | null;
 export declare function findProjectRoot(entrypointPath: string, runtime: McpRuntime): {

package/dist/services/{status-service.d.ts → platform/status-service.d.ts}

@@ -1,6 +1,6 @@
-import { type AgentAvailability, type AgentAvailabilityService } from './agent-availability-service.js';
-import { type ProfileService } from './profile-service.js';
-import type { AgentName } from '../types.js';
+import { type AgentAvailability, type AgentAvailabilityService } from '../agent/agent-availability-service.js';
+import { type ProfileService } from '../profile/profile-service.js';
+import type { AgentName } from '../../types.js';
 export interface StatusResult {
     agents: Record<AgentName, AgentAvailability>;
     profiles: {

package/dist/services/{status-service.js → platform/status-service.js}

@@ -1,5 +1,5 @@
-import { createAgentAvailabilityService, } from './agent-availability-service.js';
-import { createProfileService } from './profile-service.js';
+import { createAgentAvailabilityService, } from '../agent/agent-availability-service.js';
+import { createProfileService } from '../profile/profile-service.js';
 export function createStatusService(dependencies = {}) {
     const availabilityService = dependencies.availabilityService ?? createAgentAvailabilityService();
     const profileService = dependencies.profileService ?? createProfileService();

package/dist/services/{update-check-service.js → platform/update-check-service.js}

@@ -9,7 +9,7 @@ const execFileAsync = promisify(execFile);
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 const CACHE_DIR = path.join(homedir(), '.brainctl');
 const CACHE_PATH = path.join(CACHE_DIR, 'update-check.json');
-const packageVersion = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+const packageVersion = JSON.parse(readFileSync(new URL('../../../package.json', import.meta.url), 'utf8'));
 export function createUpdateCheckService(dependencies = {}) {
     const currentVersion = dependencies.currentVersion ?? packageVersion.version;
     const fetchLatestVersion = dependencies.fetchLatestVersion ?? fetchFromRegistry;

package/dist/services/plugin/plugin-install-bundle.d.ts

@@ -0,0 +1,20 @@
+import type { AgentName } from '../../types.js';
+import type { AgentMcpEntry } from '../agent/agent-config-service.js';
+export interface PluginBundleAgent {
+    name: string;
+    sourceFormat: 'claude-md' | 'codex-toml';
+    content: string;
+}
+export interface PluginBundleCommand {
+    name: string;
+    content: string;
+}
+export interface PluginBundle {
+    skills: string[];
+    mcps: Record<string, AgentMcpEntry>;
+    agents: PluginBundleAgent[];
+    commands: PluginBundleCommand[];
+}
+export declare function isAgentInstallableOnTarget(target: AgentName): boolean;
+export declare function isCommandInstallableOnTarget(target: AgentName): boolean;
+export declare function defaultReadInstalledPluginBundle(installPath: string): Promise<PluginBundle>;

package/dist/services/plugin/plugin-install-bundle.js

@@ -0,0 +1,80 @@
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+export function isAgentInstallableOnTarget(target) {
+    return target === 'claude' || target === 'codex';
+}
+export function isCommandInstallableOnTarget(target) {
+    return target === 'claude' || target === 'codex';
+}
+export async function defaultReadInstalledPluginBundle(installPath) {
+    const skillsDir = path.join(installPath, 'skills');
+    let skills = [];
+    try {
+        const entries = await readdir(skillsDir, { withFileTypes: true });
+        skills = entries
+            .filter((entry) => !entry.name.startsWith('.') && entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        skills = [];
+    }
+    let mcps = {};
+    try {
+        const mcpSource = await readFile(path.join(installPath, '.mcp.json'), 'utf8');
+        const parsed = JSON.parse(mcpSource);
+        mcps = Object.fromEntries(Object.entries(parsed)
+            .filter(([, value]) => typeof value?.command === 'string')
+            .map(([key, value]) => [
+            key,
+            {
+                command: String(value.command),
+                args: Array.isArray(value.args) ? value.args.map(String) : undefined,
+                env: value.env && typeof value.env === 'object' && !Array.isArray(value.env)
+                    ? Object.fromEntries(Object.entries(value.env).map(([envKey, envValue]) => [
+                        envKey,
+                        String(envValue),
+                    ]))
+                    : undefined,
+            },
+        ]));
+    }
+    catch {
+        mcps = {};
+    }
+    const agents = [];
+    try {
+        const entries = await readdir(path.join(installPath, 'agents'), { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            if (entry.name.endsWith('.md')) {
+                const content = await readFile(path.join(installPath, 'agents', entry.name), 'utf8');
+                agents.push({ name: entry.name.replace(/\.md$/, ''), sourceFormat: 'claude-md', content });
+            }
+            else if (entry.name.endsWith('.toml')) {
+                const content = await readFile(path.join(installPath, 'agents', entry.name), 'utf8');
+                agents.push({ name: entry.name.replace(/\.toml$/, ''), sourceFormat: 'codex-toml', content });
+            }
+        }
+        agents.sort((left, right) => left.name.localeCompare(right.name));
+    }
+    catch {
+        // no agents dir
+    }
+    const commands = [];
+    try {
+        const entries = await readdir(path.join(installPath, 'commands'), { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            const content = await readFile(path.join(installPath, 'commands', entry.name), 'utf8');
+            commands.push({ name: entry.name.replace(/\.md$/, ''), content });
+        }
+        commands.sort((left, right) => left.name.localeCompare(right.name));
+    }
+    catch {
+        // no commands dir
+    }
+    return { skills, mcps, agents, commands };
+}

package/dist/services/plugin/plugin-install-compatibility.d.ts

@@ -0,0 +1,15 @@
+import type { AgentName } from '../../types.js';
+import type { PluginInstallCheck } from './plugin-install-service.js';
+export interface IncompatibleArtifacts {
+    hasAppConnector: boolean;
+    hasHooks: boolean;
+    hasCommands: boolean;
+    codexAgentSkills: string[];
+    claudeAgents: string[];
+}
+export declare function pathExists(target: string): Promise<boolean>;
+export declare function detectIncompatibleArtifacts(installPath: string): Promise<IncompatibleArtifacts>;
+export declare function formatCompatibilityWarnings(artifacts: IncompatibleArtifacts, context: {
+    sourceAgent: AgentName;
+    targetAgent: AgentName;
+}): PluginInstallCheck[];