brainctl 0.1.17 → 0.1.19

package/dist/services/agent/agent-asset-installer.js

@@ -0,0 +1,109 @@
+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) {
+    try {
+        await stat(sourceDir);
+    }
+    catch {
+        throw new ProfileError(`Bundled plugin "${plugin.name}" source missing at ${sourceDir}.`);
+    }
+    if (plugin.agent === 'gemini') {
+        return;
+    }
+    const marketplace = plugin.marketplace ?? plugin.source;
+    const version = plugin.version ?? 'unknown';
+    const cacheRoot = path.join(homedir(), `.${plugin.agent}`, 'plugins', 'cache');
+    const targetDir = path.join(cacheRoot, marketplace, plugin.name, version);
+    await rm(targetDir, { recursive: true, force: true });
+    await mkdir(path.dirname(targetDir), { recursive: true });
+    await cp(sourceDir, targetDir, { recursive: true });
+    if (plugin.agent === 'claude') {
+        await registerClaudePlugin({
+            pluginKey: `${plugin.name}@${marketplace}`,
+            installPath: targetDir,
+            version,
+        });
+        return;
+    }
+    if (plugin.agent === 'codex') {
+        await registerCodexPlugin({
+            pluginKey: `${plugin.name}@${marketplace}`,
+        });
+    }
+}
+export async function installUserSkill(sourceDir, skill) {
+    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);
+    await rm(targetDir, { recursive: true, force: true });
+    await mkdir(path.dirname(targetDir), { recursive: true });
+    await cp(sourceDir, targetDir, { recursive: true });
+}
+async function registerClaudePlugin(options) {
+    const filePath = path.join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+    let existing = { version: 2, plugins: {} };
+    try {
+        const source = await readFile(filePath, 'utf8');
+        existing = JSON.parse(source);
+        await backupFile(filePath);
+    }
+    catch {
+        // fresh file
+    }
+    const plugins = (existing.plugins ?? {});
+    const now = new Date().toISOString();
+    const entry = {
+        scope: 'user',
+        installPath: options.installPath,
+        version: options.version,
+        installedAt: now,
+        lastUpdated: now,
+    };
+    plugins[options.pluginKey] = [entry];
+    existing.plugins = plugins;
+    if (typeof existing.version !== 'number')
+        existing.version = 2;
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await atomicWrite(filePath, JSON.stringify(existing, null, 2) + '\n');
+}
+async function registerCodexPlugin(options) {
+    const filePath = path.join(homedir(), '.codex', 'config.toml');
+    let existing = '';
+    try {
+        existing = await readFile(filePath, 'utf8');
+        await backupFile(filePath);
+    }
+    catch {
+        existing = '';
+    }
+    const header = `[plugins."${options.pluginKey}"]`;
+    if (existing.includes(header))
+        return;
+    const prefix = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+    const separator = existing.length > 0 ? '\n' : '';
+    const block = `${header}\nenabled = true\n`;
+    const next = existing + prefix + separator + block;
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await atomicWrite(filePath, next);
+}
+async function backupFile(filePath) {
+    const backupPath = `${filePath}.bak.${formatTimestamp()}`;
+    try {
+        await copyFile(filePath, backupPath);
+    }
+    catch {
+        // file may not exist
+    }
+}
+async function atomicWrite(filePath, content) {
+    const tmpPath = `${filePath}.tmp.${Date.now()}`;
+    await writeFile(tmpPath, content, 'utf8');
+    await rename(tmpPath, filePath);
+}

package/dist/services/agent/agent-availability-service.d.ts

@@ -0,0 +1,11 @@
+import type { AgentName } from '../../types.js';
+export interface AgentAvailability {
+    agent: AgentName;
+    available: boolean;
+    command: string;
+    resolvedPath?: string;
+}
+export interface AgentAvailabilityService {
+    getAll(): Promise<Record<AgentName, AgentAvailability>>;
+}
+export declare function createAgentAvailabilityService(): AgentAvailabilityService;

package/dist/services/agent/agent-availability-service.js

@@ -0,0 +1,32 @@
+import { findExecutable } from '../../executables.js';
+const SUPPORTED_AGENTS = ['claude', 'codex', 'gemini'];
+const AGENT_COMMANDS = {
+    claude: 'claude',
+    codex: 'codex',
+    gemini: 'gemini',
+};
+export function createAgentAvailabilityService() {
+    const cache = new Map();
+    const check = (agent) => {
+        if (!cache.has(agent)) {
+            cache.set(agent, checkAvailability(agent));
+        }
+        return cache.get(agent);
+    };
+    return {
+        async getAll() {
+            const entries = await Promise.all(SUPPORTED_AGENTS.map(async (agent) => [agent, await check(agent)]));
+            return Object.fromEntries(entries);
+        },
+    };
+}
+async function checkAvailability(agent) {
+    const command = AGENT_COMMANDS[agent];
+    const resolvedPath = await findExecutable(command);
+    return {
+        agent,
+        command,
+        available: resolvedPath !== null,
+        resolvedPath: resolvedPath ?? undefined,
+    };
+}

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,7 +1,8 @@
-import type { McpServerConfig, PortableCredentialSpec } from '../types.js';
+import type { McpServerConfig, PortableCredentialSpec } from '../../types.js';
 export interface CredentialRedactionResult<T extends McpServerConfig> {
     redacted: T;
     credentials: PortableCredentialSpec[];
+    rawValues: Record<string, string>;
 }
 export declare function redactPortableMcpCredentials<T extends McpServerConfig>(config: T): CredentialRedactionResult<T>;
 interface CredentialAccumulator {

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

@@ -1,8 +1,9 @@
 export function redactPortableMcpCredentials(config) {
     const credentialsByKey = new Map();
-    const redactedEnv = redactStringMap(config.env, 'env', credentialsByKey);
+    const rawValues = {};
+    const redactedEnv = redactStringMap(config.env, 'env', credentialsByKey, rawValues);
     if (config.kind === 'remote') {
-        const redactedHeaders = redactStringMap(config.headers, 'header', credentialsByKey);
+        const redactedHeaders = redactStringMap(config.headers, 'header', credentialsByKey, rawValues);
         return {
             redacted: {
                 ...config,
@@ -10,6 +11,7 @@ export function redactPortableMcpCredentials(config) {
                 ...(redactedHeaders ? { headers: redactedHeaders } : {}),
             },
             credentials: finalizePortableCredentialSpecs(credentialsByKey),
+            rawValues,
         };
     }
     return {
@@ -18,9 +20,10 @@ export function redactPortableMcpCredentials(config) {
             ...(redactedEnv ? { env: redactedEnv } : {}),
         },
         credentials: finalizePortableCredentialSpecs(credentialsByKey),
+        rawValues,
     };
 }
-function redactStringMap(values, source, credentialsByKey) {
+function redactStringMap(values, source, credentialsByKey, rawValues) {
     if (!values) {
         return undefined;
     }
@@ -32,6 +35,9 @@ function redactStringMap(values, source, credentialsByKey) {
         }
         const credentialKey = normalizeCredentialKey(key);
         addCredentialSpec(credentialsByKey, credentialKey, source, key);
+        if (!isCredentialPlaceholder(value)) {
+            rawValues[credentialKey] = value;
+        }
         redacted[key] = isCredentialPlaceholder(value)
             ? value
             : `\${credentials.${credentialKey}}`;

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 { ExecutorResolver } from '../executor/resolver.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;
@@ -10,5 +10,5 @@ export interface DoctorService {
     }): Promise<DoctorResult>;
 }
 export declare function createDoctorService(dependencies?: {
-    resolver?: ExecutorResolver;
+    availabilityService?: AgentAvailabilityService;
 }): DoctorService;

package/dist/services/platform/doctor-service.js

@@ -0,0 +1,23 @@
+import { createAgentAvailabilityService, } from '../agent/agent-availability-service.js';
+export function createDoctorService(dependencies = {}) {
+    const availabilityService = dependencies.availabilityService ?? createAgentAvailabilityService();
+    return {
+        async execute() {
+            const checks = [];
+            const availability = await availabilityService.getAll();
+            for (const agent of Object.values(availability)) {
+                checks.push({
+                    label: 'Agent',
+                    status: agent.available ? 'ok' : 'warn',
+                    message: agent.available
+                        ? `${agent.agent} is available`
+                        : `${agent.agent} is not available on PATH`,
+                });
+            }
+            return {
+                checks,
+                hasIssues: checks.some((c) => c.status !== 'ok'),
+            };
+        },
+    };
+}

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/platform/status-service.d.ts

@@ -0,0 +1,19 @@
+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: {
+        count: number;
+        names: string[];
+    };
+}
+export interface StatusService {
+    execute(options?: {
+        cwd?: string;
+    }): Promise<StatusResult>;
+}
+export declare function createStatusService(dependencies?: {
+    availabilityService?: AgentAvailabilityService;
+    profileService?: ProfileService;
+}): StatusService;

package/dist/services/platform/status-service.js

@@ -0,0 +1,22 @@
+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();
+    return {
+        async execute(options = {}) {
+            const cwd = options.cwd ?? process.cwd();
+            const [agents, profileList] = await Promise.all([
+                availabilityService.getAll(),
+                profileService.list({ cwd }),
+            ]);
+            return {
+                agents,
+                profiles: {
+                    count: profileList.profiles.length,
+                    names: profileList.profiles,
+                },
+            };
+        },
+    };
+}

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[];

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

@@ -0,0 +1,91 @@
+import { readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+export async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function detectIncompatibleArtifacts(installPath) {
+    const [hasAppConnector, hasHooks, hasCommands, codexAgentSkills, claudeAgents] = await Promise.all([
+        pathExists(path.join(installPath, '.app.json')),
+        pathExists(path.join(installPath, 'hooks')),
+        pathExists(path.join(installPath, 'commands')),
+        listCodexAgentSkills(installPath),
+        listClaudeAgentFiles(installPath),
+    ]);
+    return { hasAppConnector, hasHooks, hasCommands, codexAgentSkills, claudeAgents };
+}
+async function listCodexAgentSkills(installPath) {
+    const skillsDir = path.join(installPath, 'skills');
+    try {
+        const entries = await readdir(skillsDir, { withFileTypes: true });
+        const matches = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            if (await pathExists(path.join(skillsDir, entry.name, 'agents'))) {
+                matches.push(entry.name);
+            }
+        }
+        return matches.sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+async function listClaudeAgentFiles(installPath) {
+    const agentsDir = path.join(installPath, 'agents');
+    try {
+        const entries = await readdir(agentsDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => entry.name.replace(/\.md$/, ''))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+export function formatCompatibilityWarnings(artifacts, context) {
+    const warnings = [];
+    if (artifacts.hasAppConnector && context.targetAgent !== 'codex') {
+        warnings.push({
+            label: 'App connector',
+            status: 'warn',
+            message: `Plugin ships a Codex app connector (.app.json) that will NOT transfer. Skill instructions will copy over but the backing integration will not work on ${context.targetAgent}.`,
+        });
+    }
+    if (artifacts.codexAgentSkills.length > 0 && context.targetAgent !== 'codex') {
+        warnings.push({
+            label: 'Codex agent YAML',
+            status: 'warn',
+            message: `Skills ${artifacts.codexAgentSkills.join(', ')} include Codex-specific agent YAML that will not transfer to ${context.targetAgent}.`,
+        });
+    }
+    if (artifacts.hasHooks && context.targetAgent !== 'claude') {
+        warnings.push({
+            label: 'Claude hooks',
+            status: 'warn',
+            message: `Plugin ships session hooks that only work on Claude and will NOT transfer to ${context.targetAgent}.`,
+        });
+    }
+    if (context.targetAgent === 'gemini' && artifacts.claudeAgents.length > 0) {
+        warnings.push({
+            label: 'Subagents',
+            status: 'warn',
+            message: `Plugin ships subagent definitions (${artifacts.claudeAgents.join(', ')}) that cannot be converted to ${context.targetAgent}.`,
+        });
+    }
+    if (context.targetAgent === 'gemini' && artifacts.hasCommands) {
+        warnings.push({
+            label: 'Slash commands',
+            status: 'warn',
+            message: `Plugin ships slash commands that cannot be converted to ${context.targetAgent}.`,
+        });
+    }
+    return warnings;
+}

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

@@ -0,0 +1,27 @@
+import type { AgentName } from '../../types.js';
+import type { PluginBundleAgent, PluginBundleCommand } from './plugin-install-bundle.js';
+export declare function defaultInstallAgent(options: {
+    targetAgent: AgentName;
+    agent: PluginBundleAgent;
+}): Promise<void>;
+export declare function defaultInstallCommand(options: {
+    targetAgent: AgentName;
+    command: PluginBundleCommand;
+}): Promise<void>;
+export declare function defaultRemoveAgentFile(options: {
+    targetAgent: AgentName;
+    agentName: string;
+}): Promise<void>;
+export declare function defaultRemoveCommandFile(options: {
+    targetAgent: AgentName;
+    commandName: string;
+}): Promise<void>;
+export declare function defaultCopySkillDirectory(options: {
+    sourceInstallPath: string;
+    skillName: string;
+    targetAgent: AgentName;
+}): Promise<void>;
+export declare function defaultRemoveSkillDirectory(options: {
+    targetAgent: AgentName;
+    skillName: string;
+}): Promise<void>;