@agenthippo-ai/agenthippo 0.1.0

package/out/agentpack/install.js

@@ -0,0 +1,297 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------------------------
+ *  Installing agent packs from GitHub.
+ *  Flow: Parse source → Download tarball → Extract to workspace
+ *
+ *  Optimization: Try unauthenticated first, prompt for auth only if needed.
+ *--------------------------------------------------------------------------------------------*/
+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.downloadTarball = downloadTarball;
+exports.installFromGitHub = installFromGitHub;
+exports.checkGitHubUpdate = checkGitHubUpdate;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const zlib_1 = require("zlib");
+const utils_1 = require("../utils");
+const paths_1 = require("./paths");
+const manifest_1 = require("./manifest");
+const github_1 = require("./github");
+// -----------------------------------------------------------------------------
+// Tarball Download (Unauthenticated First)
+// -----------------------------------------------------------------------------
+/**
+ * Download and extract a GitHub tarball.
+ * Tries unauthenticated first, prompts for auth only if needed.
+ */
+async function downloadTarball(owner, repo, ref, outputChannel) {
+    const url = `https://github.com/${owner}/${repo}/archive/refs/tags/${ref}.tar.gz`;
+    // Try unauthenticated first
+    let response = await fetch(url, {
+        headers: { 'User-Agent': 'AgentIDE' },
+        redirect: 'follow',
+    });
+    // If failed, try with auth
+    if (!response.ok) {
+        if (response.status === 401 || response.status === 403 || response.status === 404 || response.status === 429) {
+            if (outputChannel) {
+                (0, utils_1.logInfo)(outputChannel, `[Install] Requires authentication, signing in...`);
+            }
+            const token = await (0, github_1.getGitHubToken)();
+            response = await fetch(url, {
+                headers: {
+                    'User-Agent': 'AgentIDE',
+                    Authorization: `Bearer ${token}`,
+                },
+                redirect: 'follow',
+            });
+        }
+        if (!response.ok) {
+            throw new Error(`Failed to download: ${response.status} ${response.statusText}`);
+        }
+    }
+    // Download and decompress
+    const gzipped = Buffer.from(await response.arrayBuffer());
+    const tarData = (0, zlib_1.gunzipSync)(gzipped);
+    // Parse tar (simple implementation for .tar format)
+    return parseTar(tarData);
+}
+/**
+ * Parse a tar archive into a map of path → content.
+ * Simple implementation supporting POSIX ustar format.
+ */
+function parseTar(data) {
+    const files = new Map();
+    let offset = 0;
+    while (offset < data.length - 512) {
+        // Read header (512 bytes)
+        const header = data.subarray(offset, offset + 512);
+        // Check for empty block (end of archive)
+        if (header.every(b => b === 0)) {
+            break;
+        }
+        // Parse header fields
+        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];
+        // Skip if no name
+        if (!name) {
+            offset += 512;
+            continue;
+        }
+        const size = parseInt(sizeOctal, 8) || 0;
+        offset += 512;
+        // Type 0 or '0' = regular file, type 5 = directory
+        if (typeFlag === 0 || typeFlag === 48) {
+            // Regular file
+            const content = data.subarray(offset, offset + size);
+            files.set(name, Buffer.from(content));
+        }
+        // Move to next block (512-byte aligned)
+        offset += Math.ceil(size / 512) * 512;
+    }
+    return files;
+}
+/**
+ * Strip the top-level directory from tar paths.
+ * GitHub tarballs contain repo-tag/ prefix.
+ */
+function stripTarPrefix(files) {
+    const result = new Map();
+    for (const [fullPath, content] of files) {
+        // Remove first path component (e.g., "repo-v1.0.0/")
+        const slashIndex = fullPath.indexOf('/');
+        if (slashIndex !== -1) {
+            const relativePath = fullPath.slice(slashIndex + 1);
+            if (relativePath) {
+                result.set(relativePath, content);
+            }
+        }
+    }
+    return result;
+}
+// -----------------------------------------------------------------------------
+// Installation
+// -----------------------------------------------------------------------------
+/**
+ * Install an agent pack from GitHub.
+ *
+ * Flow:
+ * 1. Parse the source URL
+ * 2. Resolve version (latest if not specified)
+ * 3. Download tarball (unauthenticated first)
+ * 4. Extract to workspace
+ */
+async function installFromGitHub(workspaceRoot, options, outputChannel) {
+    const { source, force = false } = options;
+    (0, utils_1.logInfo)(outputChannel, `[Install] Installing from ${source}...`);
+    // 1. Parse source
+    const parsed = (0, github_1.parseGitHubSource)(source);
+    (0, utils_1.logInfo)(outputChannel, `[Install] Repository: ${parsed.owner}/${parsed.repo}`);
+    // 2. Resolve version
+    let version;
+    if (parsed.version) {
+        version = parsed.version;
+    }
+    else {
+        (0, utils_1.logInfo)(outputChannel, `[Install] Resolving latest version...`);
+        const latestTag = await getLatestTag(parsed.owner, parsed.repo, outputChannel);
+        if (!latestTag) {
+            throw new Error(`No releases found for ${parsed.owner}/${parsed.repo}. ` +
+                `The repository may not have any published versions.`);
+        }
+        version = latestTag;
+        (0, utils_1.logInfo)(outputChannel, `[Install] Latest version: ${version}`);
+    }
+    // 3. Check if already installed
+    const agentId = parsed.repo;
+    const targetDir = (0, paths_1.getAgentRoot)(workspaceRoot, agentId);
+    if (await (0, utils_1.pathExists)(targetDir)) {
+        if (!force) {
+            throw new Error(`Agent "${agentId}" already exists. Use force option to overwrite.`);
+        }
+        (0, utils_1.logInfo)(outputChannel, `[Install] Removing existing installation...`);
+        await fs_1.promises.rm(targetDir, { recursive: true, force: true });
+    }
+    // 4. Download tarball
+    (0, utils_1.logInfo)(outputChannel, `[Install] Downloading ${version}...`);
+    const rawFiles = await downloadTarball(parsed.owner, parsed.repo, version, outputChannel);
+    const files = stripTarPrefix(rawFiles);
+    (0, utils_1.logInfo)(outputChannel, `[Install] Found ${files.size} files`);
+    // Verify it has agent.yaml
+    if (!files.has(paths_1.AGENT_CONSTANTS.MANIFEST_FILE)) {
+        throw new Error(`Invalid agent pack: missing ${paths_1.AGENT_CONSTANTS.MANIFEST_FILE}. ` +
+            `Ensure the repository contains a valid agent pack.`);
+    }
+    // 5. Write files to workspace
+    await fs_1.promises.mkdir(targetDir, { recursive: true });
+    let downloadedBytes = 0;
+    for (const [filePath, content] of files) {
+        (0, utils_1.logInfo)(outputChannel, `[Install]   ↓ ${filePath}`);
+        const fullPath = path.join(targetDir, filePath);
+        await fs_1.promises.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs_1.promises.writeFile(fullPath, content);
+        downloadedBytes += content.length;
+    }
+    (0, utils_1.logInfo)(outputChannel, `[Install] OK Installed ${agentId} ${version}`);
+    (0, utils_1.logInfo)(outputChannel, `[Install]    Location: ${targetDir}`);
+    (0, utils_1.logInfo)(outputChannel, `[Install]    Downloaded: ${formatBytes(downloadedBytes)}`);
+    return {
+        agentId,
+        version,
+        source: `github://${parsed.owner}/${parsed.repo}@${version}`,
+        installed: true,
+    };
+}
+/**
+ * Get the latest tag from a repository.
+ * Tries unauthenticated first.
+ */
+async function getLatestTag(owner, repo, outputChannel) {
+    const url = `https://api.github.com/repos/${owner}/${repo}/releases/latest`;
+    // Try unauthenticated first
+    let response = await fetch(url, {
+        headers: {
+            'User-Agent': 'AgentIDE',
+            Accept: 'application/vnd.github.v3+json',
+        },
+    });
+    // If failed, try with auth
+    if (!response.ok && (response.status === 401 || response.status === 403 || response.status === 429)) {
+        if (outputChannel) {
+            (0, utils_1.logInfo)(outputChannel, `[Install] Requires authentication...`);
+        }
+        const token = await (0, github_1.getGitHubToken)();
+        response = await fetch(url, {
+            headers: {
+                'User-Agent': 'AgentIDE',
+                Accept: 'application/vnd.github.v3+json',
+                Authorization: `Bearer ${token}`,
+            },
+        });
+    }
+    if (!response.ok) {
+        return null;
+    }
+    const data = (await response.json());
+    return data.tag_name;
+}
+/**
+ * Check if an update is available from GitHub.
+ */
+async function checkGitHubUpdate(workspaceRoot, agentId, source, outputChannel) {
+    try {
+        // Load current manifest
+        const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, agentId);
+        if (!(await (0, utils_1.pathExists)(manifestPath))) {
+            return { hasUpdate: false };
+        }
+        const manifest = await (0, manifest_1.loadAgentManifest)(manifestPath);
+        const currentVersion = manifest.metadata.version;
+        // Parse source and get latest
+        const parsed = (0, github_1.parseGitHubSource)(source);
+        const latestVersion = await getLatestTag(parsed.owner, parsed.repo, outputChannel);
+        if (!latestVersion) {
+            return { hasUpdate: false, currentVersion };
+        }
+        // Compare versions (strip 'v' prefix for comparison)
+        const latestClean = latestVersion.replace(/^v/, '');
+        const hasUpdate = latestClean !== currentVersion;
+        return {
+            hasUpdate,
+            currentVersion,
+            latestVersion: latestClean,
+        };
+    }
+    catch (e) {
+        (0, utils_1.logInfo)(outputChannel, `[Install] Update check failed: ${e}`);
+        return { hasUpdate: false };
+    }
+}
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+function formatBytes(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    }
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}