@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/headless/sync.js

@@ -1,473 +0,0 @@
-"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/live-e2e/mcp-demo/server.mjs

@@ -1,32 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-
-const BALANCES = {
-  'alice@corp.com': 4242,
-  'bob@corp.com': 99,
-};
-const TURN = 'ai.agenthippo/turn';
-
-const server = new Server({ name: 'e2e-demo', version: '0.0.1' }, { capabilities: { tools: {} } });
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [{
-    name: 'get_my_balance',
-    description: 'Return the signed-in user balance. No args.',
-    inputSchema: { type: 'object', properties: {} },
-  }],
-}));
-server.setRequestHandler(CallToolRequestSchema, async (req) => {
-  const turn = (req.params._meta ?? {})[TURN] ?? null;
-  const userId = typeof turn?.userId === 'string' ? turn.userId.trim() : '';
-  if (!userId) {
-    return { isError: true, content: [{ type: 'text', text: 'fail-closed: no verified user' }] };
-  }
-  const bal = BALANCES[userId];
-  if (bal === undefined) {
-    return { isError: true, content: [{ type: 'text', text: `fail-closed: no balance for ${userId}` }] };
-  }
-  console.error(`[e2e-connector] ${userId} → ${bal}`);
-  return { content: [{ type: 'text', text: JSON.stringify({ userId, balance: bal }) }] };
-});
-await server.connect(new StdioServerTransport());

package/out/live-probe/connector.mjs

@@ -1,8 +0,0 @@
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-const server = new Server({ name: 'probe', version: '0.0.1' }, { capabilities: { tools: {} } });
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [{ name: 'probe_tool', description: 'x', inputSchema: { type: 'object' } }] }));
-server.setRequestHandler(CallToolRequestSchema, async () => ({ content: [{ type: 'text', text: 'MAGIC=zebra42' }] }));
-await server.connect(new StdioServerTransport());

package/out/live-probe/env-report.mjs

@@ -1,8 +0,0 @@
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-const server = new Server({ name: 'env-report', version: '0.0.1' }, { capabilities: { tools: {} } });
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [{ name: 'report_env', description: 'reports a probe env var', inputSchema: { type: 'object' } }] }));
-server.setRequestHandler(CallToolRequestSchema, async () => ({ content: [{ type: 'text', text: 'PROBE_SEEN=' + (process.env.AGENTHIPPO_PROBE_ENV || 'ABSENT') }] }));
-await server.connect(new StdioServerTransport());