brainctl 0.1.17 → 0.1.19

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

@@ -0,0 +1,65 @@
+import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { claudeAgentMdToCodexToml, claudeCommandMdToCodexSkill, codexAgentTomlToClaudeMd, } from '../agent/agent-converter-service.js';
+import { getAgentFilePath, getCommandFilePath, getSkillDir } from './skill-paths.js';
+export async function defaultInstallAgent(options) {
+    const targetPath = getAgentFilePath(options.targetAgent, options.agent.name);
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    let output;
+    if (options.targetAgent === 'claude') {
+        output = options.agent.sourceFormat === 'claude-md'
+            ? options.agent.content
+            : codexAgentTomlToClaudeMd(options.agent.content);
+    }
+    else if (options.targetAgent === 'codex') {
+        output = options.agent.sourceFormat === 'codex-toml'
+            ? options.agent.content
+            : claudeAgentMdToCodexToml(options.agent.content);
+    }
+    else {
+        throw new Error(`Agent install is not supported for ${options.targetAgent}`);
+    }
+    await writeFile(targetPath, output, 'utf8');
+}
+export async function defaultInstallCommand(options) {
+    if (options.targetAgent === 'claude') {
+        const targetPath = getCommandFilePath('claude', options.command.name);
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await writeFile(targetPath, options.command.content, 'utf8');
+        return;
+    }
+    if (options.targetAgent === 'codex') {
+        const skillDir = getSkillDir('codex', options.command.name);
+        await mkdir(skillDir, { recursive: true });
+        const { skillMarkdown } = claudeCommandMdToCodexSkill(options.command.content);
+        await writeFile(path.join(skillDir, 'SKILL.md'), skillMarkdown, 'utf8');
+        return;
+    }
+    throw new Error(`Command install is not supported for ${options.targetAgent}`);
+}
+export async function defaultRemoveAgentFile(options) {
+    const targetPath = getAgentFilePath(options.targetAgent, options.agentName);
+    await rm(targetPath, { force: true });
+}
+export async function defaultRemoveCommandFile(options) {
+    if (options.targetAgent === 'claude') {
+        const targetPath = getCommandFilePath('claude', options.commandName);
+        await rm(targetPath, { force: true });
+        return;
+    }
+    if (options.targetAgent === 'codex') {
+        const skillDir = getSkillDir('codex', options.commandName);
+        await rm(skillDir, { recursive: true, force: true });
+        return;
+    }
+}
+export async function defaultCopySkillDirectory(options) {
+    const sourceDir = path.join(options.sourceInstallPath, 'skills', options.skillName);
+    const targetDir = getSkillDir(options.targetAgent, options.skillName);
+    await mkdir(path.dirname(targetDir), { recursive: true });
+    await cp(sourceDir, targetDir, { recursive: true });
+}
+export async function defaultRemoveSkillDirectory(options) {
+    const targetDir = getSkillDir(options.targetAgent, options.skillName);
+    await rm(targetDir, { recursive: true, force: true });
+}

package/dist/services/{plugin-install-service.d.ts → plugin/plugin-install-service.d.ts}

@@ -1,19 +1,12 @@
-import type { AgentName } from '../types.js';
-import type { AgentLiveConfig, AgentMcpEntry, AgentSkillEntry } from './agent-config-service.js';
+import type { AgentName } from '../../types.js';
+import type { AgentLiveConfig, AgentMcpEntry, AgentSkillEntry } from '../agent/agent-config-service.js';
+import { type PluginBundle, type PluginBundleAgent, type PluginBundleCommand } from './plugin-install-bundle.js';
+export type { PluginBundleAgent, PluginBundleCommand };
 export interface PluginInstallCheck {
     label: string;
     status: 'ok' | 'warn' | 'error';
     message: string;
 }
-export interface PluginBundleAgent {
-    name: string;
-    sourceFormat: 'claude-md' | 'codex-toml';
-    content: string;
-}
-export interface PluginBundleCommand {
-    name: string;
-    content: string;
-}
 export interface PluginInstallPlan {
     ok: boolean;
     checks: PluginInstallCheck[];
@@ -66,12 +59,6 @@ export interface PluginInstallService {
         plugin: AgentSkillEntry;
     }): Promise<PluginUninstallResult>;
 }
-interface PluginBundle {
-    skills: string[];
-    mcps: Record<string, AgentMcpEntry>;
-    agents: PluginBundleAgent[];
-    commands: PluginBundleCommand[];
-}
 interface PluginInstallDependencies {
     readInstalledPluginBundle?: (installPath: string) => Promise<PluginBundle>;
     readTargetState?: (options: {
@@ -132,4 +119,3 @@ interface PluginInstallDependencies {
     }) => Promise<void>;
 }
 export declare function createPluginInstallService(dependencies?: PluginInstallDependencies): PluginInstallService;
-export {};

package/dist/services/{plugin-install-service.js → plugin/plugin-install-service.js}

@@ -1,14 +1,11 @@
-import { spawn } from 'node:child_process';
-import { copyFile, cp, mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import path from 'node:path';
-import { ValidationError } from '../errors.js';
-import { formatTimestamp } from './sync/agent-writer.js';
-import { stripPluginSection } from './sync/codex-writer.js';
-import { createAgentConfigService } from './agent-config-service.js';
-import { claudeAgentMdToCodexToml, claudeCommandMdToCodexSkill, codexAgentTomlToClaudeMd, } from './agent-converter-service.js';
+import { ValidationError } from '../../errors.js';
+import { createAgentConfigService } from '../agent/agent-config-service.js';
 import { getAgentFilePath, getCommandFilePath, getSkillDir } from './skill-paths.js';
-import { removeManagedPluginInstall, writeManagedPluginInstall, } from './sync/managed-plugin-registry.js';
+import { removeManagedPluginInstall, writeManagedPluginInstall, } from '../sync/managed-plugin-registry.js';
+import { defaultCopySkillDirectory, defaultInstallAgent, defaultInstallCommand, defaultRemoveAgentFile, defaultRemoveCommandFile, defaultRemoveSkillDirectory, } from './plugin-install-fs.js';
+import { detectIncompatibleArtifacts, formatCompatibilityWarnings, pathExists, } from './plugin-install-compatibility.js';
+import { defaultReadInstalledPluginBundle, isAgentInstallableOnTarget, isCommandInstallableOnTarget, } from './plugin-install-bundle.js';
+import { defaultUninstallClaudePlugin, defaultUninstallCodexPlugin, isUnmanagedClaudePlugin, isUnmanagedCodexPlugin, } from './plugin-install-uninstall.js';
 export function createPluginInstallService(dependencies = {}) {
     const agentConfigService = createAgentConfigService();
     const readInstalledPluginBundle = dependencies.readInstalledPluginBundle ?? defaultReadInstalledPluginBundle;
@@ -301,301 +298,3 @@ export function createPluginInstallService(dependencies = {}) {
         },
     };
 }
-function isUnmanagedCodexPlugin(targetAgent, plugin) {
-    return (!plugin.managed &&
-        targetAgent === 'codex' &&
-        typeof plugin.installPath === 'string' &&
-        typeof plugin.source === 'string' &&
-        plugin.source.length > 0);
-}
-function isUnmanagedClaudePlugin(targetAgent, plugin) {
-    return (!plugin.managed &&
-        targetAgent === 'claude' &&
-        typeof plugin.installPath === 'string' &&
-        typeof plugin.source === 'string' &&
-        plugin.source.length > 0);
-}
-async function defaultUninstallClaudePlugin(options) {
-    // Delegate to `claude plugin uninstall` so a running Claude Code session
-    // drops the plugin from its in-memory state (direct fs mutation gets
-    // resurrected by live sessions that still have the plugin loaded).
-    await new Promise((resolve, reject) => {
-        const child = spawn('claude', ['plugin', 'uninstall', options.pluginKey, '--scope', 'user'], { stdio: ['ignore', 'pipe', 'pipe'] });
-        let stderr = '';
-        let stdout = '';
-        child.stdout?.on('data', (chunk) => {
-            stdout += chunk.toString();
-        });
-        child.stderr?.on('data', (chunk) => {
-            stderr += chunk.toString();
-        });
-        child.on('error', (error) => {
-            reject(new ValidationError(`Failed to invoke \`claude\` CLI: ${error.message}. Is Claude Code installed on PATH?`));
-        });
-        child.on('exit', (code) => {
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            const detail = (stderr || stdout).trim();
-            reject(new ValidationError(`\`claude plugin uninstall ${options.pluginKey}\` exited ${code}${detail ? `: ${detail}` : ''}`));
-        });
-    });
-}
-async function defaultUninstallCodexPlugin(options) {
-    const home = homedir();
-    const cacheRoot = path.join(home, '.codex', 'plugins', 'cache');
-    const resolvedInstall = path.resolve(options.installPath);
-    if (!resolvedInstall.startsWith(cacheRoot + path.sep)) {
-        throw new ValidationError(`Refusing to remove Codex plugin files outside ${cacheRoot}: ${resolvedInstall}`);
-    }
-    const pluginRoot = path.dirname(resolvedInstall);
-    const configPath = path.join(home, '.codex', 'config.toml');
-    let existing = '';
-    try {
-        existing = await readFile(configPath, 'utf8');
-    }
-    catch {
-        existing = '';
-    }
-    if (existing.length > 0) {
-        const next = stripPluginSection(existing, options.pluginKey);
-        if (next !== existing) {
-            const backupPath = `${configPath}.bak.${formatTimestamp()}`;
-            await copyFile(configPath, backupPath);
-            const tmpPath = `${configPath}.tmp.${Date.now()}`;
-            await writeFile(tmpPath, next, 'utf8');
-            await rename(tmpPath, configPath);
-        }
-    }
-    await rm(pluginRoot, { recursive: true, force: true });
-}
-async function defaultReadInstalledPluginBundle(installPath) {
-    const skillsDir = path.join(installPath, 'skills');
-    let skills = [];
-    try {
-        const { readdir } = await import('node:fs/promises');
-        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 };
-}
-function isAgentInstallableOnTarget(target) {
-    return target === 'claude' || target === 'codex';
-}
-function isCommandInstallableOnTarget(target) {
-    return target === 'claude' || target === 'codex';
-}
-async function defaultInstallAgent(options) {
-    const targetPath = getAgentFilePath(options.targetAgent, options.agent.name);
-    await mkdir(path.dirname(targetPath), { recursive: true });
-    let output;
-    if (options.targetAgent === 'claude') {
-        output = options.agent.sourceFormat === 'claude-md'
-            ? options.agent.content
-            : codexAgentTomlToClaudeMd(options.agent.content);
-    }
-    else if (options.targetAgent === 'codex') {
-        output = options.agent.sourceFormat === 'codex-toml'
-            ? options.agent.content
-            : claudeAgentMdToCodexToml(options.agent.content);
-    }
-    else {
-        throw new Error(`Agent install is not supported for ${options.targetAgent}`);
-    }
-    await writeFile(targetPath, output, 'utf8');
-}
-async function defaultInstallCommand(options) {
-    if (options.targetAgent === 'claude') {
-        const targetPath = getCommandFilePath('claude', options.command.name);
-        await mkdir(path.dirname(targetPath), { recursive: true });
-        await writeFile(targetPath, options.command.content, 'utf8');
-        return;
-    }
-    if (options.targetAgent === 'codex') {
-        const skillDir = getSkillDir('codex', options.command.name);
-        await mkdir(skillDir, { recursive: true });
-        const { skillMarkdown } = claudeCommandMdToCodexSkill(options.command.content);
-        await writeFile(path.join(skillDir, 'SKILL.md'), skillMarkdown, 'utf8');
-        return;
-    }
-    throw new Error(`Command install is not supported for ${options.targetAgent}`);
-}
-async function defaultRemoveAgentFile(options) {
-    const targetPath = getAgentFilePath(options.targetAgent, options.agentName);
-    await rm(targetPath, { force: true });
-}
-async function defaultRemoveCommandFile(options) {
-    if (options.targetAgent === 'claude') {
-        const targetPath = getCommandFilePath('claude', options.commandName);
-        await rm(targetPath, { force: true });
-        return;
-    }
-    if (options.targetAgent === 'codex') {
-        const skillDir = getSkillDir('codex', options.commandName);
-        await rm(skillDir, { recursive: true, force: true });
-        return;
-    }
-}
-async function defaultCopySkillDirectory(options) {
-    const sourceDir = path.join(options.sourceInstallPath, 'skills', options.skillName);
-    const targetDir = getSkillDir(options.targetAgent, options.skillName);
-    await mkdir(path.dirname(targetDir), { recursive: true });
-    await cp(sourceDir, targetDir, { recursive: true });
-}
-async function defaultRemoveSkillDirectory(options) {
-    const targetDir = getSkillDir(options.targetAgent, options.skillName);
-    await rm(targetDir, { recursive: true, force: true });
-}
-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 pathExists(target) {
-    try {
-        await stat(target);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-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 [];
-    }
-}
-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-uninstall.d.ts

@@ -0,0 +1,12 @@
+import type { AgentName } from '../../types.js';
+import type { AgentSkillEntry } from '../agent/agent-config-service.js';
+export declare function isUnmanagedCodexPlugin(targetAgent: AgentName, plugin: AgentSkillEntry): boolean;
+export declare function isUnmanagedClaudePlugin(targetAgent: AgentName, plugin: AgentSkillEntry): boolean;
+export declare function defaultUninstallClaudePlugin(options: {
+    pluginKey: string;
+    installPath: string;
+}): Promise<void>;
+export declare function defaultUninstallCodexPlugin(options: {
+    pluginKey: string;
+    installPath: string;
+}): Promise<void>;

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

@@ -0,0 +1,76 @@
+import { spawn } from 'node:child_process';
+import { copyFile, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { ValidationError } from '../../errors.js';
+import { formatTimestamp } from '../sync/agent-writer.js';
+import { stripPluginSection } from '../sync/codex-writer.js';
+export function isUnmanagedCodexPlugin(targetAgent, plugin) {
+    return (!plugin.managed &&
+        targetAgent === 'codex' &&
+        typeof plugin.installPath === 'string' &&
+        typeof plugin.source === 'string' &&
+        plugin.source.length > 0);
+}
+export function isUnmanagedClaudePlugin(targetAgent, plugin) {
+    return (!plugin.managed &&
+        targetAgent === 'claude' &&
+        typeof plugin.installPath === 'string' &&
+        typeof plugin.source === 'string' &&
+        plugin.source.length > 0);
+}
+export async function defaultUninstallClaudePlugin(options) {
+    // Delegate to `claude plugin uninstall` so a running Claude Code session
+    // drops the plugin from its in-memory state (direct fs mutation gets
+    // resurrected by live sessions that still have the plugin loaded).
+    await new Promise((resolve, reject) => {
+        const child = spawn('claude', ['plugin', 'uninstall', options.pluginKey, '--scope', 'user'], { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stderr = '';
+        let stdout = '';
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (error) => {
+            reject(new ValidationError(`Failed to invoke \`claude\` CLI: ${error.message}. Is Claude Code installed on PATH?`));
+        });
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const detail = (stderr || stdout).trim();
+            reject(new ValidationError(`\`claude plugin uninstall ${options.pluginKey}\` exited ${code}${detail ? `: ${detail}` : ''}`));
+        });
+    });
+}
+export async function defaultUninstallCodexPlugin(options) {
+    const home = homedir();
+    const cacheRoot = path.join(home, '.codex', 'plugins', 'cache');
+    const resolvedInstall = path.resolve(options.installPath);
+    if (!resolvedInstall.startsWith(cacheRoot + path.sep)) {
+        throw new ValidationError(`Refusing to remove Codex plugin files outside ${cacheRoot}: ${resolvedInstall}`);
+    }
+    const pluginRoot = path.dirname(resolvedInstall);
+    const configPath = path.join(home, '.codex', 'config.toml');
+    let existing = '';
+    try {
+        existing = await readFile(configPath, 'utf8');
+    }
+    catch {
+        existing = '';
+    }
+    if (existing.length > 0) {
+        const next = stripPluginSection(existing, options.pluginKey);
+        if (next !== existing) {
+            const backupPath = `${configPath}.bak.${formatTimestamp()}`;
+            await copyFile(configPath, backupPath);
+            const tmpPath = `${configPath}.tmp.${Date.now()}`;
+            await writeFile(tmpPath, next, 'utf8');
+            await rename(tmpPath, configPath);
+        }
+    }
+    await rm(pluginRoot, { recursive: true, force: true });
+}

package/dist/services/{skill-paths.d.ts → plugin/skill-paths.d.ts}

@@ -1,4 +1,4 @@
-import type { AgentName } from '../types.js';
+import type { AgentName } from '../../types.js';
 export declare function getSkillDir(agent: AgentName, skillName: string): string;
 export declare function getAgentFilePath(agent: AgentName, agentName: string): string;
 export declare function getCommandFilePath(agent: AgentName, commandName: string): string;

package/dist/services/{skill-preflight-service.d.ts → plugin/skill-preflight-service.d.ts}

@@ -1,4 +1,4 @@
-import type { AgentName } from '../types.js';
+import type { AgentName } from '../../types.js';
 export interface SkillPreflightCheck {
     label: string;
     status: 'ok' | 'warn' | 'error';

package/dist/services/{portable-mcp-classifier.d.ts → profile/portable-mcp-classifier.d.ts}

@@ -1,6 +1,6 @@
-import { ValidationError } from '../errors.js';
-import type { LocalBundledMcpServerConfig, LocalNpmMcpServerConfig, RemoteMcpServerConfig } from '../types.js';
-import type { AgentMcpEntry, PortableRemoteMcpMetadata } from './agent-config-service.js';
+import { ValidationError } from '../../errors.js';
+import type { LocalBundledMcpServerConfig, LocalNpmMcpServerConfig, RemoteMcpServerConfig } from '../../types.js';
+import type { AgentMcpEntry, PortableRemoteMcpMetadata } from '../agent/agent-config-service.js';
 export type PortableMcpClassification = LocalNpmMcpServerConfig | LocalBundledMcpServerConfig | RemoteMcpServerConfig;
 export declare class PortableMcpClassificationError extends ValidationError {
 }

package/dist/services/{portable-mcp-classifier.js → profile/portable-mcp-classifier.js}

@@ -1,6 +1,6 @@
 import path from 'node:path';
-import { ValidationError } from '../errors.js';
-import { detectMcpRuntime, extractEntrypoint } from './runtime-detector.js';
+import { ValidationError } from '../../errors.js';
+import { detectMcpRuntime, extractEntrypoint } from '../platform/runtime-detector.js';
 const NPX_LIKE_COMMANDS = new Set(['npx', 'uvx']);
 export class PortableMcpClassificationError extends ValidationError {
 }

package/dist/services/{portable-profile-pack-service.d.ts → profile/portable-profile-pack-service.d.ts}

@@ -1,5 +1,5 @@
-import type { AgentName } from '../types.js';
-import { type AgentConfigService } from './agent-config-service.js';
+import type { AgentName } from '../../types.js';
+import { type AgentConfigService } from '../agent/agent-config-service.js';
 import { type ProfileService } from './profile-service.js';
 export type PortablePackSource = {
     source: 'profile';
@@ -9,13 +9,19 @@ export type PortablePackSource = {
     agent: AgentName;
     cwd: string;
 };
+export type PortablePackFormat = 'tarball' | 'folder';
+export type PortableCredentialsMode = 'redact' | 'keep';
 export interface PortableProfilePackService {
     execute(options: {
         cwd?: string;
         source: PortablePackSource;
         outputPath?: string;
+        format?: PortablePackFormat;
+        credentialsMode?: PortableCredentialsMode;
     }): Promise<{
         archivePath: string;
+        format: PortablePackFormat;
+        warnings: string[];
     }>;
 }
 interface PortableProfilePackServiceDependencies {