@agenthippo-ai/agenthippo 0.1.0

package/out/cli/commands/store.js

@@ -0,0 +1,919 @@
+"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.storeCommand = storeCommand;
+exports.resolvePublishBundleMode = resolvePublishBundleMode;
+/**
+ * Store Command - Search and install from the store
+ *
+ * Commands:
+ *   agenthippo store search <query>              Search for skills/packs/mcp/engines
+ *   agenthippo store install <type/slug>         Install from store
+ *   agenthippo store publish <type/slug>       Publish engine or Spotlight view
+ *   agenthippo store publish view/<id>[@ver] [--bundle full|scripts-only] [--full]
+ *   agenthippo store uninstall engine/<slug>     Uninstall a custom engine
+ *   agenthippo store info <type/slug>            Show artifact details
+ */
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const zlib_1 = require("zlib");
+const branding_1 = require("../../branding");
+const index_1 = require("../../registry/index");
+const shared_1 = require("../../store/shared");
+const install_1 = require("../../engines/install");
+const publish_1 = require("../../engines/publish");
+const index_2 = require("../../store/index");
+const publish_2 = require("../../spotlight/publish");
+// -----------------------------------------------------------------------------
+// Configuration
+// -----------------------------------------------------------------------------
+/**
+ * Get store configuration from environment variables with defaults.
+ *
+ * Environment variables (CLI only; agentide.storeRepo in VS Code settings is not read here):
+ *   AGENTHIPPO_STORE_REPO    - GitHub repo (e.g., "myorg/my-store")
+ *   AGENTHIPPO_STORE_URL     - Direct index URL (overrides repo-based URL)
+ */
+function getStoreConfig() {
+    const repoEnv = process.env.AGENTHIPPO_STORE_REPO;
+    let owner = shared_1.DEFAULT_STORE_OWNER;
+    let repo = shared_1.DEFAULT_STORE_REPO;
+    if (repoEnv) {
+        const parts = repoEnv.split('/');
+        if (parts.length === 2) {
+            owner = parts[0];
+            repo = parts[1];
+        }
+    }
+    return {
+        owner,
+        repo,
+        defaultBranch: shared_1.DEFAULT_STORE_BRANCH,
+        paths: shared_1.STORE_PATHS,
+    };
+}
+function getIndexUrl() {
+    // Direct URL override
+    if (process.env.AGENTHIPPO_STORE_URL) {
+        return process.env.AGENTHIPPO_STORE_URL;
+    }
+    const config = getStoreConfig();
+    return `https://${config.owner}.github.io/${config.repo}/store-index.json`;
+}
+/**
+ * Get GitHub token for private repo access.
+ * Checks: GITHUB_TOKEN, GH_TOKEN, AGENTHIPPO_GITHUB_TOKEN
+ */
+function getGitHubToken() {
+    return process.env.GITHUB_TOKEN
+        || process.env.GH_TOKEN
+        || process.env.AGENTHIPPO_GITHUB_TOKEN;
+}
+/**
+ * Make authenticated GitHub API request (if token available).
+ */
+async function githubFetch(url, options = {}) {
+    const token = getGitHubToken();
+    const headers = {
+        'User-Agent': 'AgentHippo-CLI',
+        Accept: 'application/vnd.github.v3+json',
+        ...(options.headers || {}),
+    };
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    return fetch(url, {
+        ...options,
+        headers,
+        redirect: 'follow',
+    });
+}
+// -----------------------------------------------------------------------------
+// Console Logger (CLI-compatible)
+// -----------------------------------------------------------------------------
+const cliLogger = {
+    appendLine: (msg) => {
+        if (process.env.VERBOSE === '1') {
+            console.error(msg);
+        }
+    },
+};
+// -----------------------------------------------------------------------------
+// Main Command
+// -----------------------------------------------------------------------------
+async function storeCommand(options) {
+    if (options.verbose) {
+        process.env.VERBOSE = '1';
+    }
+    switch (options.action) {
+        case 'search':
+            await searchStore(options);
+            break;
+        case 'install':
+            await installFromStore(options);
+            break;
+        case 'publish':
+            await publishToStoreFromCli(options);
+            break;
+        case 'uninstall':
+        case 'remove':
+            await uninstallFromStore(options);
+            break;
+        case 'info':
+            await showStoreInfo(options);
+            break;
+        case 'list':
+            await listStoreArtifacts(options);
+            break;
+        default:
+            console.error(`Error: Unknown action: ${options.action}`);
+            console.log('');
+            console.log('Available actions:');
+            console.log('  search <query>     Search for skills, packs, MCP servers, engines');
+            console.log('  install <ref>      Install artifact (e.g., skill/pdf-tools@1.0.0)');
+            console.log('  publish <ref>      Publish engine/<id> or view/<id>[@version]');
+            console.log('  uninstall <ref>    Uninstall artifact (currently engine/<slug>)');
+            console.log('  info <ref>         Show artifact details');
+            console.log('  list               List all available artifacts');
+            console.log('');
+            console.log('  Override store repo (CLI): AGENTHIPPO_STORE_REPO=owner/repo');
+            process.exit(1);
+    }
+}
+// -----------------------------------------------------------------------------
+// Search
+// -----------------------------------------------------------------------------
+// Icons for source display
+// Use shared icons for consistency with VS Code UI
+const ICONS = shared_1.STORE_ICONS;
+async function searchStore(options) {
+    const query = options.query?.toLowerCase() || '';
+    const limit = options.limit || 20;
+    const typeFilter = options.type;
+    const index = await fetchIndex();
+    // Load local registry to check installed status
+    const registry = new index_1.LocalRegistry();
+    const installedPacks = new Set((await registry.listPacks()).map(p => p.slug));
+    const installedSkills = await registry.listSkills();
+    const installedMcps = await registry.listMcp();
+    const installedEngines = await listInstalledEngineIds();
+    // Build installed map: slug -> { installedTo: string[] }
+    const installedSkillMap = new Map(installedSkills.map(s => [s.slug, s.installedTo || []]));
+    const installedMcpMap = new Map(installedMcps.map(m => [m.slug, m.installedTo || []]));
+    // Simple search: filter by query in name/description/tags
+    let results = index.artifacts.filter((a) => {
+        if (typeFilter && a.type !== typeFilter) {
+            return false;
+        }
+        if (!query) {
+            return true;
+        }
+        const searchText = [
+            a.slug,
+            a.displayName,
+            a.description,
+            ...(a.tags || []),
+        ].join(' ').toLowerCase();
+        return searchText.includes(query);
+    });
+    // Sort by relevance (exact match first, then by name)
+    results.sort((a, b) => {
+        const aExact = a.slug.toLowerCase() === query;
+        const bExact = b.slug.toLowerCase() === query;
+        if (aExact && !bExact) {
+            return -1;
+        }
+        if (!aExact && bExact) {
+            return 1;
+        }
+        return a.slug.localeCompare(b.slug);
+    });
+    results = results.slice(0, limit);
+    const enriched = results.map((a) => {
+        let isLocal = false;
+        let installedTo;
+        if (a.type === 'pack') {
+            isLocal = installedPacks.has(a.slug);
+        }
+        else if (a.type === 'skill') {
+            installedTo = installedSkillMap.get(a.slug);
+            isLocal = installedTo !== undefined && installedTo.length > 0;
+        }
+        else if (a.type === 'mcp') {
+            installedTo = installedMcpMap.get(a.slug);
+            isLocal = installedTo !== undefined && installedTo.length > 0;
+        }
+        else if (a.type === 'engine') {
+            isLocal = installedEngines.has(a.slug);
+        }
+        return { ...a, isLocal, installedTo };
+    });
+    if (options.json) {
+        console.log(JSON.stringify(enriched, null, 2));
+        return;
+    }
+    if (enriched.length === 0) {
+        console.log(`No results found for "${query}"`);
+        return;
+    }
+    console.log('');
+    console.log(`Found ${enriched.length} result(s):`);
+    console.log('');
+    for (const artifact of enriched) {
+        const version = artifact.latestVersion ? `v${artifact.latestVersion}` : '';
+        const sourceIcon = artifact.isLocal ? ICONS.local : ICONS.remote;
+        const installedLabel = artifact.isLocal ? ` ${ICONS.installed}` : '';
+        console.log(`  ${sourceIcon} ${artifact.type}/${artifact.slug}  ${version}${installedLabel}`);
+        if (artifact.description) {
+            const desc = artifact.description.length > 60
+                ? artifact.description.slice(0, 57) + '...'
+                : artifact.description;
+            console.log(`     ${desc}`);
+        }
+        // Show which packs this is installed to (for skills/MCPs)
+        if (artifact.installedTo && artifact.installedTo.length > 0) {
+            console.log(`     Installed to: ${artifact.installedTo.join(', ')}`);
+        }
+    }
+    console.log('');
+    console.log(`Legend: ${ICONS.local} Local  ${ICONS.remote} Remote  ${ICONS.installed} Installed`);
+    console.log('');
+    console.log('Install with:');
+    console.log('  agenthippo store install <type>/<slug>');
+    console.log('');
+}
+// -----------------------------------------------------------------------------
+// Install
+// -----------------------------------------------------------------------------
+async function installFromStore(options) {
+    if (!options.query) {
+        console.error('Error: Artifact reference required.');
+        console.log('Usage: agenthippo store install <type>/<slug>[@version]');
+        console.log('');
+        console.log('Examples:');
+        console.log('  agenthippo store install skill/pdf-tools');
+        console.log('  agenthippo store install pack/code-reviewer@1.0.0');
+        console.log('  agenthippo store install mcp/filesystem');
+        console.log('  agenthippo store install engine/gemini');
+        console.log('  agenthippo store install view/cost-ops@1.0.0');
+        process.exit(1);
+    }
+    const parsed = parseArtifactRef(options.query);
+    const { type, slug, version } = parsed;
+    const workspace = options.workspace || process.cwd();
+    console.log(`Installing ${type}/${slug}${version ? `@${version}` : ''}...`);
+    // Resolve version
+    let targetVersion = version || options.version;
+    if (!targetVersion) {
+        const versions = await listVersions(type, slug);
+        if (versions.length > 0) {
+            const stable = versions.find(v => !v.isPrerelease);
+            targetVersion = stable?.version || versions[0].version;
+            console.log(`  Using latest version: ${targetVersion}`);
+        }
+        else {
+            targetVersion = 'main';
+            console.log(`  No versions found, using main branch`);
+        }
+    }
+    if (type === 'view') {
+        console.log(`  Downloading...`);
+        const files = await downloadArtifact(type, slug, targetVersion);
+        if (files.length === 0) {
+            console.error(`Error: No files found for ${type}/${slug}`);
+            process.exit(1);
+        }
+        const { installSpotlightViewFromFiles } = await import('../../spotlight/install.js');
+        const result = await installSpotlightViewFromFiles(files.map(file => ({ path: file.path, content: file.content })), {
+            slug,
+            version: targetVersion,
+            overwrite: !!options.force,
+            workspaceRoot: workspace,
+            logger: cliLogger,
+        });
+        console.log('');
+        console.log(`✓ Installed view/${result.id} to:`);
+        console.log(`  ${result.installDir}`);
+        console.log(`  Panel config: ${result.viewsConfigPath}`);
+        console.log('');
+        return;
+    }
+    if (type === 'engine') {
+        console.log(`  Downloading...`);
+        const files = await downloadArtifact(type, slug, targetVersion);
+        if (files.length === 0) {
+            console.error(`Error: No files found for ${type}/${slug}`);
+            process.exit(1);
+        }
+        const result = await (0, install_1.installCustomEngineFromFiles)(files, {
+            slug,
+            version: targetVersion,
+            overwrite: !!options.force,
+            logger: cliLogger,
+        });
+        console.log('');
+        console.log(`✓ Installed engine/${result.id} to:`);
+        console.log(`  ${result.installDir}`);
+        console.log('');
+        return;
+    }
+    // Determine install path
+    const agentId = options.agent || 'default';
+    let installDir;
+    switch (type) {
+        case 'skill':
+            installDir = path.join(workspace, branding_1.AGENTIDE_DIR_NAME, 'agents', agentId, 'skills', slug);
+            break;
+        case 'pack':
+            installDir = path.join(os.homedir(), branding_1.AGENTIDE_DIR_NAME, 'agents', slug, targetVersion);
+            break;
+        case 'mcp':
+            installDir = path.join(workspace, branding_1.AGENTIDE_DIR_NAME, 'agents', agentId, 'mcp', slug);
+            break;
+    }
+    // Check if already exists
+    try {
+        await fs.access(installDir);
+        if (!options.force) {
+            console.error(`Error: ${type}/${slug} already exists at ${installDir}`);
+            console.log('Use --force to overwrite.');
+            process.exit(1);
+        }
+        console.log(`  Removing existing installation...`);
+        await fs.rm(installDir, { recursive: true, force: true });
+    }
+    catch {
+        // Doesn't exist, continue
+    }
+    // Download
+    console.log(`  Downloading...`);
+    const files = await downloadArtifact(type, slug, targetVersion);
+    if (files.length === 0) {
+        console.error(`Error: No files found for ${type}/${slug}`);
+        process.exit(1);
+    }
+    // Extract
+    console.log(`  Extracting ${files.length} files...`);
+    await fs.mkdir(installDir, { recursive: true });
+    for (const file of files) {
+        const filePath = path.join(installDir, file.path);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, file.content);
+    }
+    // For packs, create current.txt
+    if (type === 'pack') {
+        const packRoot = path.join(os.homedir(), branding_1.AGENTIDE_DIR_NAME, 'agents', slug);
+        await fs.writeFile(path.join(packRoot, 'current.txt'), targetVersion);
+    }
+    console.log('');
+    console.log(`✓ Installed ${type}/${slug} to:`);
+    console.log(`  ${installDir}`);
+    console.log('');
+}
+// -----------------------------------------------------------------------------
+// Publish
+// -----------------------------------------------------------------------------
+/** Resolve Spotlight view publish bundle mode from CLI flags. */
+function resolvePublishBundleMode(options) {
+    if (options.full && options.bundle && options.bundle.trim().toLowerCase() !== 'full') {
+        console.error('Error: Cannot combine --full with --bundle scripts-only');
+        process.exit(1);
+    }
+    if (options.full) {
+        return 'full';
+    }
+    if (options.bundle) {
+        const normalized = options.bundle.trim().toLowerCase();
+        if (normalized === 'full' || normalized === 'scripts-only') {
+            return normalized;
+        }
+        console.error('Error: Invalid --bundle value. Use scripts-only or full.');
+        process.exit(1);
+    }
+    return 'scripts-only';
+}
+async function publishToStoreFromCli(options) {
+    if (!options.query) {
+        console.error('Error: Artifact reference required.');
+        console.log('Usage: agenthippo store publish <engine|view>/<slug>[@version]');
+        console.log('');
+        console.log('Examples:');
+        console.log('  agenthippo store publish engine/rovo');
+        console.log('  agenthippo store publish engine/rovo@1.0.0');
+        console.log('  agenthippo store publish view/cost-ops@1.0.0');
+        console.log('  agenthippo store publish view/brand-board --bundle full');
+        console.log('  agenthippo store publish view/brand-board --full');
+        console.log('');
+        console.log('Requires GITHUB_TOKEN (or GH_TOKEN / AGENTHIPPO_GITHUB_TOKEN) with fork + PR access.');
+        console.log('Override store repo (CLI): AGENTHIPPO_STORE_REPO=owner/repo');
+        process.exit(1);
+    }
+    const parsed = parseArtifactRef(options.query);
+    const { type, slug, version: versionFromRef } = parsed;
+    if (type !== 'engine' && type !== 'view') {
+        console.error(`Error: store publish supports engine and view only, got ${type}/${slug}`);
+        console.log('Use: agenthippo store publish engine/<id>[@version]');
+        console.log('     agenthippo store publish view/<id>[@version] [--bundle full|scripts-only]');
+        process.exit(1);
+    }
+    const token = getGitHubToken();
+    if (!token) {
+        console.error('Error: GitHub token required to publish.');
+        console.log('Set GITHUB_TOKEN, GH_TOKEN, or AGENTHIPPO_GITHUB_TOKEN, then retry.');
+        process.exit(1);
+    }
+    if (type === 'engine') {
+        await publishEngineToStoreFromCli(options, slug, versionFromRef);
+        return;
+    }
+    await publishViewToStoreFromCli(options, slug, versionFromRef);
+}
+async function publishEngineToStoreFromCli(options, slug, versionFromRef) {
+    const workspace = options.workspace || process.cwd();
+    const engineDir = await (0, publish_1.resolveEngineSourceDir)(slug, workspace);
+    if (!engineDir) {
+        console.error(`Error: Engine "${slug}" not found under .agent-hippo/engines/ (workspace or home).`);
+        process.exit(1);
+    }
+    console.log(`Publishing engine/${slug} from ${engineDir}...`);
+    const validation = await (0, publish_1.validateEngineForPublish)(engineDir, slug);
+    if (!validation.valid) {
+        console.error(`Error: Cannot publish engine/${slug}`);
+        for (const error of validation.errors) {
+            console.error(`  - ${error}`);
+        }
+        process.exit(1);
+    }
+    for (const warning of validation.warnings) {
+        console.log(`  Warning: ${warning}`);
+    }
+    let version = versionFromRef || options.version || validation.metadata?.suggestedVersion;
+    if (!version) {
+        console.error('Error: Publish version required.');
+        console.log('Pass a version: agenthippo store publish engine/<slug>@1.0.0');
+        console.log('Or add a semver version field to package.json in the engine folder.');
+        process.exit(1);
+    }
+    version = version.replace(/^v/, '');
+    if (!(0, publish_1.isValidPublishVersion)(version)) {
+        console.error(`Error: Invalid version "${version}". Use semver (e.g., 1.0.0).`);
+        process.exit(1);
+    }
+    const files = await (0, publish_1.collectEngineFiles)(engineDir);
+    const config = getStoreConfig();
+    console.log(`  Target store: ${config.owner}/${config.repo}`);
+    console.log(`  Version tag: engines/${slug}/v${version}`);
+    console.log(`  Files: ${files.length}`);
+    await submitStorePublish({
+        options,
+        type: 'engine',
+        slug,
+        version,
+        files,
+        installHint: `agenthippo store install engine/${slug}`,
+    });
+}
+async function publishViewToStoreFromCli(options, slug, versionFromRef) {
+    const workspace = options.workspace || process.cwd();
+    const mode = resolvePublishBundleMode(options);
+    const views = await (0, publish_2.discoverPublishableViews)(workspace);
+    const summary = views.find(view => view.id === slug);
+    if (!summary) {
+        console.error(`Error: Spotlight view "${slug}" not found.`);
+        console.log('Register a user view in .agent-hippo/analytics/panel/views.yaml (non-system id).');
+        if (views.length > 0) {
+            console.log('');
+            console.log('Publishable views:');
+            for (const view of views) {
+                console.log(`  - view/${view.id} (${view.sourceLabel}, ${view.scope})`);
+            }
+        }
+        process.exit(1);
+    }
+    console.log(`Publishing view/${slug} from ${summary.viewRoot}...`);
+    console.log(`  Bundle: ${mode === 'full' ? 'full (scripts + assets + charts/reports/exports + manifest.json)' : 'scripts only'}`);
+    const validation = await (0, publish_2.validateViewForPublish)(summary, {
+        expectedId: slug,
+        mode,
+    });
+    if (!validation.valid) {
+        console.error(`Error: Cannot publish view/${slug}`);
+        for (const error of validation.errors) {
+            console.error(`  - ${error}`);
+        }
+        process.exit(1);
+    }
+    for (const warning of validation.warnings) {
+        console.log(`  Warning: ${warning}`);
+    }
+    if (!validation.metadata) {
+        console.error('Error: Validation succeeded but metadata is missing.');
+        process.exit(1);
+    }
+    let version = versionFromRef || options.version || validation.metadata.publishVersion;
+    if (!version) {
+        console.error('Error: Publish version required.');
+        console.log('Pass a version: agenthippo store publish view/<slug>@1.0.0');
+        console.log('Or add version to view.yaml (e.g. version: 1.0.0).');
+        process.exit(1);
+    }
+    version = version.replace(/^v/, '');
+    if (!(0, publish_1.isValidPublishVersion)(version)) {
+        console.error(`Error: Invalid version "${version}". Use semver (e.g., 1.0.0).`);
+        process.exit(1);
+    }
+    const files = await (0, publish_2.collectViewFiles)(summary, version, validation.metadata, mode);
+    const config = getStoreConfig();
+    const binaryCount = files.filter(file => file.encoding === 'base64').length;
+    console.log(`  Target store: ${config.owner}/${config.repo}`);
+    console.log(`  Version tag: spotlight/${slug}/v${version}`);
+    console.log(`  Files: ${files.length}${binaryCount > 0 ? ` (${binaryCount} binary)` : ''}`);
+    await submitStorePublish({
+        options,
+        type: 'view',
+        slug,
+        version,
+        files,
+        bundle: mode,
+        installHint: `agenthippo store install view/${slug}`,
+    });
+}
+async function submitStorePublish(params) {
+    const { options, type, slug, version, files, bundle, installHint } = params;
+    try {
+        const result = await (0, index_2.publishToStore)({
+            type,
+            slug,
+            version,
+            files,
+        }, cliLogger);
+        if (options.json) {
+            console.log(JSON.stringify({
+                success: true,
+                type,
+                slug,
+                version,
+                bundle,
+                prUrl: result.prUrl,
+                prNumber: result.prNumber,
+                tagName: result.tagName,
+            }, null, 2));
+        }
+        else {
+            console.log('');
+            const bundleLabel = bundle === 'full' ? ' (full bundle)' : '';
+            console.log(`✓ Opened pull request for ${type}/${slug} v${version}${bundleLabel}`);
+            console.log(`  ${result.prUrl}`);
+            console.log('');
+            console.log(`After merge, install with: ${installHint}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: message }));
+        }
+        else {
+            console.error(`Error: ${message}`);
+        }
+        process.exit(1);
+    }
+}
+// -----------------------------------------------------------------------------
+// Uninstall
+// -----------------------------------------------------------------------------
+async function uninstallFromStore(options) {
+    if (!options.query) {
+        console.error('Error: Artifact reference required.');
+        console.log('Usage: agenthippo store uninstall engine/<slug>');
+        console.log('');
+        console.log('Examples:');
+        console.log('  agenthippo store uninstall engine/gemini');
+        process.exit(1);
+    }
+    const { type, slug } = parseArtifactRef(options.query);
+    if (type !== 'engine') {
+        console.error(`Error: store uninstall currently supports custom engines only, got ${type}/${slug}`);
+        process.exit(1);
+    }
+    const result = await (0, install_1.uninstallCustomEngine)(slug, { logger: cliLogger });
+    if (!result.removed) {
+        console.error(`Error: engine/${result.id} is not installed.`);
+        process.exit(1);
+    }
+    console.log('');
+    console.log(`✓ Uninstalled engine/${result.id} from:`);
+    console.log(`  ${result.installDir}`);
+    console.log('');
+}
+// -----------------------------------------------------------------------------
+// Info
+// -----------------------------------------------------------------------------
+async function showStoreInfo(options) {
+    if (!options.query) {
+        console.error('Error: Artifact reference required.');
+        console.log('Usage: agenthippo store info <type>/<slug>');
+        process.exit(1);
+    }
+    const parsed = parseArtifactRef(options.query);
+    const index = await fetchIndex();
+    const artifact = index.artifacts.find((a) => a.type === parsed.type && a.slug === parsed.slug);
+    if (!artifact) {
+        console.error(`Error: ${parsed.type}/${parsed.slug} not found in store.`);
+        process.exit(1);
+    }
+    if (options.json) {
+        // Also fetch versions
+        const versions = await listVersions(parsed.type, parsed.slug);
+        console.log(JSON.stringify({ ...artifact, versions }, null, 2));
+        return;
+    }
+    console.log('');
+    // allow-any-unicode-next-line
+    console.log('─'.repeat(60));
+    console.log(`${artifact.type}/${artifact.slug}`);
+    // allow-any-unicode-next-line
+    console.log('─'.repeat(60));
+    console.log(`Name:        ${artifact.displayName}`);
+    console.log(`Type:        ${artifact.type}`);
+    console.log(`Version:     ${artifact.latestVersion || 'N/A'}`);
+    if (artifact.author) {
+        console.log(`Author:      ${artifact.author}`);
+    }
+    if (artifact.description) {
+        console.log(`Description: ${artifact.description}`);
+    }
+    if (artifact.tags?.length) {
+        console.log(`Tags:        ${artifact.tags.join(', ')}`);
+    }
+    // Fetch versions
+    const versions = await listVersions(parsed.type, parsed.slug);
+    if (versions.length > 0) {
+        console.log('');
+        console.log('Available versions:');
+        for (const v of versions.slice(0, 10)) {
+            const pre = v.isPrerelease ? ' (pre-release)' : '';
+            console.log(`  - ${v.version}${pre}`);
+        }
+        if (versions.length > 10) {
+            console.log(`  ... and ${versions.length - 10} more`);
+        }
+    }
+    // allow-any-unicode-next-line
+    console.log('─'.repeat(60));
+    console.log('');
+    console.log('Install with:');
+    console.log(`  agenthippo store install ${artifact.type}/${artifact.slug}`);
+    console.log('');
+}
+// -----------------------------------------------------------------------------
+// List
+// -----------------------------------------------------------------------------
+async function listStoreArtifacts(options) {
+    const index = await fetchIndex();
+    const typeFilter = options.type;
+    // Load local registry to check installed status
+    const registry = new index_1.LocalRegistry();
+    const installedPacks = new Set((await registry.listPacks()).map(p => p.slug));
+    const installedSkills = await registry.listSkills();
+    const installedMcps = await registry.listMcp();
+    const installedEngines = await listInstalledEngineIds();
+    // Build installed map: slug -> { installedTo: string[] }
+    const installedSkillMap = new Map(installedSkills.map(s => [s.slug, s.installedTo || []]));
+    const installedMcpMap = new Map(installedMcps.map(m => [m.slug, m.installedTo || []]));
+    let artifacts = index.artifacts;
+    if (typeFilter) {
+        artifacts = artifacts.filter((a) => a.type === typeFilter);
+    }
+    // Helper to check if an artifact is installed locally
+    const isLocalArtifact = (a) => {
+        if (a.type === 'pack') {
+            return installedPacks.has(a.slug);
+        }
+        if (a.type === 'skill') {
+            const installedTo = installedSkillMap.get(a.slug);
+            return installedTo !== undefined && installedTo.length > 0;
+        }
+        if (a.type === 'mcp') {
+            const installedTo = installedMcpMap.get(a.slug);
+            return installedTo !== undefined && installedTo.length > 0;
+        }
+        if (a.type === 'engine') {
+            return installedEngines.has(a.slug);
+        }
+        return false;
+    };
+    if (options.json) {
+        const enriched = artifacts.map((a) => ({
+            ...a,
+            isLocal: isLocalArtifact(a),
+            installedTo: a.type === 'skill' ? installedSkillMap.get(a.slug)
+                : a.type === 'mcp' ? installedMcpMap.get(a.slug)
+                    : undefined,
+        }));
+        console.log(JSON.stringify(enriched, null, 2));
+        return;
+    }
+    console.log('');
+    console.log(`Store contains ${artifacts.length} artifact(s):`);
+    console.log('');
+    // Group by type
+    const byType = {};
+    for (const a of artifacts) {
+        byType[a.type] = byType[a.type] || [];
+        byType[a.type].push(a);
+    }
+    for (const type of ['pack', 'skill', 'mcp', 'engine']) {
+        const items = byType[type] || [];
+        if (items.length === 0) {
+            continue;
+        }
+        console.log(`${type}s (${items.length}):`);
+        for (const item of items) {
+            const v = item.latestVersion ? ` v${item.latestVersion}` : '';
+            const isLocal = isLocalArtifact(item);
+            const sourceIcon = isLocal ? ICONS.local : ICONS.remote;
+            const installedLabel = isLocal ? ` ${ICONS.installed}` : '';
+            console.log(`  ${sourceIcon} ${item.slug}${v}${installedLabel}`);
+        }
+        console.log('');
+    }
+    console.log(`Legend: ${ICONS.local} Local  ${ICONS.remote} Remote  ${ICONS.installed} Installed`);
+    console.log('');
+}
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+function parseArtifactRef(ref) {
+    try {
+        return (0, shared_1.parseStoreUrl)(ref);
+    }
+    catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        console.error(`Error: ${errorMsg}`);
+        console.log('Expected format: <type>/<slug>[@version]');
+        console.log('Examples: skill/pdf-tools, pack/code-reviewer@1.0.0, engine/gemini, view/cost-ops');
+        process.exit(1);
+    }
+}
+async function listInstalledEngineIds() {
+    return new Set((await (0, install_1.listInstalledCustomEngines)()).map(engine => engine.id));
+}
+async function fetchIndex() {
+    // Try GitHub Pages first (public, fast CDN)
+    const pagesUrl = getIndexUrl();
+    cliLogger.appendLine(`[Store] Fetching index from ${pagesUrl}`);
+    let response = await fetch(pagesUrl, {
+        headers: {
+            'User-Agent': 'AgentHippo-CLI',
+            Accept: 'application/json',
+        },
+    });
+    if (response.ok) {
+        return await response.json();
+    }
+    // Fallback: Try GitHub API (for private repos with token)
+    const token = getGitHubToken();
+    if (token && (response.status === 403 || response.status === 404)) {
+        cliLogger.appendLine(`[Store] GitHub Pages not available, trying API with auth...`);
+        const config = getStoreConfig();
+        const apiUrl = `https://api.github.com/repos/${config.owner}/${config.repo}/contents/dist/store-index.json`;
+        response = await githubFetch(apiUrl, {
+            headers: { Accept: 'application/vnd.github.raw+json' },
+        });
+        if (response.ok) {
+            return await response.json();
+        }
+    }
+    throw new Error(`Failed to fetch store index: ${response.status} ${response.statusText}`);
+}
+async function listVersions(type, slug) {
+    const config = getStoreConfig();
+    const typePath = (0, shared_1.getStorePath)(type);
+    const prefix = `${typePath}/${slug}/v`;
+    const url = `https://api.github.com/repos/${config.owner}/${config.repo}/git/refs/tags`;
+    cliLogger.appendLine(`[Store] Listing versions for ${type}/${slug}`);
+    const response = await githubFetch(url);
+    if (!response.ok) {
+        if (response.status === 404) {
+            return [];
+        }
+        throw new Error(`Failed to list versions: ${response.statusText}`);
+    }
+    const refs = (await response.json());
+    const versions = [];
+    for (const { ref } of refs) {
+        const tagName = ref.replace('refs/tags/', '');
+        if (tagName.startsWith(prefix)) {
+            const version = tagName.slice(prefix.length - 1); // Keep the 'v'
+            versions.push({
+                version: version.replace(/^v/, ''),
+                tagName,
+                isPrerelease: /-(alpha|beta|rc|pre)/.test(version),
+            });
+        }
+    }
+    return versions.sort((a, b) => b.version.localeCompare(a.version, undefined, { numeric: true }));
+}
+async function downloadArtifact(type, slug, version) {
+    const config = getStoreConfig();
+    const typePath = (0, shared_1.getStorePath)(type);
+    // Determine ref
+    let targetRef;
+    if (version === 'main' || version === 'latest') {
+        targetRef = config.defaultBranch;
+    }
+    else {
+        targetRef = `${typePath}/${slug}/v${version.replace(/^v/, '')}`;
+    }
+    cliLogger.appendLine(`[Store] Downloading ${type}/${slug} at ${targetRef}`);
+    // Download tarball
+    const encodedRef = encodeURIComponent(targetRef);
+    const url = `https://api.github.com/repos/${config.owner}/${config.repo}/tarball/${encodedRef}`;
+    const response = await githubFetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download: ${response.status} ${response.statusText}`);
+    }
+    // Decompress and parse tar
+    const gzipped = Buffer.from(await response.arrayBuffer());
+    const tarData = (0, zlib_1.gunzipSync)(gzipped);
+    const allFiles = parseTar(tarData);
+    // Filter to files in our artifact's folder
+    const artifactPath = `${typePath}/${slug}/`;
+    const result = [];
+    for (const [fullPath, content] of allFiles) {
+        // Strip top-level directory (e.g., "repo-commit/")
+        const slashIndex = fullPath.indexOf('/');
+        if (slashIndex === -1) {
+            continue;
+        }
+        const relativePath = fullPath.slice(slashIndex + 1);
+        if (relativePath.startsWith(artifactPath)) {
+            const artifactRelativePath = relativePath.slice(artifactPath.length);
+            if (artifactRelativePath) {
+                result.push({ path: artifactRelativePath, content });
+            }
+        }
+    }
+    return result;
+}
+function parseTar(data) {
+    const files = new Map();
+    let offset = 0;
+    while (offset < data.length - 512) {
+        const header = data.subarray(offset, offset + 512);
+        if (header.every(b => b === 0)) {
+            break;
+        }
+        const name = header.subarray(0, 100).toString('utf-8').replace(/\0/g, '').trim();
+        const sizeOctal = header.subarray(124, 136).toString('utf-8').replace(/\0/g, '').trim();
+        const typeFlag = header[156];
+        if (!name) {
+            offset += 512;
+            continue;
+        }
+        const size = parseInt(sizeOctal, 8) || 0;
+        offset += 512;
+        if (typeFlag === 0 || typeFlag === 48) {
+            files.set(name, Buffer.from(data.subarray(offset, offset + size)));
+        }
+        offset += Math.ceil(size / 512) * 512;
+    }
+    return files;
+}