brainctl 0.1.17 → 0.1.18

package/dist/services/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-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-availability-service.js

@@ -0,0 +1,32 @@
+import { findExecutable } from '../system/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/credential-redaction-service.d.ts

@@ -2,6 +2,7 @@ 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

@@ -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/doctor-service.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutorResolver } from '../executor/resolver.js';
+import { type AgentAvailabilityService } from './agent-availability-service.js';
 import type { DiagnosticCheck } from '../types.js';
 export interface DoctorResult {
     checks: DiagnosticCheck[];
@@ -10,5 +10,5 @@ export interface DoctorService {
     }): Promise<DoctorResult>;
 }
 export declare function createDoctorService(dependencies?: {
-    resolver?: ExecutorResolver;
+    availabilityService?: AgentAvailabilityService;
 }): DoctorService;

package/dist/services/doctor-service.js

@@ -1,79 +1,23 @@
-import { stat } from 'node:fs/promises';
-import path from 'node:path';
-import { loadConfig } from '../config.js';
-import { createExecutorResolver } from '../executor/resolver.js';
+import { createAgentAvailabilityService, } from './agent-availability-service.js';
 export function createDoctorService(dependencies = {}) {
-    const resolver = dependencies.resolver ?? createExecutorResolver();
+    const availabilityService = dependencies.availabilityService ?? createAgentAvailabilityService();
     return {
-        async execute(options = {}) {
-            const cwd = options.cwd ?? process.cwd();
+        async execute() {
             const checks = [];
-            const configPath = path.join(cwd, 'ai-stack.yaml');
-            const configExists = await pathExists(configPath);
-            if (!configExists) {
-                checks.push({
-                    label: 'Config',
-                    status: 'error',
-                    message: 'ai-stack.yaml was not found.'
-                });
-            }
-            if (configExists) {
-                try {
-                    const config = await loadConfig({ cwd });
-                    checks.push({
-                        label: 'Config',
-                        status: 'ok',
-                        message: `Loaded ${config.configPath}`
-                    });
-                    for (const memoryPath of config.memory.paths) {
-                        const exists = await pathExists(memoryPath);
-                        checks.push({
-                            label: 'Memory',
-                            status: exists ? 'ok' : 'error',
-                            message: exists
-                                ? `Memory path is available: ${memoryPath}`
-                                : `Memory path is missing: ${memoryPath}`
-                        });
-                    }
-                    checks.push({
-                        label: 'Skills',
-                        status: Object.keys(config.skills).length > 0 ? 'ok' : 'error',
-                        message: Object.keys(config.skills).length > 0
-                            ? `${Object.keys(config.skills).length} skills configured`
-                            : 'No skills are configured.'
-                    });
-                }
-                catch (error) {
-                    checks.push({
-                        label: 'Config',
-                        status: 'error',
-                        message: error instanceof Error ? error.message : 'Config validation failed.'
-                    });
-                }
-            }
-            const availability = await resolver.getAgentAvailability();
+            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`
+                        : `${agent.agent} is not available on PATH`,
                 });
             }
             return {
                 checks,
-                hasIssues: checks.some((check) => check.status !== 'ok')
+                hasIssues: checks.some((c) => c.status !== 'ok'),
             };
-        }
+        },
     };
 }
-async function pathExists(targetPath) {
-    try {
-        await stat(targetPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

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

@@ -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 {

package/dist/services/portable-profile-pack-service.js

@@ -52,11 +52,26 @@ export function createPortableProfilePackService(deps = {}) {
                         filter: (src) => !matchesPluginExclude(src),
                     });
                 }
+                const format = options.format ?? 'tarball';
+                const credentialsMode = options.credentialsMode ?? 'redact';
+                const warnings = [];
+                if (credentialsMode === 'keep' && Object.keys(packed.rawCredentials).length > 0) {
+                    await writeFile(path.join(stagingDir, '.env'), renderDotEnv(packed.rawCredentials), 'utf8');
+                    warnings.push(`Wrote .env with ${Object.keys(packed.rawCredentials).length} real credential value(s). Do NOT publish this archive publicly.`);
+                }
+                if (format === 'folder') {
+                    await writeRepoReadyFiles(stagingDir, packed);
+                    const outputPath = options.outputPath ?? path.join(cwd, packed.profile.name);
+                    await rm(outputPath, { recursive: true, force: true });
+                    await mkdir(path.dirname(outputPath), { recursive: true });
+                    await cp(stagingDir, outputPath, { recursive: true });
+                    return { archivePath: outputPath, format, warnings };
+                }
                 const outputPath = options.outputPath ?? path.join(cwd, `${packed.profile.name}.tar.gz`);
                 execSync(`tar -czf "${outputPath}" -C "${stagingDir}" .`, {
                     stdio: 'pipe',
                 });
-                return { archivePath: outputPath };
+                return { archivePath: outputPath, format, warnings };
             }
             finally {
                 await rm(stagingDir, { recursive: true, force: true });
@@ -64,6 +79,62 @@ export function createPortableProfilePackService(deps = {}) {
         },
     };
 }
+function renderDotEnv(values) {
+    return (Object.entries(values)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, value]) => `${key.toUpperCase()}=${escapeEnvValue(value)}`)
+        .join('\n') + '\n');
+}
+function escapeEnvValue(value) {
+    if (/[\s"'#$\\]/.test(value)) {
+        return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+    }
+    return value;
+}
+async function writeRepoReadyFiles(stagingDir, packed) {
+    const credentials = packed.manifest.credentials ?? [];
+    const envLines = credentials.map((c) => `${c.key.toUpperCase()}=${c.description ? `# ${c.description}` : ''}`);
+    const envExample = envLines.length > 0
+        ? `# Credentials required by this profile\n# Copy to .env and fill in values before \`brainctl profile import\`.\n${envLines.join('\n')}\n`
+        : '# No credentials required by this profile.\n';
+    const gitignore = ['.env', 'node_modules/', '.DS_Store', '*.bak.*', ''].join('\n');
+    const readme = renderReadme(packed);
+    await writeFile(path.join(stagingDir, '.env.example'), envExample, 'utf8');
+    await writeFile(path.join(stagingDir, '.gitignore'), gitignore, 'utf8');
+    await writeFile(path.join(stagingDir, 'README.md'), readme, 'utf8');
+}
+function renderReadme(packed) {
+    const { manifest, profile } = packed;
+    const mcpNames = Object.keys(profile.mcps);
+    const credNames = (manifest.credentials ?? []).map((c) => `- \`${c.key}\`${c.description ? ` — ${c.description}` : ''}`);
+    const lines = [
+        `# ${profile.name}`,
+        '',
+        profile.description ?? 'A brainctl portable profile.',
+        '',
+        `Packed by ${manifest.createdBy?.tool ?? 'brainctl'} v${manifest.createdBy?.version ?? packageVersion.version}.`,
+        '',
+        '## Contents',
+        '',
+        `- **MCPs:** ${mcpNames.length > 0 ? mcpNames.join(', ') : '(none)'}`,
+        ...(manifest.plugins ? [`- **Plugins:** ${manifest.plugins.map((p) => `${p.agent}:${p.name}`).join(', ')}`] : []),
+        ...(manifest.userSkills ? [`- **User skills:** ${manifest.userSkills.map((s) => `${s.agent}:${s.name}`).join(', ')}`] : []),
+        '',
+        '## Install',
+        '',
+        '```bash',
+        `brainctl profile import ./${profile.name}`,
+        '```',
+        '',
+    ];
+    if (credNames.length > 0) {
+        lines.push('## Required credentials', '', 'Copy `.env.example` to `.env` (gitignored) and fill in values, or pass them at import time:', '', '```bash', `brainctl profile import ./${profile.name} \\`, ...credNames.map((c) => {
+            const key = c.match(/`([^`]+)`/)?.[1] ?? '';
+            return `  --credential ${key}=<value> \\`;
+        }), '```', '', '### Keys', '', ...credNames, '');
+    }
+    return lines.join('\n');
+}
 async function buildPackedProfile(options) {
     if (options.source.source === 'profile') {
         const profile = await options.profileService.get({
@@ -117,9 +188,7 @@ async function buildPackedProfile(options) {
     const extras = collectAgentExtras(agentConfig);
     return redactAndNormalizeProfile({
         name: profileName,
-        skills: {},
         mcps,
-        memory: { paths: [] },
     }, agentSource.cwd, {
         kind: 'agent',
         agent: agentSource.agent,
@@ -186,14 +255,18 @@ function inferPluginVersion(agent, installPath) {
     const base = path.basename(installPath);
     return base.length > 0 ? base : undefined;
 }
-function redactAndNormalizeProfile(profile, cwd, source, extras) {
+async function redactAndNormalizeProfile(profile, cwd, source, extras) {
     const bundledSources = new Map();
     const credentials = new Map();
+    const rawCredentials = {};
     const mcps = Object.fromEntries(Object.entries(profile.mcps).map(([key, config]) => {
         const result = redactPortableMcpCredentials(config);
         for (const credential of result.credentials) {
             credentials.set(credential.key, credential);
         }
+        for (const [credKey, credValue] of Object.entries(result.rawValues)) {
+            rawCredentials[credKey] = credValue;
+        }
         if (result.redacted.kind === 'local' && result.redacted.source === 'bundled') {
             const sourcePath = path.isAbsolute(result.redacted.path)
                 ? result.redacted.path
@@ -230,6 +303,7 @@ function redactAndNormalizeProfile(profile, cwd, source, extras) {
         bundledSources,
         bundledPlugins: extras?.bundledPlugins ?? new Map(),
         bundledUserSkills: extras?.bundledUserSkills ?? new Map(),
+        rawCredentials,
     };
 }
 function sanitizePackName(value) {

package/dist/services/profile-apply-service.d.ts

@@ -0,0 +1,34 @@
+import type { AgentName, SyncResult } from '../types.js';
+import { type ProfileSnapshotService } from './profile-snapshot-service.js';
+import { type ProfileService } from './profile-service.js';
+import type { AgentConfigWriter } from './sync/agent-writer.js';
+export type ItemType = 'mcp' | 'plugin' | 'skill';
+export interface ItemSelector {
+    type: ItemType;
+    name: string;
+}
+export interface ApplyOptions {
+    cwd?: string;
+    profileName: string;
+    agents: AgentName[];
+    items?: ItemSelector[];
+    backup?: boolean;
+}
+export interface ApplyResult extends SyncResult {
+}
+export interface ProfileApplyService {
+    execute(options: ApplyOptions): Promise<{
+        backups: Array<{
+            agent: AgentName;
+            profileName: string;
+        }>;
+        applied: ApplyResult;
+    }>;
+}
+interface ProfileApplyDependencies {
+    profileService?: ProfileService;
+    snapshotService?: ProfileSnapshotService;
+    writers?: Partial<Record<AgentName, AgentConfigWriter>>;
+}
+export declare function createProfileApplyService(deps?: ProfileApplyDependencies): ProfileApplyService;
+export {};

package/dist/services/profile-apply-service.js

@@ -0,0 +1,102 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+import { ProfileError } from '../errors.js';
+import { installPlugin, installUserSkill } from './agent-asset-installer.js';
+import { createProfileSnapshotService, defaultBackupProfileName, } from './profile-snapshot-service.js';
+import { createProfileService, profileDir } from './profile-service.js';
+import { createClaudeWriter } from './sync/claude-writer.js';
+import { createCodexWriter } from './sync/codex-writer.js';
+import { createGeminiWriter } from './sync/gemini-writer.js';
+export function createProfileApplyService(deps = {}) {
+    const profileService = deps.profileService ?? createProfileService();
+    const snapshotService = deps.snapshotService ?? createProfileSnapshotService();
+    const defaultWriters = {
+        claude: createClaudeWriter(),
+        codex: createCodexWriter(),
+        gemini: createGeminiWriter(),
+    };
+    const writers = { ...defaultWriters, ...deps.writers };
+    return {
+        async execute(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profile = await profileService.get({ cwd, name: options.profileName });
+            const remoteMcpName = Object.entries(profile.mcps).find(([, config]) => config.kind === 'remote')?.[0];
+            if (remoteMcpName) {
+                throw new ProfileError(`Profile "${profile.name}" includes remote MCP "${remoteMcpName}". Remote MCP apply is not supported yet.`);
+            }
+            const isPartial = options.items !== undefined && options.items.length > 0;
+            const shouldBackup = options.backup ?? !isPartial;
+            const backups = [];
+            if (shouldBackup) {
+                for (const agent of options.agents) {
+                    const backupName = defaultBackupProfileName(agent);
+                    try {
+                        await snapshotService.execute({ cwd, agent, profileName: backupName });
+                        backups.push({ agent, profileName: backupName });
+                    }
+                    catch {
+                        // Agent may not have a live config to back up — skip silently
+                    }
+                }
+            }
+            const folder = profileDir(cwd, options.profileName);
+            const manifest = await readProfileManifest(folder);
+            const applied = [];
+            const wantMcp = (name) => matches(options.items, 'mcp', name);
+            const wantPlugin = (name) => matches(options.items, 'plugin', name);
+            const wantSkill = (name) => matches(options.items, 'skill', name);
+            for (const agent of options.agents) {
+                const writer = writers[agent];
+                if (!writer)
+                    continue;
+                const filteredMcps = Object.fromEntries(Object.entries(profile.mcps).filter(([name]) => wantMcp(name)));
+                let mcpResult;
+                if (Object.keys(filteredMcps).length > 0 || options.items === undefined) {
+                    mcpResult = await writer.write({ mcpServers: filteredMcps, cwd });
+                }
+                else {
+                    mcpResult = { configPath: '', backedUpTo: null };
+                }
+                const pluginsInstalled = [];
+                for (const plugin of (manifest?.plugins ?? []).filter((p) => p.agent === agent && wantPlugin(p.name))) {
+                    const sourceDir = path.join(folder, plugin.archivePath);
+                    await installPlugin(sourceDir, plugin);
+                    pluginsInstalled.push(plugin.name);
+                }
+                const userSkillsInstalled = [];
+                for (const skill of (manifest?.userSkills ?? []).filter((s) => s.agent === agent && wantSkill(s.name))) {
+                    const sourceDir = path.join(folder, skill.archivePath);
+                    await installUserSkill(sourceDir, skill);
+                    userSkillsInstalled.push(skill.name);
+                }
+                applied.push({
+                    agent,
+                    configPath: mcpResult.configPath,
+                    backedUpTo: mcpResult.backedUpTo,
+                    mcpCount: Object.keys(filteredMcps).length,
+                    ...(pluginsInstalled.length > 0 ? { pluginsInstalled } : {}),
+                    ...(userSkillsInstalled.length > 0 ? { userSkillsInstalled } : {}),
+                });
+            }
+            return { backups, applied };
+        },
+    };
+}
+function matches(items, type, name) {
+    if (items === undefined)
+        return true;
+    return items.some((s) => s.type === type && s.name === name);
+}
+async function readProfileManifest(folder) {
+    try {
+        const source = await readFile(path.join(folder, 'manifest.yaml'), 'utf8');
+        const parsed = YAML.parse(source);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/services/profile-export-service.d.ts

@@ -1,6 +1,6 @@
 import type { AgentName } from '../types.js';
 import type { AgentConfigService } from './agent-config-service.js';
-import { type PortableProfilePackService } from './portable-profile-pack-service.js';
+import { type PortableCredentialsMode, type PortablePackFormat, type PortableProfilePackService } from './portable-profile-pack-service.js';
 import type { ProfileService } from './profile-service.js';
 export interface ProfileExportService {
     execute(options: {
@@ -14,8 +14,12 @@ export interface ProfileExportService {
             cwd: string;
         };
         outputPath?: string;
+        format?: PortablePackFormat;
+        credentialsMode?: PortableCredentialsMode;
     }): Promise<{
         archivePath: string;
+        format: PortablePackFormat;
+        warnings: string[];
     }>;
 }
 interface ProfileExportDependencies {

package/dist/services/profile-export-service.js

@@ -1,4 +1,4 @@
-import { createPortableProfilePackService } from './portable-profile-pack-service.js';
+import { createPortableProfilePackService, } from './portable-profile-pack-service.js';
 export function createProfileExportService(deps = {}) {
     const portableProfilePackService = deps.portableProfilePackService ?? createPortableProfilePackService({
         profileService: deps.profileService,
@@ -10,6 +10,8 @@ export function createProfileExportService(deps = {}) {
                 cwd: options.cwd,
                 source: options.source,
                 outputPath: options.outputPath,
+                format: options.format,
+                credentialsMode: options.credentialsMode,
             });
         },
     };