@agenthippo-ai/agenthippo 0.1.0

package/out/store/index.js

@@ -0,0 +1,755 @@
+"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 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.
+ */
+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;
+}
+/**
+ * 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: 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;