@agenthippo-ai/agenthippo 0.1.0

package/out/cli/commands/gateway.js

@@ -0,0 +1,160 @@
+"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.gatewaySendCommand = gatewaySendCommand;
+exports.gatewayListCommand = gatewayListCommand;
+const promises_1 = require("fs/promises");
+const path = __importStar(require("path"));
+const outboundHandles_js_1 = require("../../gateway/outboundHandles.js");
+const outboundSend_js_1 = require("../../gateway/outboundSend.js");
+const utils_js_1 = require("../utils.js");
+function resolveOutboundPath(outbound) {
+    const trimmed = outbound.trim();
+    if (!trimmed) {
+        console.error('Error: --outbound is required');
+        process.exit(1);
+    }
+    return path.resolve(trimmed);
+}
+async function ensureStoreFileExists(storePath) {
+    try {
+        await (0, promises_1.access)(storePath);
+    }
+    catch {
+        console.error(`Error: gateway outbound file not found: ${storePath}`);
+        process.exit(1);
+    }
+}
+async function gatewaySendCommand(options) {
+    const storePath = resolveOutboundPath(options.outbound);
+    await ensureStoreFileExists(storePath);
+    const agentId = options.agent.trim();
+    const message = options.message.trim();
+    if (!agentId) {
+        console.error('Error: --agent is required');
+        process.exit(1);
+    }
+    if (!message) {
+        console.error('Error: --message is required');
+        process.exit(1);
+    }
+    const handle = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, agentId, {
+        target: options.target,
+        threadId: options.threadId,
+    });
+    if (!handle) {
+        console.error(`Error: No gateway outbound handle for agent "${agentId}" in ${storePath}.`);
+        if (options.target) {
+            console.error(`No stored route matching target "${options.target}".`);
+        }
+        console.error(`Run \`agenthippo gateway list --outbound "${storePath}" --agent ${agentId}\` to see known routes.`);
+        process.exit(1);
+    }
+    const result = await (0, outboundSend_js_1.sendGatewayOutboundMessage)(handle, {
+        message,
+        media: options.media,
+        dryRun: options.dryRun,
+    });
+    if (options.json) {
+        console.log(JSON.stringify({ file: storePath, handle, result }, null, 2));
+    }
+    else if (options.dryRun) {
+        console.log(`${utils_js_1.COLORS.dim}Dry run:${utils_js_1.COLORS.reset} ${result.command.join(' ')}`);
+    }
+    else if (result.ok) {
+        const via = result.via === 'hippoclaw' ? ' (via hippoclaw CLI fallback)' : '';
+        console.log(`${utils_js_1.COLORS.green}✓${utils_js_1.COLORS.reset} Sent via ${handle.channel}:${handle.target}${via}`);
+        if (result.stdout) {
+            console.log(result.stdout);
+        }
+    }
+    else {
+        console.error(`${utils_js_1.COLORS.red}✗${utils_js_1.COLORS.reset} Gateway send failed (exit ${result.exitCode ?? 'unknown'})`);
+        if (result.stderr) {
+            console.error(result.stderr);
+        }
+        if (result.stdout) {
+            console.error(result.stdout);
+        }
+        process.exit(1);
+    }
+    // One-shot CLI: RPC WebSocket must not keep the event loop alive after success.
+    process.exit(0);
+}
+function formatHandleLine(handle, isLast) {
+    const label = handle.label ? ` (${handle.label})` : '';
+    const thread = handle.threadId ? ` thread=${handle.threadId}` : '';
+    const count = handle.inboundCount > 1 ? ` ×${handle.inboundCount}` : '';
+    const lastMark = isLast ? `${utils_js_1.COLORS.green}*${utils_js_1.COLORS.reset} ` : '  ';
+    return `${lastMark}${handle.agentId}${label}: ${handle.channel} → ${handle.target}${thread}${count}`;
+}
+async function gatewayListCommand(options) {
+    const storePath = resolveOutboundPath(options.outbound);
+    await ensureStoreFileExists(storePath);
+    const snapshot = await (0, outboundHandles_js_1.getGatewayOutboundStoreSnapshot)(storePath);
+    if (options.json) {
+        console.log(JSON.stringify({ file: storePath, ...snapshot }, null, 2));
+        return;
+    }
+    const agentFilter = options.agent?.trim();
+    const agentIds = agentFilter
+        ? [agentFilter]
+        : [...new Set([...Object.keys(snapshot.targetsByAgent), ...Object.keys(snapshot.lastByAgent)])];
+    if (agentIds.length === 0) {
+        console.log(`No gateway outbound routes in ${storePath}.`);
+        return;
+    }
+    console.log(`${utils_js_1.COLORS.dim}${storePath}${utils_js_1.COLORS.reset}`);
+    for (const agentId of agentIds.sort()) {
+        const routes = snapshot.targetsByAgent[agentId] ?? [];
+        const last = snapshot.lastByAgent[agentId];
+        const lastKey = last ? (0, outboundHandles_js_1.buildGatewayOutboundHandleKey)(last.target, last.threadId) : undefined;
+        if (routes.length === 0 && last) {
+            console.log(formatHandleLine(last, true));
+            continue;
+        }
+        console.log(`${utils_js_1.COLORS.dim}${agentId}:${utils_js_1.COLORS.reset}`);
+        for (const handle of routes) {
+            const key = (0, outboundHandles_js_1.buildGatewayOutboundHandleKey)(handle.target, handle.threadId);
+            console.log(formatHandleLine(handle, key === lastKey));
+        }
+        if (routes.length > 1 && last) {
+            console.log(`${utils_js_1.COLORS.dim}  * = last inbound (default for gateway send without --target)${utils_js_1.COLORS.reset}`);
+        }
+    }
+}

package/out/cli/commands/pack.js

@@ -0,0 +1,220 @@
+"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.packCommand = packCommand;
+/**
+ * Pack Command - Agent pack management
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pack_loader_1 = require("../pack-loader");
+const branding_1 = require("../../branding");
+const BANNER_LINE = '-'.repeat(62);
+async function packCommand(options) {
+    const workspace = options.workspace;
+    switch (options.action) {
+        case 'list':
+            await listPacks(workspace);
+            break;
+        case 'validate':
+            if (!options.name) {
+                console.error('Error: Pack name required. Usage: agenthippo pack validate <name>');
+                process.exit(1);
+            }
+            await validatePack(options.name, workspace);
+            break;
+        case 'info':
+            if (!options.name) {
+                console.error('Error: Pack name required. Usage: agenthippo pack info <name>');
+                process.exit(1);
+            }
+            await showPackInfo(options.name, workspace);
+            break;
+        case 'install':
+            console.log('Pack installation is not yet implemented.');
+            console.log(`   For now, manually copy your pack to ~/${branding_1.AGENTIDE_DIR_NAME}/agents/<name>/`);
+            break;
+        case 'export':
+            console.log('Pack export is not yet implemented.');
+            break;
+        default:
+            console.error(`Error: Unknown action: ${options.action}`);
+            console.log('');
+            console.log('Available actions:');
+            console.log('  list      List installed packs');
+            console.log('  validate  Validate a pack');
+            console.log('  info      Show pack details');
+            console.log('  install   Install a pack (coming soon)');
+            console.log('  export    Export a pack (coming soon)');
+            process.exit(1);
+    }
+}
+async function listPacks(workspace) {
+    const packs = (0, pack_loader_1.listAvailablePacks)(workspace);
+    if (packs.length === 0) {
+        console.log('No agent packs found.');
+        console.log('');
+        console.log('Agent packs are stored in:');
+        if (workspace) {
+            console.log(`  Workspace: ${workspace}/${branding_1.AGENTIDE_DIR_NAME}/agents/`);
+        }
+        console.log(`  User library: ~/${branding_1.AGENTIDE_DIR_NAME}/agents/`);
+        console.log('');
+        console.log('Create a pack with:');
+        console.log(`  mkdir -p ~/${branding_1.AGENTIDE_DIR_NAME}/agents/my-agent/1.0.0`);
+        console.log(`  echo "1.0.0" > ~/${branding_1.AGENTIDE_DIR_NAME}/agents/my-agent/current.txt`);
+        console.log('  # Add agent.yaml and AGENTS.md');
+        return;
+    }
+    console.log('');
+    console.log('Installed Agent Packs:');
+    console.log('');
+    for (const pack of packs) {
+        const versionStr = pack.version ? ` (v${pack.version})` : '';
+        const sourceStr = pack.source === 'workspace' ? ' [workspace]' : '';
+        console.log(`  ${pack.name}${versionStr}${sourceStr}`);
+        console.log(`    ${pack.path}`);
+    }
+    console.log('');
+}
+async function validatePack(nameOrPath, workspace) {
+    console.log(`Validating pack: ${nameOrPath}`);
+    console.log('');
+    const packPath = (0, pack_loader_1.resolvePackPath)(nameOrPath, workspace);
+    if (!packPath) {
+        console.error(`Error: Pack not found: ${nameOrPath}`);
+        process.exit(1);
+    }
+    const errors = [];
+    const warnings = [];
+    // Check agent.yaml
+    const manifestPath = path.join(packPath, 'agent.yaml');
+    if (fs.existsSync(manifestPath)) {
+        console.log('  OK: agent.yaml exists');
+    }
+    else {
+        errors.push('Missing agent.yaml');
+    }
+    // Try to load and validate
+    try {
+        const pack = await (0, pack_loader_1.loadAgentPack)(nameOrPath, workspace);
+        console.log(`  OK: metadata.name: ${pack.manifest.metadata.name}`);
+        console.log(`  OK: metadata.version: ${pack.manifest.metadata.version}`);
+        console.log(`  OK: spec.engine: ${pack.manifest.spec.engine}`);
+        if (pack.manifest.spec.model) {
+            console.log(`  OK: spec.model: ${pack.manifest.spec.model}`);
+        }
+        else {
+            warnings.push('spec.model not specified, will use default');
+        }
+        if (pack.manifest.spec.cheapModel) {
+            console.log(`  OK: spec.cheapModel: ${pack.manifest.spec.cheapModel}`);
+        }
+        // Check AGENTS.md
+        const agentsMdPath = path.join(packPath, 'AGENTS.md');
+        if (fs.existsSync(agentsMdPath)) {
+            const stats = fs.statSync(agentsMdPath);
+            console.log(`  OK: AGENTS.md exists (${(stats.size / 1024).toFixed(1)} KB)`);
+        }
+        else {
+            warnings.push('No AGENTS.md found');
+        }
+    }
+    catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+    }
+    // Summary
+    console.log('');
+    if (warnings.length > 0) {
+        for (const warning of warnings) {
+            console.log(`  Warning: ${warning}`);
+        }
+    }
+    if (errors.length > 0) {
+        for (const error of errors) {
+            console.log(`  Error: ${error}`);
+        }
+        console.log('');
+        console.log('Pack is INVALID');
+        process.exit(1);
+    }
+    console.log('');
+    console.log('Pack is valid.');
+}
+async function showPackInfo(nameOrPath, workspace) {
+    try {
+        const pack = await (0, pack_loader_1.loadAgentPack)(nameOrPath, workspace);
+        console.log('');
+        console.log(BANNER_LINE);
+        console.log(`Agent: ${pack.manifest.metadata.name}`);
+        console.log(BANNER_LINE);
+        console.log(`Version:     ${pack.manifest.metadata.version}`);
+        if (pack.manifest.metadata.description) {
+            console.log(`Description: ${pack.manifest.metadata.description}`);
+        }
+        if (pack.manifest.metadata.author) {
+            console.log(`Author:      ${pack.manifest.metadata.author}`);
+        }
+        console.log(`Engine:      ${pack.manifest.spec.engine}`);
+        if (pack.manifest.spec.model) {
+            console.log(`Model:       ${pack.manifest.spec.model}`);
+        }
+        if (pack.manifest.spec.cheapModel) {
+            console.log(`Cheap Model: ${pack.manifest.spec.cheapModel}`);
+        }
+        console.log(`Path:        ${pack.packPath}`);
+        if (pack.manifest.spec.permissions) {
+            console.log('');
+            console.log('Permissions:');
+            console.log(`  File Access: ${pack.manifest.spec.permissions.fileAccess || 'default'}`);
+        }
+        if (pack.manifest.spec.mcpServers && pack.manifest.spec.mcpServers.length > 0) {
+            console.log('');
+            console.log('MCP Servers:');
+            for (const server of pack.manifest.spec.mcpServers) {
+                console.log(`  - ${server.name}`);
+            }
+        }
+        console.log(BANNER_LINE);
+        console.log('');
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+}

package/out/cli/commands/probe-custom-engine.js

@@ -0,0 +1,82 @@
+"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.probeCustomEngineCommand = probeCustomEngineCommand;
+const path = __importStar(require("node:path"));
+const custom_1 = require("../../engines/custom");
+const customRegistry_1 = require("../../engines/customRegistry");
+const STRATEGIES = ['in-process', 'node-subprocess'];
+function parseStrategyArg(raw) {
+    if (!raw?.trim() || raw === 'all') {
+        return 'all';
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'a' || normalized === 'in-process' || normalized === 'inprocess') {
+        return 'in-process';
+    }
+    if (normalized === 'b' || normalized === 'c' || normalized === 'bun-subprocess' || normalized === 'bun' || normalized === 'node-subprocess' || normalized === 'node') {
+        return 'node-subprocess';
+    }
+    throw new Error(`Unknown strategy "${raw}". Use in-process, node-subprocess, or all.`);
+}
+async function probeCustomEngineCommand(options) {
+    const engineId = options.engine.trim();
+    const workspaceRoot = path.resolve(options.workspace);
+    const manifest = (0, customRegistry_1.resolveCustomEngineManifest)(workspaceRoot, engineId);
+    const strategyArg = parseStrategyArg(options.strategy);
+    const toRun = strategyArg === 'all' ? STRATEGIES : [strategyArg];
+    console.log(`Probing custom engine "${manifest.id}" import (${manifest.entryPath})`);
+    console.log(`Workspace: ${workspaceRoot}`);
+    console.log('');
+    let anyOk = false;
+    for (const strategy of toRun) {
+        const result = await (0, custom_1.probeCustomEngineImport)(manifest, strategy);
+        if (result.ok) {
+            anyOk = true;
+            console.log(`  [PASS] ${strategy}`);
+        }
+        else {
+            console.log(`  [FAIL] ${strategy}`);
+            console.log(`         ${result.error ?? 'unknown error'}`);
+        }
+    }
+    console.log('');
+    if (!anyOk) {
+        process.exit(1);
+    }
+}