brainctl 0.1.6 → 0.1.7

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

@@ -30,7 +30,7 @@ async function stageProfile(profile, cwd, stagingDir) {
     const mcpsDir = path.join(stagingDir, 'mcps');
     const exportMcps = {};
     for (const [name, mcp] of Object.entries(profile.mcps)) {
-        if (mcp.type === 'bundled') {
+        if (mcp.kind === 'local' && mcp.source === 'bundled') {
             const sourcePath = path.isAbsolute(mcp.path)
                 ? mcp.path
                 : path.resolve(cwd, mcp.path);
@@ -41,17 +41,17 @@ async function stageProfile(profile, cwd, stagingDir) {
                 filter: (src) => !src.includes('node_modules'),
             });
             exportMcps[name] = {
-                type: 'bundled',
+                kind: 'local',
+                source: 'bundled',
                 path: `./mcps/${name}`,
                 ...(mcp.install ? { install: mcp.install } : {}),
                 command: mcp.command,
                 ...(mcp.args ? { args: mcp.args } : {}),
                 ...(mcp.env ? { env: mcp.env } : {}),
             };
+            continue;
         }
-        else {
-            exportMcps[name] = mcp;
-        }
+        exportMcps[name] = mcp;
     }
     return {
         name: profile.name,

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

@@ -39,7 +39,7 @@ export function createProfileImportService() {
                 const installedMcps = [];
                 const mcpsBaseDir = path.join(cwd, PROFILES_DIR, profileName, 'mcps');
                 for (const [name, mcp] of Object.entries(profile.mcps)) {
-                    if (mcp.type !== 'bundled')
+                    if (!(mcp.kind === 'local' && mcp.source === 'bundled'))
                         continue;
                     const extractedMcpPath = path.join(extractDir, 'mcps', name);
                     const destMcpPath = path.join(mcpsBaseDir, name);

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

@@ -38,3 +38,4 @@ export interface ProfileService {
 }
 export declare function createProfileService(): ProfileService;
 export declare function parseProfile(source: string, name: string): ProfileConfig;
+export declare function normalizeProfileConfig(value: unknown, name: string): ProfileConfig;

package/dist/services/profile-service.js

@@ -70,12 +70,13 @@ export function createProfileService() {
             if (!(await pathExists(profilePath))) {
                 throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
             }
+            const normalized = normalizeProfileConfig(options.config, options.name);
             const data = {
-                name: options.config.name,
-                ...(options.config.description ? { description: options.config.description } : {}),
-                skills: options.config.skills,
-                mcps: options.config.mcps,
-                memory: options.config.memory,
+                name: normalized.name,
+                ...(normalized.description ? { description: normalized.description } : {}),
+                skills: normalized.skills,
+                mcps: normalized.mcps,
+                memory: normalized.memory,
             };
             await writeFile(profilePath, YAML.stringify(data), 'utf8');
         },
@@ -137,7 +138,13 @@ export function parseProfile(source, name) {
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
         throw new ProfileError(`Profile "${name}" has invalid structure.`);
     }
-    const data = parsed;
+    return normalizeProfileConfig(parsed, name);
+}
+export function normalizeProfileConfig(value, name) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new ProfileError(`Profile "${name}" has invalid structure.`);
+    }
+    const data = value;
     const skills = {};
     if (data.skills && typeof data.skills === 'object' && !Array.isArray(data.skills)) {
         for (const [key, value] of Object.entries(data.skills)) {
@@ -152,31 +159,7 @@ export function parseProfile(source, name) {
             }
         }
     }
-    const mcps = {};
-    if (data.mcps && typeof data.mcps === 'object' && !Array.isArray(data.mcps)) {
-        for (const [key, value] of Object.entries(data.mcps)) {
-            if (value && typeof value === 'object' && !Array.isArray(value)) {
-                const m = value;
-                if (m.type === 'npm' && typeof m.package === 'string') {
-                    mcps[key] = {
-                        type: 'npm',
-                        package: m.package,
-                        env: parseEnv(m.env),
-                    };
-                }
-                else if (m.type === 'bundled' && typeof m.command === 'string') {
-                    mcps[key] = {
-                        type: 'bundled',
-                        path: typeof m.path === 'string' ? m.path : '.',
-                        install: typeof m.install === 'string' ? m.install : undefined,
-                        command: m.command,
-                        args: Array.isArray(m.args) ? m.args.map(String) : undefined,
-                        env: parseEnv(m.env),
-                    };
-                }
-            }
-        }
-    }
+    const mcps = normalizeMcps(data.mcps, name);
     const memoryPaths = [];
     if (data.memory && typeof data.memory === 'object' && !Array.isArray(data.memory)) {
         const mem = data.memory;
@@ -196,7 +179,102 @@ export function parseProfile(source, name) {
         memory: { paths: memoryPaths },
     };
 }
-function parseEnv(value) {
+function normalizeMcps(value, profileName) {
+    if (value === undefined || value === null) {
+        return {};
+    }
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new ProfileError(`Profile "${profileName}" has an invalid "mcps" section.`);
+    }
+    const mcps = {};
+    for (const [key, rawValue] of Object.entries(value)) {
+        if (!rawValue || typeof rawValue !== 'object' || Array.isArray(rawValue)) {
+            throw new ProfileError(`MCP "${key}" must be an object.`);
+        }
+        const mcp = rawValue;
+        // Local profile files may still use the older type-based shape.
+        if (mcp.type === 'npm') {
+            if (typeof mcp.package !== 'string' || mcp.package.trim().length === 0) {
+                throw new ProfileError(`Local MCP "${key}" must include a non-empty package.`);
+            }
+            mcps[key] = {
+                kind: 'local',
+                source: 'npm',
+                package: mcp.package,
+                env: parseStringMap(mcp.env),
+            };
+            continue;
+        }
+        if (mcp.type === 'bundled') {
+            if (typeof mcp.path !== 'string' ||
+                mcp.path.trim().length === 0 ||
+                typeof mcp.command !== 'string' ||
+                mcp.command.trim().length === 0) {
+                throw new ProfileError(`Bundled local MCP "${key}" must include non-empty path and command fields.`);
+            }
+            mcps[key] = {
+                kind: 'local',
+                source: 'bundled',
+                path: mcp.path,
+                install: typeof mcp.install === 'string' ? mcp.install : undefined,
+                command: mcp.command,
+                args: parseStringArray(mcp.args),
+                env: parseStringMap(mcp.env),
+            };
+            continue;
+        }
+        if (mcp.kind !== 'local' && mcp.kind !== 'remote') {
+            throw new ProfileError(`MCP "${key}" must declare kind "local" or "remote".`);
+        }
+        if (mcp.kind === 'remote') {
+            if ((mcp.transport !== 'http' && mcp.transport !== 'sse') ||
+                typeof mcp.url !== 'string' ||
+                mcp.url.trim().length === 0) {
+                throw new ProfileError(`Remote MCP "${key}" must include transport ("http" or "sse") and a url.`);
+            }
+            mcps[key] = {
+                kind: 'remote',
+                transport: mcp.transport,
+                url: mcp.url,
+                headers: parseStringMap(mcp.headers),
+                env: parseStringMap(mcp.env),
+            };
+            continue;
+        }
+        if (mcp.source !== 'npm' && mcp.source !== 'bundled') {
+            throw new ProfileError(`Local MCP "${key}" must declare source "npm" or "bundled".`);
+        }
+        if (mcp.source === 'npm') {
+            if (typeof mcp.package !== 'string' || mcp.package.trim().length === 0) {
+                throw new ProfileError(`Local MCP "${key}" must include a non-empty package.`);
+            }
+            mcps[key] = {
+                kind: 'local',
+                source: 'npm',
+                package: mcp.package,
+                env: parseStringMap(mcp.env),
+            };
+            continue;
+        }
+        if (typeof mcp.path !== 'string' ||
+            mcp.path.trim().length === 0 ||
+            typeof mcp.command !== 'string' ||
+            mcp.command.trim().length === 0) {
+            throw new ProfileError(`Bundled local MCP "${key}" must include non-empty path and command fields.`);
+        }
+        mcps[key] = {
+            kind: 'local',
+            source: 'bundled',
+            path: mcp.path,
+            install: typeof mcp.install === 'string' ? mcp.install : undefined,
+            command: mcp.command,
+            args: parseStringArray(mcp.args),
+            env: parseStringMap(mcp.env),
+        };
+    }
+    return mcps;
+}
+function parseStringMap(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return undefined;
     }
@@ -206,6 +284,13 @@ function parseEnv(value) {
     }
     return Object.keys(result).length > 0 ? result : undefined;
 }
+function parseStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value.map(String);
+    return items.length > 0 ? items : undefined;
+}
 async function pathExists(targetPath) {
     try {
         await stat(targetPath);

package/dist/services/skill-paths.d.ts

@@ -0,0 +1,2 @@
+import type { AgentName } from '../types.js';
+export declare function getSkillDir(agent: AgentName, skillName: string): string;

package/dist/services/skill-paths.js

@@ -0,0 +1,12 @@
+import { homedir } from 'node:os';
+import path from 'node:path';
+export function getSkillDir(agent, skillName) {
+    const safeName = path.basename(skillName);
+    if (agent === 'claude')
+        return path.join(homedir(), '.claude', 'skills', safeName);
+    if (agent === 'codex')
+        return path.join(homedir(), '.codex', 'skills', safeName);
+    if (agent === 'gemini')
+        return path.join(homedir(), '.gemini', 'skills', safeName);
+    throw new Error(`Skill management is not supported for ${agent}`);
+}

package/dist/services/skill-preflight-service.d.ts

@@ -0,0 +1,23 @@
+import type { AgentName } from '../types.js';
+export interface SkillPreflightCheck {
+    label: string;
+    status: 'ok' | 'warn' | 'error';
+    message: string;
+}
+export interface SkillPreflightResult {
+    ok: boolean;
+    checks: SkillPreflightCheck[];
+}
+export interface SkillPreflightService {
+    execute(options: {
+        sourceAgent: AgentName;
+        targetAgent: AgentName;
+        skillName: string;
+        source?: string;
+    }): Promise<SkillPreflightResult>;
+}
+interface SkillPreflightDependencies {
+    pathExists?: (targetPath: string) => Promise<boolean>;
+}
+export declare function createSkillPreflightService(dependencies?: SkillPreflightDependencies): SkillPreflightService;
+export {};

package/dist/services/skill-preflight-service.js

@@ -0,0 +1,40 @@
+import { stat } from 'node:fs/promises';
+import { getSkillDir } from './skill-paths.js';
+export function createSkillPreflightService(dependencies = {}) {
+    const pathExists = dependencies.pathExists ?? defaultPathExists;
+    return {
+        async execute(options) {
+            const checks = [];
+            if (options.source && options.source !== 'local' && options.source !== 'linked') {
+                checks.push({
+                    label: 'Source',
+                    status: 'error',
+                    message: `Only local skill folders can be copied today. "${options.skillName}" is a plugin/managed entry from ${options.source}.`,
+                });
+                return { ok: false, checks };
+            }
+            const sourceDir = getSkillDir(options.sourceAgent, options.skillName);
+            const exists = await pathExists(sourceDir);
+            checks.push({
+                label: 'Source',
+                status: exists ? 'ok' : 'error',
+                message: exists
+                    ? `Skill folder was found: ${sourceDir}`
+                    : `Skill folder was not found: ${sourceDir}`,
+            });
+            return {
+                ok: exists,
+                checks,
+            };
+        },
+    };
+}
+async function defaultPathExists(targetPath) {
+    try {
+        await stat(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/services/sync/agent-reader.d.ts

@@ -7,6 +7,11 @@ export interface AgentMcpEntry {
 export interface AgentSkillEntry {
     name: string;
     source?: string;
+    kind?: 'skill' | 'plugin';
+    pluginSkills?: string[];
+    pluginMcps?: string[];
+    installPath?: string;
+    managed?: boolean;
 }
 export interface AgentLiveConfig {
     agent: AgentName;

package/dist/services/sync/agent-reader.js

@@ -1,6 +1,8 @@
 import { readFile, readdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
+import { mergeManagedPluginsIntoSkills, readManagedPlugins, } from './managed-plugin-registry.js';
+import { readInstalledPlugins } from './plugin-skill-reader.js';
 export function createClaudeReader() {
     return {
         async read(options) {
@@ -170,37 +172,46 @@ function parseTomlArray(raw) {
 }
 /* ---- Skill readers ---- */
 async function readClaudePlugins() {
+    const results = [];
+    // Read marketplace plugins
     try {
         const pluginsPath = path.join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
-        const source = await readFile(pluginsPath, 'utf8');
-        const data = JSON.parse(source);
-        if (!data.plugins)
-            return [];
-        return Object.keys(data.plugins).map((key) => {
-            const [name, source] = key.split('@');
-            return { name, source };
-        });
+        results.push(...await readInstalledPlugins(pluginsPath));
     }
     catch {
-        return [];
+        // no plugins file
+    }
+    // Read local skills from ~/.claude/skills/
+    try {
+        const skillsDir = path.join(homedir(), '.claude', 'skills');
+        const localSkills = await readSkillDirs(skillsDir);
+        results.push(...localSkills);
     }
+    catch {
+        // no skills dir
+    }
+    return results;
 }
 async function readCodexSkills() {
     try {
         const skillsDir = path.join(homedir(), '.codex', 'skills');
-        return await readSkillDirs(skillsDir);
+        const localSkills = await readSkillDirs(skillsDir);
+        const managedPlugins = await readManagedPlugins({ agent: 'codex' });
+        return mergeManagedPluginsIntoSkills(localSkills, managedPlugins);
     }
     catch {
-        return [];
+        return await readManagedPlugins({ agent: 'codex' });
     }
 }
 async function readGeminiSkills() {
     try {
         const skillsDir = path.join(homedir(), '.gemini', 'skills');
-        return await readSkillDirs(skillsDir);
+        const localSkills = await readSkillDirs(skillsDir);
+        const managedPlugins = await readManagedPlugins({ agent: 'gemini' });
+        return mergeManagedPluginsIntoSkills(localSkills, managedPlugins);
     }
     catch {
-        return [];
+        return await readManagedPlugins({ agent: 'gemini' });
     }
 }
 /** Shared: read skill directories (Codex and Gemini use the same SKILL.md convention) */
@@ -211,10 +222,10 @@ async function readSkillDirs(skillsDir) {
         if (entry.name.startsWith('.'))
             continue;
         if (entry.isDirectory()) {
-            skills.push({ name: entry.name, source: 'local' });
+            skills.push({ name: entry.name, source: 'local', kind: 'skill' });
         }
         else if (entry.isSymbolicLink()) {
-            skills.push({ name: entry.name, source: 'linked' });
+            skills.push({ name: entry.name, source: 'linked', kind: 'skill' });
         }
     }
     return skills;

package/dist/services/sync/claude-writer.js

@@ -65,7 +65,10 @@ export function createClaudeWriter() {
     };
 }
 function toClaudeFormat(config) {
-    if (config.type === 'npm') {
+    if (config.kind === 'remote') {
+        throw new SyncError('Remote MCP servers are not supported in Claude sync.');
+    }
+    if (config.source === 'npm') {
         return {
             type: 'stdio',
             command: 'npx',

package/dist/services/sync/codex-writer.js

@@ -27,7 +27,8 @@ export function createCodexWriter() {
             const allServers = { ...options.mcpServers };
             // Always include brainctl itself
             allServers['brainctl'] = {
-                type: 'npm',
+                kind: 'local',
+                source: 'npm',
                 package: 'brainctl',
             };
             const mcpToml = buildMcpToml(allServers);
@@ -71,7 +72,10 @@ function buildMcpToml(servers) {
     const lines = [];
     for (const [name, config] of Object.entries(servers)) {
         lines.push(`[mcp_servers.${name}]`);
-        if (config.type === 'npm') {
+        if (config.kind === 'remote') {
+            throw new SyncError('Remote MCP servers are not supported in Codex sync.');
+        }
+        if (config.source === 'npm') {
             lines.push(`command = "npx"`);
             lines.push(`args = ["-y", ${tomlString(config.package)}]`);
         }

package/dist/services/sync/gemini-writer.js

@@ -67,7 +67,10 @@ export function createGeminiWriter() {
     };
 }
 function toGeminiFormat(config) {
-    if (config.type === 'npm') {
+    if (config.kind === 'remote') {
+        throw new SyncError('Remote MCP servers are not supported in Gemini sync.');
+    }
+    if (config.source === 'npm') {
         return {
             command: 'npx',
             args: ['-y', config.package],

package/dist/services/sync/managed-plugin-registry.d.ts

@@ -0,0 +1,17 @@
+import type { AgentName } from '../../types.js';
+import type { AgentSkillEntry } from './agent-reader.js';
+export declare function readManagedPlugins(options: {
+    homeDir?: string;
+    agent: AgentName;
+}): Promise<AgentSkillEntry[]>;
+export declare function writeManagedPluginInstall(options: {
+    homeDir?: string;
+    agent: AgentName;
+    plugin: AgentSkillEntry;
+}): Promise<void>;
+export declare function removeManagedPluginInstall(options: {
+    homeDir?: string;
+    agent: AgentName;
+    pluginName: string;
+}): Promise<void>;
+export declare function mergeManagedPluginsIntoSkills(localSkills: AgentSkillEntry[], managedPlugins: AgentSkillEntry[]): AgentSkillEntry[];

package/dist/services/sync/managed-plugin-registry.js

@@ -0,0 +1,75 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+function getRegistryPath(homeDir) {
+    return path.join(homeDir, '.brainctl', 'managed-plugins.json');
+}
+export async function readManagedPlugins(options) {
+    const homeDir = options.homeDir ?? homedir();
+    const registryPath = getRegistryPath(homeDir);
+    try {
+        const source = await readFile(registryPath, 'utf8');
+        const parsed = JSON.parse(source);
+        return (parsed.agents?.[options.agent] ?? []).map((entry) => ({
+            ...entry,
+            kind: 'plugin',
+            managed: true,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function writeManagedPluginInstall(options) {
+    const homeDir = options.homeDir ?? homedir();
+    const registryPath = getRegistryPath(homeDir);
+    const existing = await readRegistryFile(homeDir);
+    const currentEntries = existing.agents?.[options.agent] ?? [];
+    const nextEntries = [
+        ...currentEntries.filter((entry) => entry.name !== options.plugin.name),
+        {
+            ...options.plugin,
+            kind: 'plugin',
+            managed: true,
+        },
+    ].sort((left, right) => left.name.localeCompare(right.name));
+    const next = {
+        version: 1,
+        agents: {
+            ...existing.agents,
+            [options.agent]: nextEntries,
+        },
+    };
+    await mkdir(path.dirname(registryPath), { recursive: true });
+    await writeFile(registryPath, JSON.stringify(next, null, 2) + '\n', 'utf8');
+}
+export async function removeManagedPluginInstall(options) {
+    const homeDir = options.homeDir ?? homedir();
+    const registryPath = getRegistryPath(homeDir);
+    const existing = await readRegistryFile(homeDir);
+    const currentEntries = existing.agents?.[options.agent] ?? [];
+    const nextEntries = currentEntries.filter((entry) => entry.name !== options.pluginName);
+    const next = {
+        version: 1,
+        agents: {
+            ...existing.agents,
+            [options.agent]: nextEntries,
+        },
+    };
+    await mkdir(path.dirname(registryPath), { recursive: true });
+    await writeFile(registryPath, JSON.stringify(next, null, 2) + '\n', 'utf8');
+}
+export function mergeManagedPluginsIntoSkills(localSkills, managedPlugins) {
+    const pluginOwnedSkills = new Set(managedPlugins.flatMap((plugin) => plugin.pluginSkills ?? []));
+    const filteredLocalSkills = localSkills.filter((skill) => !pluginOwnedSkills.has(skill.name));
+    return [...managedPlugins, ...filteredLocalSkills];
+}
+async function readRegistryFile(homeDir) {
+    try {
+        const source = await readFile(getRegistryPath(homeDir), 'utf8');
+        return JSON.parse(source);
+    }
+    catch {
+        return { version: 1, agents: {} };
+    }
+}

package/dist/services/sync/plugin-skill-reader.d.ts

@@ -0,0 +1,2 @@
+import type { AgentSkillEntry } from './agent-reader.js';
+export declare function readInstalledPlugins(installedPluginsPath: string): Promise<AgentSkillEntry[]>;

package/dist/services/sync/plugin-skill-reader.js

@@ -0,0 +1,33 @@
+import { readFile, readdir } from 'node:fs/promises';
+import path from 'node:path';
+export async function readInstalledPlugins(installedPluginsPath) {
+    const source = await readFile(installedPluginsPath, 'utf8');
+    const data = JSON.parse(source);
+    const results = [];
+    for (const [key, records] of Object.entries(data.plugins ?? {})) {
+        const [name, pluginSource] = key.split('@');
+        const installPath = records[0]?.installPath;
+        const pluginSkills = installPath ? await readPluginSkills(installPath) : [];
+        results.push({
+            name,
+            source: pluginSource,
+            kind: 'plugin',
+            installPath,
+            pluginSkills,
+        });
+    }
+    return results;
+}
+async function readPluginSkills(installPath) {
+    const skillsDir = path.join(installPath, 'skills');
+    try {
+        const entries = await readdir(skillsDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => !entry.name.startsWith('.') && entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/services/sync-service.js

@@ -1,3 +1,4 @@
+import { ProfileError } from '../errors.js';
 import { createClaudeWriter } from './sync/claude-writer.js';
 import { createCodexWriter } from './sync/codex-writer.js';
 import { createGeminiWriter } from './sync/gemini-writer.js';
@@ -21,6 +22,10 @@ export function createSyncService(dependencies = {}) {
                 throw new Error('No active profile set. Run "brainctl profile use <name>" first.');
             }
             const profile = await profileService.get({ cwd, name: meta.active_profile });
+            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 sync is not supported yet.`);
+            }
             const results = [];
             for (const agent of meta.agents) {
                 const writer = writers[agent];

package/dist/system/executables.d.ts

@@ -0,0 +1 @@
+export declare function findExecutable(command: string): Promise<string | null>;

package/dist/system/executables.js

@@ -0,0 +1,38 @@
+import { access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import path from 'node:path';
+export async function findExecutable(command) {
+    if (command.includes(path.sep)) {
+        return (await isExecutable(command)) ? command : null;
+    }
+    const pathEntries = (process.env.PATH ?? '')
+        .split(path.delimiter)
+        .filter((entry) => entry.length > 0);
+    const extensions = process.platform === 'win32'
+        ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM')
+            .split(';')
+            .filter((entry) => entry.length > 0)
+        : [''];
+    for (const pathEntry of pathEntries) {
+        for (const extension of extensions) {
+            const candidate = process.platform === 'win32' &&
+                extension.length > 0 &&
+                !command.toLowerCase().endsWith(extension.toLowerCase())
+                ? path.join(pathEntry, `${command}${extension}`)
+                : path.join(pathEntry, command);
+            if (await isExecutable(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+async function isExecutable(filePath) {
+    try {
+        await access(filePath, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}