@agenthippo-ai/agenthippo 0.1.0

package/out/headless/sync.js

@@ -0,0 +1,473 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncPackMcpToWorkspace = syncPackMcpToWorkspace;
+exports.syncPackToWorkspace = syncPackToWorkspace;
+exports.computeSkillsSignature = computeSkillsSignature;
+exports.createSkillsSignatureGetter = createSkillsSignatureGetter;
+exports.createSessionDir = createSessionDir;
+exports.getSessionDir = getSessionDir;
+/**
+ * Headless Sync
+ *
+ * Simple one-time sync of pack content to workspace derived directories.
+ * This is a lightweight alternative to the full SyncService used in the extension.
+ *
+ * The extension's SyncService handles:
+ * - File watchers for live reload
+ * - Bi-directional sync
+ * - Manifest tracking
+ * - Remote skills sync
+ *
+ * This module does:
+ * - One-time copy of pack content to <brand>/agents/<packId>/ (where engines look)
+ * - Copy AGENTS.md to .claude/CLAUDE.md and .codex/AGENTS.md (derived dirs)
+ * - Symlink skills/ and rules/ directories
+ * - Create session directories
+ * - Compute skills signature for cache invalidation
+ */
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const utils_1 = require("../utils");
+const shared_1 = require("../shared");
+const paths_1 = require("../agentpack/paths");
+const manifest_1 = require("../agentpack/manifest");
+const mcp_1 = require("../mcp");
+const customRegistry_1 = require("../engines/customRegistry");
+/**
+ * Merge pack agent.yaml spec.mcp configs into workspace .mcp.json so loadMcpServers()
+ * and inline custom-engine MCP work after syncPackToWorkspace (serve/ask).
+ */
+async function syncPackMcpToWorkspace(packPath, workspaceRoot, packId, logger) {
+    const manifestPath = path.join(packPath, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+    if (!(await (0, utils_1.pathExists)(manifestPath))) {
+        return;
+    }
+    let manifest;
+    try {
+        manifest = await (0, manifest_1.loadAgentManifest)(manifestPath);
+    }
+    catch (e) {
+        logInfo(logger, `[AgentIDE] Skipping pack MCP sync for ${packId}: ${e instanceof Error ? e.message : String(e)}`);
+        return;
+    }
+    const mcpEntries = manifest.spec?.mcp;
+    if (!mcpEntries?.length) {
+        return;
+    }
+    const agentideMcpDir = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, paths_1.AGENT_CONSTANTS.AGENTS_DIR, packId, paths_1.AGENT_CONSTANTS.MCP_DIR);
+    await fs_1.promises.mkdir(agentideMcpDir, { recursive: true });
+    const merged = { mcpServers: {} };
+    const targetPath = path.join(agentideMcpDir, '.mcp.json');
+    for (const entry of mcpEntries) {
+        const configRel = entry.config?.trim();
+        if (!configRel) {
+            continue;
+        }
+        const configPath = path.resolve(packPath, configRel);
+        if (!isWithin(packPath, configPath)) {
+            logInfo(logger, `[AgentIDE] Skipping MCP config ${configRel}: path escapes pack root`);
+            continue;
+        }
+        if (!(await (0, utils_1.pathExists)(configPath))) {
+            logInfo(logger, `[AgentIDE] Skipping MCP config ${configRel}: file not found`);
+            continue;
+        }
+        try {
+            const raw = JSON.parse(await fs_1.promises.readFile(configPath, 'utf8'));
+            const servers = raw.mcpServers;
+            if (servers && typeof servers === 'object') {
+                Object.assign(merged.mcpServers, servers);
+            }
+        }
+        catch (e) {
+            logInfo(logger, `[AgentIDE] Skipping MCP config ${configRel}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    // Copy pack mcp/ subdirs (server assets referenced via ${serverDir}/…).
+    const packMcpDir = path.join(packPath, paths_1.AGENT_CONSTANTS.MCP_DIR);
+    if (await (0, utils_1.pathExists)(packMcpDir)) {
+        const entries = await fs_1.promises.readdir(packMcpDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.')) {
+                continue;
+            }
+            const src = path.join(packMcpDir, entry.name);
+            const dst = path.join(agentideMcpDir, entry.name);
+            if (!(await (0, utils_1.pathExists)(dst))) {
+                await (0, utils_1.copyDirRecursive)(src, dst);
+            }
+        }
+    }
+    if (!merged.mcpServers || Object.keys(merged.mcpServers).length === 0) {
+        return;
+    }
+    await (0, utils_1.writeFileIfChanged)(targetPath, `${JSON.stringify(merged, null, 2)}\n`);
+    logInfo(logger, `[AgentIDE] Synced pack MCP config: ${targetPath}`);
+}
+function isRelativeLocalPath(value) {
+    if (!value || !value.trim()) {
+        return false;
+    }
+    if (path.isAbsolute(value)) {
+        return false;
+    }
+    if (/^(https?:\/\/|git@|ssh:\/\/)/i.test(value)) {
+        return false;
+    }
+    return true;
+}
+function isWithin(baseDir, candidate) {
+    const rel = path.relative(baseDir, candidate);
+    return rel !== '..' && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
+}
+async function isDirEmpty(targetDir) {
+    const entries = await fs_1.promises.readdir(targetDir);
+    return entries.length === 0;
+}
+async function seedPackDataIfNeeded(workspaceRoot, packPath, packId, logger) {
+    const manifestPath = path.join(packPath, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+    if (!(await (0, utils_1.pathExists)(manifestPath))) {
+        return;
+    }
+    try {
+        const manifest = await (0, manifest_1.loadAgentManifest)(manifestPath);
+        const data = manifest.spec?.data;
+        if (!data) {
+            return;
+        }
+        const sourcePath = data.sourcePath?.trim() || './data';
+        const workspacePath = (data.workspacePath?.trim() || `.${path.sep}${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}${path.sep}data${path.sep}${packId}`)
+            .replace(/^(?:\.\/|\.\\)/, '');
+        if (!isRelativeLocalPath(sourcePath) || !isRelativeLocalPath(workspacePath)) {
+            logInfo(logger, `[AgentIDE] Skipping data sync for ${packId}: invalid spec.data paths`);
+            return;
+        }
+        const sourceDir = path.resolve(packPath, sourcePath);
+        const targetDir = path.resolve(workspaceRoot, workspacePath);
+        if (!isWithin(packPath, sourceDir) || !isWithin(workspaceRoot, targetDir)) {
+            logInfo(logger, `[AgentIDE] Skipping data sync for ${packId}: path escapes allowed root`);
+            return;
+        }
+        if (!(await (0, utils_1.pathExists)(sourceDir))) {
+            return;
+        }
+        if (!(await (0, utils_1.pathExists)(targetDir))) {
+            await (0, utils_1.copyDirRecursive)(sourceDir, targetDir);
+            logInfo(logger, `[AgentIDE] Seeded pack data for ${packId}: ${targetDir}`);
+            return;
+        }
+        const st = await fs_1.promises.stat(targetDir);
+        if (st.isDirectory() && await isDirEmpty(targetDir)) {
+            await (0, utils_1.copyDirRecursive)(sourceDir, targetDir);
+            logInfo(logger, `[AgentIDE] Seeded pack data for ${packId}: ${targetDir}`);
+        }
+    }
+    catch (e) {
+        logInfo(logger, `[AgentIDE] Skipping data sync for ${packId}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+async function skillDirHasReadableSkillMd(skillDir) {
+    const skillMd = path.join(skillDir, 'SKILL.md');
+    try {
+        const stat = await fs_1.promises.lstat(skillMd);
+        if (stat.isSymbolicLink()) {
+            const link = await fs_1.promises.readlink(skillMd);
+            const linkAbs = path.isAbsolute(link) ? link : path.resolve(path.dirname(skillMd), link);
+            if (path.resolve(linkAbs) === path.resolve(skillMd)) {
+                return false;
+            }
+        }
+        await fs_1.promises.access(skillMd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function mergeBundledSkillsIntoAgentideDir(bundledBasePromptsDir, agentideSkillsDir, logger) {
+    const bundledSkillsDir = path.join(bundledBasePromptsDir, 'skills');
+    if (!(await (0, utils_1.pathExists)(bundledSkillsDir))) {
+        return;
+    }
+    await fs_1.promises.mkdir(agentideSkillsDir, { recursive: true });
+    const entries = await fs_1.promises.readdir(bundledSkillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const dstSkill = path.join(agentideSkillsDir, entry.name);
+        if (await (0, utils_1.pathExists)(dstSkill) && await skillDirHasReadableSkillMd(dstSkill)) {
+            continue;
+        }
+        if (await (0, utils_1.pathExists)(dstSkill)) {
+            await fs_1.promises.rm(dstSkill, { recursive: true, force: true });
+        }
+        await (0, utils_1.copyDirRecursive)(path.join(bundledSkillsDir, entry.name), dstSkill);
+        logInfo(logger, `[AgentIDE] Bootstrapped bundled skill: ${entry.name}`);
+    }
+}
+/**
+ * Sync pack content to workspace directories.
+ *
+ * This prepares the workspace so that the engine SDKs can find the pack's
+ * AGENTS.md, rules, and skills. Syncs to both:
+ * - <brand>/agents/<packId>/ (where engines look for skills)
+ * - .claude/ or .codex/ (derived dirs for rules files)
+ *
+ * @param workspaceRoot - The workspace directory where the engine will run
+ * @param packPath - Path to the pack (e.g., ~/<brand>/agents/joker/1.0.0/)
+ * @param packId - The pack ID (e.g., 'joker' or 'default')
+ * @param engine - Which engine to sync for ('claude' or 'codex')
+ * @param logger - Logger for output
+ * @param bundledBasePromptsDir - Optional path to extension's base-prompts (for default agent MCP sync)
+ */
+async function syncPackToWorkspace(workspaceRoot, packPath, packId, engine, logger, bundledBasePromptsDir) {
+    const builtinEngine = shared_1.AGENT_ENGINES[engine];
+    const engineConfig = builtinEngine
+        ? {
+            workspaceDir: builtinEngine.workspaceDir,
+            rulesFile: builtinEngine.rulesFile,
+            includeSkills: true,
+            includeRules: true,
+        }
+        : (() => {
+            const manifest = (0, customRegistry_1.tryResolveCustomEngineManifest)(workspaceRoot, engine);
+            if (!manifest) {
+                throw new Error(`Unknown engine: ${engine}`);
+            }
+            if (!manifest.workspaceSync?.enabled) {
+                return undefined;
+            }
+            return {
+                workspaceDir: manifest.workspaceSync.dir,
+                rulesFile: manifest.workspaceSync.rulesFile,
+                includeSkills: manifest.workspaceSync.includeSkills,
+                includeRules: manifest.workspaceSync.includeRules,
+            };
+        })();
+    const agentsMdPath = path.join(packPath, 'AGENTS.md');
+    const contextMdPath = path.join(packPath, 'context.md');
+    const skillsDir = path.join(packPath, 'skills');
+    const rulesDir = path.join(packPath, 'rules');
+    // 1. Ensure workspace has .gitignore for derived dirs
+    await (0, utils_1.ensureWorkspaceGitAndGitignore)(workspaceRoot, logger);
+    // 2. Sync to <brand>/agents/<packId>/ (where engines look for skills)
+    const agentideAgentsDir = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, paths_1.AGENT_CONSTANTS.AGENTS_DIR, packId);
+    await fs_1.promises.mkdir(agentideAgentsDir, { recursive: true });
+    // Copy AGENTS.md to <brand>/agents/<packId>/
+    if (await (0, utils_1.pathExists)(agentsMdPath)) {
+        const agentsContent = await fs_1.promises.readFile(agentsMdPath, 'utf8');
+        await (0, utils_1.writeFileIfChanged)(path.join(agentideAgentsDir, paths_1.AGENT_CONSTANTS.AGENTS_MD), agentsContent);
+    }
+    // Copy context.md to <brand>/agents/<packId>/
+    if (await (0, utils_1.pathExists)(contextMdPath)) {
+        const contextContent = await fs_1.promises.readFile(contextMdPath, 'utf8');
+        await (0, utils_1.writeFileIfChanged)(path.join(agentideAgentsDir, paths_1.AGENT_CONSTANTS.CONTEXT_MD), contextContent);
+    }
+    // Copy GHOST_TEXT.md (inline completions prompt) if pack includes one
+    const ghostTextPath = path.join(packPath, paths_1.AGENT_CONSTANTS.GHOST_TEXT_FILE);
+    if (await (0, utils_1.pathExists)(ghostTextPath)) {
+        const ghostTextContent = await fs_1.promises.readFile(ghostTextPath, 'utf8');
+        await (0, utils_1.writeFileIfChanged)(path.join(agentideAgentsDir, paths_1.AGENT_CONSTANTS.GHOST_TEXT_FILE), ghostTextContent);
+        logInfo(logger, `[AgentIDE] Synced GHOST_TEXT.md to ${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}`);
+    }
+    // Sync skills/ to <brand>/agents/<packId>/skills/
+    const agentideSkillsDir = path.join(agentideAgentsDir, paths_1.AGENT_CONSTANTS.SKILLS_DIR);
+    const resolvedSkillsDir = path.resolve(skillsDir);
+    const resolvedAgentideSkillsDir = path.resolve(agentideSkillsDir);
+    if (await (0, utils_1.pathExists)(skillsDir)) {
+        if (resolvedSkillsDir === resolvedAgentideSkillsDir) {
+            logInfo(logger, `[AgentIDE] Skipping skills self-sync (pack already under ${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}/agents/${packId})`);
+        }
+        else {
+            await (0, utils_1.syncDirByFileLinks)(skillsDir, agentideSkillsDir, logger, `${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}/agents/${packId}/skills`);
+            logInfo(logger, `[AgentIDE] Synced skills to ${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}: ${agentideSkillsDir}`);
+        }
+    }
+    if (bundledBasePromptsDir) {
+        await mergeBundledSkillsIntoAgentideDir(bundledBasePromptsDir, agentideSkillsDir, logger);
+    }
+    // Sync rules/ to <brand>/agents/<packId>/rules/
+    const agentideRulesDir = path.join(agentideAgentsDir, paths_1.AGENT_CONSTANTS.RULES_DIR);
+    if (await (0, utils_1.pathExists)(rulesDir)) {
+        await fs_1.promises.mkdir(agentideRulesDir, { recursive: true });
+        const entries = await fs_1.promises.readdir(rulesDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.toLowerCase().endsWith('.md')) {
+                continue;
+            }
+            const src = path.join(rulesDir, entry.name);
+            const dst = path.join(agentideRulesDir, entry.name);
+            await (0, utils_1.symlinkOrCopyFile)(src, dst, logger, `rules/${entry.name}`, { force: true });
+        }
+    }
+    // Sync MCP config to <brand>/agents/<packId>/mcp/.mcp.json (for default agent)
+    if (packId === paths_1.AGENT_CONSTANTS.DEFAULT_AGENT_ID && bundledBasePromptsDir) {
+        const mcpConfig = await (0, mcp_1.getDefaultMcpConfig)(bundledBasePromptsDir);
+        if (mcpConfig) {
+            const agentideMcpDir = path.join(agentideAgentsDir, paths_1.AGENT_CONSTANTS.MCP_DIR);
+            await fs_1.promises.mkdir(agentideMcpDir, { recursive: true });
+            const mcpConfigPath = path.join(agentideMcpDir, '.mcp.json');
+            await (0, utils_1.writeFileIfChanged)(mcpConfigPath, mcpConfig);
+            logInfo(logger, `[AgentIDE] Synced MCP config: ${mcpConfigPath}`);
+        }
+    }
+    // Pack-declared MCP (agent.yaml spec.mcp → workspace .mcp.json for inline engine pass-through)
+    await syncPackMcpToWorkspace(packPath, workspaceRoot, packId, logger);
+    // Seed optional data directory into workspace (seed-if-empty)
+    await seedPackDataIfNeeded(workspaceRoot, packPath, packId, logger);
+    if (!engineConfig) {
+        return;
+    }
+    // 3. Sync to derived directory (.claude/, .codex/, or manifest workspaceSync.dir)
+    const derivedDir = path.join(workspaceRoot, engineConfig.workspaceDir);
+    await fs_1.promises.mkdir(derivedDir, { recursive: true });
+    // Read and combine AGENTS.md with context.md
+    let content = '';
+    if (await (0, utils_1.pathExists)(agentsMdPath)) {
+        content = await fs_1.promises.readFile(agentsMdPath, 'utf8');
+    }
+    if (await (0, utils_1.pathExists)(contextMdPath)) {
+        const contextContent = await fs_1.promises.readFile(contextMdPath, 'utf8');
+        content = content.trimEnd() + '\n\n---\n\n' + contextContent.trimEnd() + '\n';
+    }
+    // Write to engine-specific rules file
+    const rulesFilePath = path.join(derivedDir, engineConfig.rulesFile);
+    if (content) {
+        await (0, utils_1.writeFileIfChanged)(rulesFilePath, content);
+        logInfo(logger, `[AgentIDE] Synced rules: ${rulesFilePath}`);
+    }
+    // Sync skills/ to derived dir (pack + bundled skills under agentide agents dir)
+    const derivedSkillsDir = path.join(derivedDir, 'skills');
+    if (engineConfig.includeSkills && await (0, utils_1.pathExists)(agentideSkillsDir)) {
+        await (0, utils_1.syncDirByFileLinks)(agentideSkillsDir, derivedSkillsDir, logger, `${engineConfig.workspaceDir}/skills`);
+    }
+    // Sync rules/ fragments to derived dir
+    const derivedRulesDir = path.join(derivedDir, 'rules');
+    if (engineConfig.includeRules && await (0, utils_1.pathExists)(rulesDir)) {
+        await fs_1.promises.mkdir(derivedRulesDir, { recursive: true });
+        const entries = await fs_1.promises.readdir(rulesDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.toLowerCase().endsWith('.md')) {
+                continue;
+            }
+            const src = path.join(rulesDir, entry.name);
+            const dst = path.join(derivedRulesDir, entry.name);
+            await (0, utils_1.symlinkOrCopyFile)(src, dst, logger, `rules/${entry.name}`, { force: true });
+        }
+    }
+    logInfo(logger, `[AgentIDE] Pack '${packId}' synced to workspace: ${workspaceRoot}`);
+}
+// -----------------------------------------------------------------------------
+// Skills Signature
+// -----------------------------------------------------------------------------
+/**
+ * Compute a signature for the skills directory (for cache invalidation).
+ * This matches what SyncService.getSkillsSignature does but is standalone.
+ *
+ * @param workspaceRoot - The workspace root directory
+ * @param packId - The pack ID to get skills signature for
+ * @returns Hash signature or undefined if no skills
+ */
+function computeSkillsSignature(workspaceRoot, packId) {
+    const skillsDir = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, paths_1.AGENT_CONSTANTS.AGENTS_DIR, packId, paths_1.AGENT_CONSTANTS.SKILLS_DIR);
+    try {
+        const fs = require('fs');
+        if (!fs.existsSync(skillsDir)) {
+            return undefined;
+        }
+        const hash = (0, crypto_1.createHash)('sha256');
+        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.')) {
+                continue;
+            }
+            const skillMdPath = path.join(skillsDir, entry.name, 'SKILL.md');
+            if (fs.existsSync(skillMdPath)) {
+                const stat = fs.statSync(skillMdPath);
+                hash.update(`${entry.name}:${stat.mtimeMs}`);
+            }
+        }
+        return hash.digest('hex').slice(0, 16);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Create a getter function for skills signature compatible with engine constructor.
+ */
+function createSkillsSignatureGetter(packId) {
+    return (workspaceRoot) => computeSkillsSignature(workspaceRoot, packId);
+}
+// -----------------------------------------------------------------------------
+// Session Management
+// -----------------------------------------------------------------------------
+/**
+ * Create a session directory and return the session ID.
+ * Creates <brand>/sessions/<sessionId>/ in the workspace.
+ *
+ * @param workspaceRoot - The workspace root directory
+ * @returns The session ID (UUID)
+ */
+async function createSessionDir(workspaceRoot) {
+    const sessionId = (0, crypto_1.randomUUID)();
+    const sessionDir = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, paths_1.AGENT_CONSTANTS.SESSIONS_DIR, sessionId);
+    await fs_1.promises.mkdir(sessionDir, { recursive: true });
+    return sessionId;
+}
+/**
+ * Get the session directory path for a given session ID.
+ */
+function getSessionDir(workspaceRoot, sessionId) {
+    return path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, paths_1.AGENT_CONSTANTS.SESSIONS_DIR, sessionId);
+}
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+/** Helper to log a message */
+function logInfo(logger, msg) {
+    if (logger.appendLine) {
+        logger.appendLine(msg);
+    }
+    else if (logger.info) {
+        logger.info(msg);
+    }
+}

package/out/mcp/publish.js

@@ -0,0 +1,143 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------------------------
+ *  MCP server validation and file collection for publishing.
+ *  Publishing uses the central store via publishToStore() in store/index.ts.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMcpConfig = validateMcpConfig;
+exports.createMcpManifest = createMcpManifest;
+exports.collectMcpFiles = collectMcpFiles;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+// -----------------------------------------------------------------------------
+// Validation
+// -----------------------------------------------------------------------------
+/**
+ * Validate MCP server configuration.
+ */
+function validateMcpConfig(config) {
+    const errors = [];
+    const warnings = [];
+    if (!config.name) {
+        errors.push('MCP server config missing: name');
+    }
+    if (!config.version) {
+        errors.push('MCP server config missing: version');
+    }
+    else if (!/^\d+\.\d+\.\d+/.test(config.version)) {
+        errors.push(`Invalid version format: ${config.version}. Use semver (e.g., 1.0.0)`);
+    }
+    if (!config.transport) {
+        errors.push('MCP server config missing: transport (stdio, sse, or http)');
+    }
+    else if (!['stdio', 'sse', 'http'].includes(config.transport)) {
+        errors.push(`Invalid transport: ${config.transport}. Must be stdio, sse, or http`);
+    }
+    // Transport-specific validation
+    if (config.transport === 'stdio') {
+        if (!config.command && !config.npmPackage) {
+            errors.push('stdio transport requires command or npmPackage');
+        }
+    }
+    else if (config.transport === 'sse' || config.transport === 'http') {
+        if (!config.url) {
+            warnings.push(`${config.transport} transport typically requires a url`);
+        }
+    }
+    if (!config.description) {
+        warnings.push('Consider adding a description for discoverability');
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+// -----------------------------------------------------------------------------
+// Manifest Creation
+// -----------------------------------------------------------------------------
+/**
+ * Create an MCP manifest object from config.
+ */
+function createMcpManifest(config) {
+    return {
+        name: config.name,
+        version: config.version,
+        description: config.description,
+        transport: config.transport,
+        command: config.command,
+        args: config.args,
+        env: config.env,
+        url: config.url,
+        npmPackage: config.npmPackage,
+    };
+}
+// -----------------------------------------------------------------------------
+// File Collection
+// -----------------------------------------------------------------------------
+/**
+ * Collect all files from an MCP server directory.
+ */
+async function collectMcpFiles(dir) {
+    const files = [];
+    async function walk(currentDir, prefix) {
+        const entries = await fs_1.promises.readdir(currentDir);
+        for (const entry of entries) {
+            // Skip common non-source files
+            if (entry.startsWith('.') ||
+                entry === 'node_modules' ||
+                entry === 'dist' ||
+                entry === 'build') {
+                continue;
+            }
+            const fullPath = path.join(currentDir, entry);
+            const relativePath = prefix ? `${prefix}/${entry}` : entry;
+            const stat = await fs_1.promises.stat(fullPath);
+            if (stat.isDirectory()) {
+                await walk(fullPath, relativePath);
+            }
+            else if (stat.isFile()) {
+                // Only include source files
+                const ext = path.extname(entry).toLowerCase();
+                if (['.ts', '.js', '.json', '.md', '.py', '.sh', '.yaml', '.yml'].includes(ext)) {
+                    const content = await fs_1.promises.readFile(fullPath, 'utf-8');
+                    files.push({ path: relativePath, content });
+                }
+            }
+        }
+    }
+    await walk(dir, '');
+    return files;
+}