@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/store/index.js

@@ -1,786 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------------------------
- *  Store - Publish and install from a configurable GitHub repo.
- *
- *  Design:
- *  - Default repo: github.com/agenthippoai/agenthippo-store (configurable via setting)
- *  - Structure: agent-packs/, skills/, mcp/, engines/
- *  - Versioning: Path-prefixed tags (e.g., agent-packs/code-review/v1.0.0)
- *  - Publishing: Fork → Branch → PR workflow
- *  - Auth: Only required for publishing (PR submission)
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatStoreUrl = exports.parseStoreUrl = exports.STORE_CONFIG = exports.getRegistry = exports.formatStorePullRequestError = exports.isForkOfStoreRepo = exports.getTagsApiUrl = exports.getStoreIndexUrl = exports.getStorePath = exports.DEFAULT_STORE_BRANCH = exports.DEFAULT_STORE_REPO = exports.DEFAULT_STORE_OWNER = exports.STORE_PATHS = exports.STORE_ICONS = void 0;
-exports.listStoreVersions = listStoreVersions;
-exports.getLatestStoreVersion = getLatestStoreVersion;
-exports.downloadFromStore = downloadFromStore;
-exports.downloadFromExternalGitHub = downloadFromExternalGitHub;
-exports.canPublishDirectlyToStore = canPublishDirectlyToStore;
-exports.publishToStore = publishToStore;
-exports.parseGitHubUrl = parseGitHubUrl;
-exports.detectArtifactType = detectArtifactType;
-exports.isStoreUrl = isStoreUrl;
-exports.listStoreIndex = listStoreIndex;
-const utils_1 = require("../utils");
-const branding_1 = require("../branding");
-const github_1 = require("../agentpack/github");
-// Import shared types and utilities for local use
-const shared_1 = require("./shared");
-// Re-export shared types and utilities for consumers of this module
-// Note: parseStoreUrl, parseGitHubUrl, isStoreUrl, formatStoreUrl are defined locally as wrappers
-var shared_2 = require("./shared");
-Object.defineProperty(exports, "STORE_ICONS", { enumerable: true, get: function () { return shared_2.STORE_ICONS; } });
-Object.defineProperty(exports, "STORE_PATHS", { enumerable: true, get: function () { return shared_2.STORE_PATHS; } });
-Object.defineProperty(exports, "DEFAULT_STORE_OWNER", { enumerable: true, get: function () { return shared_2.DEFAULT_STORE_OWNER; } });
-Object.defineProperty(exports, "DEFAULT_STORE_REPO", { enumerable: true, get: function () { return shared_2.DEFAULT_STORE_REPO; } });
-Object.defineProperty(exports, "DEFAULT_STORE_BRANCH", { enumerable: true, get: function () { return shared_2.DEFAULT_STORE_BRANCH; } });
-Object.defineProperty(exports, "getStorePath", { enumerable: true, get: function () { return shared_2.getStorePath; } });
-Object.defineProperty(exports, "getStoreIndexUrl", { enumerable: true, get: function () { return shared_2.getStoreIndexUrl; } });
-Object.defineProperty(exports, "getTagsApiUrl", { enumerable: true, get: function () { return shared_2.getTagsApiUrl; } });
-Object.defineProperty(exports, "isForkOfStoreRepo", { enumerable: true, get: function () { return shared_2.isForkOfStoreRepo; } });
-Object.defineProperty(exports, "formatStorePullRequestError", { enumerable: true, get: function () { return shared_2.formatStorePullRequestError; } });
-// Re-export registry for convenience
-var index_1 = require("../registry/index");
-Object.defineProperty(exports, "getRegistry", { enumerable: true, get: function () { return index_1.getRegistry; } });
-// -----------------------------------------------------------------------------
-// Configuration (VS Code-specific: reads from settings)
-// -----------------------------------------------------------------------------
-/**
- * Get the configured store repo. Reads from VS Code settings if available.
- */
-function getStoreRepo() {
-    const repoEnv = process.env.AGENTHIPPO_STORE_REPO?.trim();
-    if (repoEnv) {
-        const match = repoEnv.match(/^(?:https?:\/\/github\.com\/)?([^/]+)\/([^/]+?)(?:\.git)?$/);
-        if (match) {
-            return { owner: match[1], repo: match[2] };
-        }
-        const parts = repoEnv.split('/').filter(Boolean);
-        if (parts.length === 2) {
-            return { owner: parts[0], repo: parts[1] };
-        }
-    }
-    try {
-        // Try to read from VS Code settings (lazy load to avoid bundling issues)
-        // eslint-disable-next-line no-eval
-        const vscode = eval('require')('vscode');
-        const config = vscode.workspace.getConfiguration('agentide');
-        const storeUrl = config.get('storeRepo');
-        if (storeUrl) {
-            // Parse owner/repo format
-            const match = storeUrl.match(/^(?:https?:\/\/github\.com\/)?([^/]+)\/([^/]+?)(?:\.git)?$/);
-            if (match) {
-                return { owner: match[1], repo: match[2] };
-            }
-        }
-    }
-    catch {
-        // Not in VS Code context, use default
-    }
-    return { owner: shared_1.DEFAULT_STORE_OWNER, repo: shared_1.DEFAULT_STORE_REPO };
-}
-exports.STORE_CONFIG = {
-    get owner() { return getStoreRepo().owner; },
-    get repo() { return getStoreRepo().repo; },
-    defaultBranch: shared_1.DEFAULT_STORE_BRANCH,
-    paths: shared_1.STORE_PATHS,
-};
-// StoreVersion is re-exported from shared.ts
-// -----------------------------------------------------------------------------
-// Version Management
-// -----------------------------------------------------------------------------
-/**
- * List available versions for an artifact in the store.
- * Tries unauthenticated first, prompts for auth only if needed.
- */
-async function listStoreVersions(type, slug) {
-    const prefix = `${(0, shared_1.getStorePath)(type)}/${slug}/v`;
-    const url = `https://api.github.com/repos/${exports.STORE_CONFIG.owner}/${exports.STORE_CONFIG.repo}/git/refs/tags`;
-    // Try unauthenticated first
-    let response = await fetch(url, {
-        headers: {
-            Accept: 'application/vnd.github.v3+json',
-            'User-Agent': 'AgentIDE',
-        },
-    });
-    // If failed, try with auth
-    if (!response.ok && (response.status === 401 || response.status === 403 || response.status === 429)) {
-        const token = await (0, github_1.getGitHubToken)();
-        response = await fetch(url, {
-            headers: {
-                Authorization: `Bearer ${token}`,
-                Accept: 'application/vnd.github.v3+json',
-                'User-Agent': 'AgentIDE',
-            },
-        });
-    }
-    if (!response.ok) {
-        if (response.status === 404) {
-            return []; // No tags yet
-        }
-        throw new Error(`Failed to list tags: ${response.statusText}`);
-    }
-    const refs = (await response.json());
-    // Filter and parse versions
-    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),
-            });
-        }
-    }
-    // Sort by version (newest first)
-    return versions.sort((a, b) => {
-        // Simple semver comparison (could use semver library for proper comparison)
-        return b.version.localeCompare(a.version, undefined, { numeric: true });
-    });
-}
-/**
- * Get the latest version for an artifact.
- */
-async function getLatestStoreVersion(type, slug, includePrerelease = false) {
-    const versions = await listStoreVersions(type, slug);
-    if (includePrerelease) {
-        return versions[0] || null;
-    }
-    return versions.find(v => !v.isPrerelease) || null;
-}
-// -----------------------------------------------------------------------------
-// Install from Store (Tarball, Unauthenticated First)
-// -----------------------------------------------------------------------------
-const zlib_1 = require("zlib");
-/**
- * Parse a tar archive into a map of path → content.
- *
- * Long paths are the whole difficulty here. The ustar `name` field is 100 bytes, and anything
- * longer is carried one of two other ways:
- *
- *   - ustar `prefix` (offset 345, 155 bytes): the real path is `prefix + "/" + name`.
- *   - PAX extended header (typeflag 'x') or GNU LongName ('L'): a pseudo-entry whose BODY holds
- *     the path for the entry that follows.
- *
- * Reading only the `name` field silently DROPPED every such file — a store install of a pack with
- * deep skill directories quietly produced an incomplete pack, which is worse than failing, because
- * nothing anywhere reported a problem. Found when a signed pack verified cryptographically but its
- * digest did not match: the download was missing two files the signature covered.
- */
-function parseTar(data) {
-    const files = new Map();
-    let offset = 0;
-    /** Set by a PAX/GNU pseudo-entry, consumed by the next real entry. */
-    let pendingLongName;
-    const str = (buf) => buf.toString('utf-8').replace(/\0/g, '').trim();
-    while (offset < data.length - 512) {
-        const header = data.subarray(offset, offset + 512);
-        if (header.every(b => b === 0)) {
-            break;
-        }
-        const name = str(header.subarray(0, 100));
-        const prefix = str(header.subarray(345, 500));
-        const sizeOctal = str(header.subarray(124, 136));
-        const typeFlag = header[156];
-        const size = parseInt(sizeOctal, 8) || 0;
-        const body = data.subarray(offset + 512, offset + 512 + size);
-        const advance = 512 + Math.ceil(size / 512) * 512;
-        // 'x' (120) PAX extended header, 'L' (76) GNU LongName: the path for the NEXT entry.
-        if (typeFlag === 120 || typeFlag === 103) {
-            // PAX records are "<len> <key>=<value>\n"; we only care about path.
-            const match = body.toString('utf-8').match(/\d+ path=([^\n]+)\n/);
-            if (match) {
-                pendingLongName = match[1];
-            }
-            offset += advance;
-            continue;
-        }
-        if (typeFlag === 76) {
-            pendingLongName = str(body);
-            offset += advance;
-            continue;
-        }
-        const fullName = pendingLongName ?? (prefix ? `${prefix}/${name}` : name);
-        pendingLongName = undefined;
-        if (fullName && (typeFlag === 0 || typeFlag === 48)) {
-            files.set(fullName, Buffer.from(body));
-        }
-        offset += advance;
-    }
-    return files;
-}
-/**
- * Download files for an artifact from the store.
- * Uses tarball download, tries unauthenticated first.
- */
-async function downloadFromStore(options, outputChannel) {
-    const { type, slug, version, includePrerelease } = options;
-    const typePath = (0, shared_1.getStorePath)(type);
-    // Resolve version
-    let targetRef;
-    if (version === 'main' || version === 'latest') {
-        // Explicit main branch request
-        targetRef = exports.STORE_CONFIG.defaultBranch;
-        if (outputChannel) {
-            (0, utils_1.logInfo)(outputChannel, `[Store] Using ${targetRef} branch (latest)`);
-        }
-    }
-    else if (version) {
-        targetRef = `${typePath}/${slug}/v${version.replace(/^v/, '')}`;
-    }
-    else {
-        const latest = await getLatestStoreVersion(type, slug, includePrerelease);
-        if (latest) {
-            targetRef = latest.tagName;
-            if (outputChannel) {
-                (0, utils_1.logInfo)(outputChannel, `[Store] Using latest version: ${latest.version}`);
-            }
-        }
-        else {
-            // No tags found - try to download from main branch
-            targetRef = exports.STORE_CONFIG.defaultBranch;
-            if (outputChannel) {
-                (0, utils_1.logInfo)(outputChannel, `[Store] No version tags found, using ${targetRef} branch`);
-            }
-        }
-    }
-    if (outputChannel) {
-        (0, utils_1.logInfo)(outputChannel, `[Store] Downloading ${type}/${slug} at ${targetRef}`);
-    }
-    // Download tarball (unauthenticated first)
-    const encodedRef = encodeURIComponent(targetRef);
-    const url = `https://api.github.com/repos/${exports.STORE_CONFIG.owner}/${exports.STORE_CONFIG.repo}/tarball/${encodedRef}`;
-    let response = await fetch(url, {
-        headers: {
-            'User-Agent': 'AgentIDE',
-            Accept: 'application/vnd.github.v3+json',
-        },
-        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, `[Store] Requires authentication, signing in...`);
-            }
-            const token = await (0, github_1.getGitHubToken)();
-            response = await fetch(url, {
-                headers: {
-                    'User-Agent': 'AgentIDE',
-                    Accept: 'application/vnd.github.v3+json',
-                    Authorization: `Bearer ${token}`,
-                },
-                redirect: 'follow',
-            });
-        }
-        if (!response.ok) {
-            throw new Error(`Version ${version || 'latest'} not found for ${type} "${slug}"`);
-        }
-    }
-    // Download and decompress
-    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 });
-                if (outputChannel) {
-                    (0, utils_1.logInfo)(outputChannel, `[Store]   ↓ ${artifactRelativePath}`);
-                }
-            }
-        }
-    }
-    return result;
-}
-/**
- * Download files from any GitHub repository.
- * Used for installing from external sources like anthropics/skills.
- */
-async function downloadFromExternalGitHub(options, outputChannel) {
-    const { owner, repo, ref = 'main', path } = options;
-    if (outputChannel) {
-        (0, utils_1.logInfo)(outputChannel, `[GitHub] Downloading ${owner}/${repo}${path ? `/${path}` : ''} at ${ref}`);
-    }
-    // Download tarball
-    const encodedRef = encodeURIComponent(ref);
-    const url = `https://api.github.com/repos/${owner}/${repo}/tarball/${encodedRef}`;
-    let response = await fetch(url, {
-        headers: {
-            'User-Agent': 'AgentIDE',
-            Accept: 'application/vnd.github.v3+json',
-        },
-        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, `[GitHub] Requires authentication, signing in...`);
-            }
-            const token = await (0, github_1.getGitHubToken)();
-            response = await fetch(url, {
-                headers: {
-                    'User-Agent': 'AgentIDE',
-                    Accept: 'application/vnd.github.v3+json',
-                    Authorization: `Bearer ${token}`,
-                },
-                redirect: 'follow',
-            });
-        }
-        if (!response.ok) {
-            throw new Error(`Failed to download from ${owner}/${repo}@${ref}: ${response.statusText}`);
-        }
-    }
-    const buffer = Buffer.from(await response.arrayBuffer());
-    const decompressed = (0, zlib_1.gunzipSync)(buffer);
-    const tarFiles = parseTar(decompressed);
-    // Find root directory in tarball (GitHub adds prefix like "repo-sha/")
-    let rootPrefix = '';
-    for (const name of tarFiles.keys()) {
-        if (name.includes('/')) {
-            rootPrefix = name.split('/')[0] + '/';
-            break;
-        }
-    }
-    // If path specified, filter to only files in that path
-    const pathPrefix = path ? `${rootPrefix}${path}/` : rootPrefix;
-    const result = [];
-    for (const [name, content] of tarFiles) {
-        if (name.startsWith(pathPrefix)) {
-            const relativePath = name.slice(pathPrefix.length);
-            if (relativePath && !relativePath.endsWith('/')) {
-                result.push({
-                    path: relativePath,
-                    content: content.toString('utf-8'),
-                });
-            }
-        }
-    }
-    if (result.length === 0) {
-        throw new Error(`No files found in ${owner}/${repo}${path ? `/${path}` : ''} at ${ref}`);
-    }
-    if (outputChannel) {
-        (0, utils_1.logInfo)(outputChannel, `[GitHub] Downloaded ${result.length} files`);
-    }
-    return result;
-}
-async function getRepoForkMetadata(owner, repo) {
-    const token = await (0, github_1.getGitHubToken)();
-    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
-        headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: 'application/vnd.github.v3+json',
-            'User-Agent': 'AgentIDE',
-        },
-    });
-    if (response.status === 404) {
-        return null;
-    }
-    if (!response.ok) {
-        throw new Error(`Failed to inspect repo ${owner}/${repo}: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-        fork: data.fork === true,
-        parentFullName: data.parent?.full_name,
-    };
-}
-function assertStoreFork(owner, repo, metadata) {
-    if ((0, shared_1.isForkOfStoreRepo)(metadata, exports.STORE_CONFIG.owner, exports.STORE_CONFIG.repo)) {
-        return;
-    }
-    throw new Error(`Your GitHub repo ${owner}/${repo} is not a fork of ${exports.STORE_CONFIG.owner}/${exports.STORE_CONFIG.repo}.\n\n` +
-        `Publishing requires a fork of the store repository. Either delete or rename ${owner}/${repo} ` +
-        `and retry (AgentIDE will create a proper fork), or fork ${exports.STORE_CONFIG.owner}/${exports.STORE_CONFIG.repo} on GitHub.`);
-}
-/**
- * Sync the fork's default branch with upstream when possible.
- */
-async function syncForkWithUpstream(forkOwner, forkRepo) {
-    const token = await (0, github_1.getGitHubToken)();
-    const response = await fetch(`https://api.github.com/repos/${forkOwner}/${forkRepo}/merge-upstream`, {
-        method: 'POST',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: 'application/vnd.github.v3+json',
-            'User-Agent': 'AgentIDE',
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ branch: exports.STORE_CONFIG.defaultBranch }),
-    });
-    // Best-effort: publish branches from upstream SHA even if sync fails.
-    if (response.ok || response.status === 409) {
-        return;
-    }
-    // Log but don't throw — the publish branch will be based on upstream SHA directly.
-    const errorBody = await response.text().catch(() => '');
-    console.warn(`[Store] Warning: fork sync returned ${response.status}: ${errorBody.slice(0, 200)}`);
-}
-/**
- * Fork the central store repo if not already forked.
- */
-async function ensureFork() {
-    const token = await (0, github_1.getGitHubToken)();
-    const user = await (0, github_1.getGitHubUser)();
-    // Check if fork already exists
-    const existingFork = await (0, github_1.getRepo)(user.login, exports.STORE_CONFIG.repo);
-    if (existingFork) {
-        const metadata = await getRepoForkMetadata(user.login, exports.STORE_CONFIG.repo);
-        if (!metadata) {
-            throw new Error(`Fork repo not found: ${user.login}/${exports.STORE_CONFIG.repo}`);
-        }
-        assertStoreFork(user.login, exports.STORE_CONFIG.repo, metadata);
-        return existingFork;
-    }
-    // Check if source repo exists
-    const sourceRepo = await (0, github_1.getRepo)(exports.STORE_CONFIG.owner, exports.STORE_CONFIG.repo);
-    if (!sourceRepo) {
-        throw new Error(`Store repo not found: ${exports.STORE_CONFIG.owner}/${exports.STORE_CONFIG.repo}\n\n` +
-            `If using a custom store, ensure the repo exists and is accessible.\n` +
-            `Setting: ${(0, branding_1.toSettingsDisplayKey)('agentide.storeRepo')}`);
-    }
-    // Create fork
-    const response = await fetch(`https://api.github.com/repos/${exports.STORE_CONFIG.owner}/${exports.STORE_CONFIG.repo}/forks`, {
-        method: 'POST',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: 'application/vnd.github.v3+json',
-            'User-Agent': 'AgentIDE',
-        },
-    });
-    if (!response.ok) {
-        const errorBody = await response.text().catch(() => '');
-        if (response.status === 403) {
-            throw new Error(`Cannot fork store: Permission denied.\n\n` +
-                `Ensure your GitHub token has the 'repo' scope.\n` +
-                `Try: Sign out and sign in again with GitHub.`);
-        }
-        if (response.status === 404) {
-            throw new Error(`Store repo not found: ${exports.STORE_CONFIG.owner}/${exports.STORE_CONFIG.repo}\n\n` +
-                `The repository may be private or doesn't exist.`);
-        }
-        throw new Error(`Failed to fork store: ${response.status} ${response.statusText}\n${errorBody}`);
-    }
-    const fork = (await response.json());
-    // Wait for fork to be ready (GitHub needs a moment)
-    await new Promise(resolve => setTimeout(resolve, 2000));
-    return fork;
-}
-/**
- * Create (or reset) a publish branch on the fork from upstream's default branch.
- */
-async function ensurePublishBranch(forkOwner, forkRepo, branchName) {
-    const token = await (0, github_1.getGitHubToken)();
-    const baseSha = await (0, github_1.getBranchSha)(exports.STORE_CONFIG.owner, exports.STORE_CONFIG.repo, exports.STORE_CONFIG.defaultBranch);
-    const headers = {
-        Authorization: `Bearer ${token}`,
-        Accept: 'application/vnd.github.v3+json',
-        'User-Agent': 'AgentIDE',
-        'Content-Type': 'application/json',
-    };
-    const createResponse = await fetch(`https://api.github.com/repos/${forkOwner}/${forkRepo}/git/refs`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({
-            ref: `refs/heads/${branchName}`,
-            sha: baseSha,
-        }),
-    });
-    if (createResponse.ok) {
-        return;
-    }
-    if (createResponse.status === 422) {
-        const patchResponse = await fetch(`https://api.github.com/repos/${forkOwner}/${forkRepo}/git/refs/heads/${encodeURIComponent(branchName)}`, {
-            method: 'PATCH',
-            headers,
-            body: JSON.stringify({ sha: baseSha, force: true }),
-        });
-        if (patchResponse.ok) {
-            return;
-        }
-        const patchError = await patchResponse.text();
-        throw new Error(`Failed to reset publish branch: ${patchResponse.status} ${patchError}`);
-    }
-    const error = await createResponse.text();
-    if (createResponse.status === 403 && error.includes('personal access token')) {
-        const orgHint = forkOwner === exports.STORE_CONFIG.owner
-            ? `\n\nIf this is an organization repo, authorize the token for SSO: GitHub → Settings → Developer settings → Personal access tokens → your token → Configure SSO → Authorize ${exports.STORE_CONFIG.owner}.`
-            : '';
-        throw new Error(`Failed to create publish branch: token cannot write to ${forkOwner}/${forkRepo}.${orgHint}`);
-    }
-    throw new Error(`Failed to create publish branch: ${createResponse.status} ${error}`);
-}
-/**
- * Check whether the token has push access to a repo via the GitHub API permissions field.
- */
-async function verifyGitWriteAccess(owner, repo) {
-    const token = await (0, github_1.getGitHubToken)();
-    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
-        headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: 'application/vnd.github.v3+json',
-            'User-Agent': 'AgentIDE',
-        },
-    });
-    if (!response.ok) {
-        return false;
-    }
-    const data = await response.json();
-    return data.permissions?.push === true || data.permissions?.admin === true;
-}
-/**
- * Whether the authenticated user can push directly to the configured store repo.
- */
-async function canPublishDirectlyToStore() {
-    return verifyGitWriteAccess(exports.STORE_CONFIG.owner, exports.STORE_CONFIG.repo);
-}
-/**
- * Create a pull request into the store repo.
- * @param head Branch name for same-repo PRs, or `owner:branch` for cross-repo PRs.
- */
-async function createPullRequest(head, title, body, forkOwnerForErrors) {
-    const token = await (0, github_1.getGitHubToken)();
-    const response = await fetch(`https://api.github.com/repos/${exports.STORE_CONFIG.owner}/${exports.STORE_CONFIG.repo}/pulls`, {
-        method: 'POST',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: 'application/vnd.github.v3+json',
-            'User-Agent': 'AgentIDE',
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            title,
-            body,
-            head,
-            base: exports.STORE_CONFIG.defaultBranch,
-        }),
-    });
-    if (!response.ok) {
-        const error = await response.text();
-        throw new Error((0, shared_1.formatStorePullRequestError)(error, exports.STORE_CONFIG.owner, exports.STORE_CONFIG.repo, forkOwnerForErrors));
-    }
-    const pr = (await response.json());
-    return { url: pr.html_url, number: pr.number };
-}
-/**
- * Publish an artifact to the store.
- * Maintainers with push access publish directly to the store repo; others use fork + PR.
- */
-async function publishToStore(options, outputChannel) {
-    const { type, slug, version, files, changelog } = options;
-    const typePath = (0, shared_1.getStorePath)(type);
-    const tagName = `${typePath}/${slug}/v${version}`;
-    const branchName = `publish-${type}-${slug}-v${version}`;
-    if (outputChannel) {
-        (0, utils_1.logInfo)(outputChannel, `[Store] Publishing ${type} "${slug}" v${version}...`);
-    }
-    const publishDirect = await canPublishDirectlyToStore();
-    let targetOwner;
-    let targetRepo;
-    let prHead;
-    let forkOwnerForErrors;
-    if (publishDirect) {
-        targetOwner = exports.STORE_CONFIG.owner;
-        targetRepo = exports.STORE_CONFIG.repo;
-        prHead = branchName;
-        if (outputChannel) {
-            (0, utils_1.logInfo)(outputChannel, `[Store] Publishing directly to ${targetOwner}/${targetRepo}...`);
-        }
-    }
-    else {
-        if (outputChannel) {
-            (0, utils_1.logInfo)(outputChannel, `[Store] Ensuring fork exists...`);
-        }
-        const fork = await ensureFork();
-        targetOwner = fork.owner.login;
-        targetRepo = fork.name;
-        prHead = `${fork.owner.login}:${branchName}`;
-        forkOwnerForErrors = fork.owner.login;
-        if (outputChannel) {
-            (0, utils_1.logInfo)(outputChannel, `[Store] Syncing fork with upstream...`);
-        }
-        await syncForkWithUpstream(fork.owner.login, fork.name);
-    }
-    if (outputChannel) {
-        (0, utils_1.logInfo)(outputChannel, `[Store] Creating branch: ${branchName}`);
-    }
-    await ensurePublishBranch(targetOwner, targetRepo, branchName);
-    if (outputChannel) {
-        (0, utils_1.logInfo)(outputChannel, `[Store] Committing ${files.length} files...`);
-    }
-    const filesToCommit = files.map(file => ({
-        path: `${typePath}/${slug}/${file.path}`,
-        content: file.content,
-    }));
-    await (0, github_1.commitMultipleFiles)(targetOwner, targetRepo, branchName, filesToCommit, `Add ${type}/${slug} v${version}`);
-    if (outputChannel) {
-        for (const file of files) {
-            (0, utils_1.logInfo)(outputChannel, `[Store]   ✓ ${file.path}`);
-        }
-    }
-    if (outputChannel) {
-        (0, utils_1.logInfo)(outputChannel, `[Store] Creating pull request...`);
-    }
-    const prBody = `
-## New ${type}: ${slug} v${version}
-
-${changelog || 'No changelog provided.'}
-
----
-*Submitted via AgentIDE*
-`;
-    const pr = await createPullRequest(prHead, `[${type}] Add ${slug} v${version}`, prBody, forkOwnerForErrors);
-    if (outputChannel) {
-        (0, utils_1.logInfo)(outputChannel, `[Store] OK Created PR: ${pr.url}`);
-    }
-    return {
-        prUrl: pr.url,
-        prNumber: pr.number,
-        tagName,
-    };
-}
-// -----------------------------------------------------------------------------
-// URL Parsing
-// -----------------------------------------------------------------------------
-// -----------------------------------------------------------------------------
-// URL Parsing and Type Detection
-// -----------------------------------------------------------------------------
-/**
- * Parse any GitHub URL into components.
- * Uses STORE_CONFIG to determine if URL points to the configured store repo.
- */
-function parseGitHubUrl(url) {
-    return (0, shared_1.parseGitHubUrl)(url, exports.STORE_CONFIG.owner, exports.STORE_CONFIG.repo);
-}
-/**
- * Detect artifact type from a GitHub repo by checking for marker files.
- * - agent.yaml → pack
- * - SKILL.md → skill
- * - .mcp.json or mcp.json → mcp
- * - engine.manifest.json → engine
- */
-async function detectArtifactType(owner, repo, ref, path, outputChannel) {
-    const basePath = path ? `${path}/` : '';
-    const baseRef = ref || 'main';
-    const checkFile = async (filePath) => {
-        const url = `https://api.github.com/repos/${owner}/${repo}/contents/${basePath}${filePath}?ref=${baseRef}`;
-        try {
-            const response = await fetch(url, {
-                headers: {
-                    Accept: 'application/vnd.github.v3+json',
-                    'User-Agent': 'AgentIDE',
-                },
-            });
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    };
-    if (outputChannel) {
-        (0, utils_1.logInfo)(outputChannel, `[Store] Detecting artifact type for ${owner}/${repo}/${basePath}...`);
-    }
-    // Check in order of specificity
-    if (await checkFile('agent.yaml')) {
-        return 'pack';
-    }
-    if (await checkFile('SKILL.md')) {
-        return 'skill';
-    }
-    if (await checkFile('.mcp.json') || await checkFile('mcp.json')) {
-        return 'mcp';
-    }
-    if (await checkFile('engine.manifest.json')) {
-        return 'engine';
-    }
-    if (await checkFile('view.yaml') && await checkFile('panel-entry.yaml')) {
-        return 'view';
-    }
-    throw new Error(`Cannot detect artifact type in ${owner}/${repo}${path ? `/${path}` : ''}. Expected agent.yaml, SKILL.md, .mcp.json, engine.manifest.json, or view.yaml with panel-entry.yaml`);
-}
-/**
- * Parse a store URL into components.
- * Re-exports shared parseStoreUrl.
- */
-exports.parseStoreUrl = shared_1.parseStoreUrl;
-/**
- * Check if a URL looks like a store URL.
- * Uses STORE_CONFIG to determine if URL points to the configured store repo.
- */
-function isStoreUrl(url) {
-    return (0, shared_1.isStoreUrl)(url, exports.STORE_CONFIG.owner, exports.STORE_CONFIG.repo);
-}
-/**
- * List all artifacts available in the store.
- */
-async function listStoreIndex(type, outputChannel) {
-    const items = [];
-    // Fetch directory listing from GitHub
-    const typePaths = type
-        ? [(0, shared_1.getStorePath)(type)]
-        : [
-            exports.STORE_CONFIG.paths.packs,
-            exports.STORE_CONFIG.paths.skills,
-            exports.STORE_CONFIG.paths.mcp,
-            exports.STORE_CONFIG.paths.engines,
-            exports.STORE_CONFIG.paths.spotlightViews,
-        ];
-    for (const typePath of typePaths) {
-        const url = `https://api.github.com/repos/${exports.STORE_CONFIG.owner}/${exports.STORE_CONFIG.repo}/contents/${typePath}`;
-        try {
-            const response = await fetch(url, {
-                headers: {
-                    Accept: 'application/vnd.github.v3+json',
-                    'User-Agent': 'AgentIDE',
-                },
-            });
-            if (!response.ok) {
-                if (outputChannel) {
-                    (0, utils_1.logInfo)(outputChannel, `[Store] No ${typePath} directory found`);
-                }
-                continue;
-            }
-            const entries = (await response.json());
-            for (const entry of entries) {
-                if (entry.type === 'dir') {
-                    const artifactType = typePath === exports.STORE_CONFIG.paths.packs ? 'pack' :
-                        typePath === exports.STORE_CONFIG.paths.skills ? 'skill' :
-                            typePath === exports.STORE_CONFIG.paths.mcp ? 'mcp' :
-                                typePath === exports.STORE_CONFIG.paths.engines ? 'engine' : 'view';
-                    items.push({
-                        type: artifactType,
-                        slug: entry.name,
-                        path: entry.path,
-                    });
-                }
-            }
-        }
-        catch (e) {
-            if (outputChannel) {
-                (0, utils_1.logInfo)(outputChannel, `[Store] Error listing ${typePath}: ${e}`);
-            }
-        }
-    }
-    return items;
-}
-/**
- * Format a store URL.
- * Re-exports shared formatStoreUrl.
- */
-exports.formatStoreUrl = shared_1.formatStoreUrl;