claudepluginhub 0.3.2 → 0.4.1

package/README.md

@@ -1,28 +1,77 @@
 # claudepluginhub
 
-Install Claude Code plugins from [ClaudePluginHub](https://claudepluginhub.com) with a single command.
+Install Claude Code plugins from [ClaudePluginHub](https://claudepluginhub.com) and GitHub with a single command.
 
 ## Usage
 
 ```bash
+# GitHub plugin or marketplace
+npx claudepluginhub owner/repo
+
+# ClaudePluginHub collection
 npx claudepluginhub u/<userId>/<slug>
+
+# Full URL
+npx claudepluginhub https://claudepluginhub.com/api/user-plugins/<userId>/<slug>/marketplace.json
 ```
 
-This will:
+## Identifier types
+
+### `owner/repo` (GitHub)
+
+Installs a plugin or marketplace directly from a GitHub repository using Claude Code's native plugin system.
 
-1. Fetch the plugin's marketplace JSON
-2. Register the marketplace with Claude Code
-3. Install all plugins from the marketplace
+- **Marketplace repos** (`.claude-plugin/marketplace.json`): Adds the marketplace and installs selected plugins via `claude plugin marketplace add` and `claude plugin install`.
+- **Plugin repos** (with or without `.claude-plugin/plugin.json`): Creates a local wrapper marketplace, then installs via Claude Code.
+
+### `u/<userId>/<slug>` (ClaudePluginHub)
+
+Installs from a ClaudePluginHub user-curated collection. Components are downloaded directly and tracked in a lock file.
 
 ### Full URL
 
-You can also pass the full marketplace JSON URL:
+Same as `u/` form but with the full marketplace JSON URL.
+
+## Commands
 
-```bash
-npx claudepluginhub https://claudepluginhub.com/api/user-plugins/<userId>/<slug>/marketplace.json
 ```
+npx claudepluginhub <identifier>        Install from a source
+npx claudepluginhub add <identifier>    Same as above
+npx claudepluginhub update [identifier] Update (u/ collections only)
+npx claudepluginhub list                List (u/ collections only)
+npx claudepluginhub remove <identifier> Remove
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `--yes, -y` | Skip prompts (install all, project scope) |
+| `--scope <scope>` | Set scope: `user`, `project` (default), `local` |
+| `-h, --help` | Show help |
+
+## Lifecycle differences
+
+| Feature | `owner/repo` | `u/` collections |
+|---------|-------------|------------------|
+| Install | `claude plugin` commands | Direct download |
+| List | `claude plugin list` | `npx claudepluginhub list` |
+| Update | `claude plugin update` | `npx claudepluginhub update` |
+| Remove | `npx claudepluginhub remove owner/repo --scope <scope>` (standalone) or `claude plugin` commands (marketplace) | `npx claudepluginhub remove` |
+
+## Standalone wrapper
+
+When installing a standalone plugin via `owner/repo`, a local wrapper marketplace is created:
+
+| Scope | Wrapper path |
+|-------|-------------|
+| `user` | `~/.claude/.cpd-wrappers/<owner>-<repo>-user/` |
+| `project` | `.claude/.cpd-wrappers/<owner>-<repo>-project/` |
+| `local` | `~/.claude/.cpd-wrappers/<owner>-<repo>-local-<cwd-hash>/` |
+
+**Note:** `local` scope wrappers are stored under `~/.claude/` and are tied to the working directory where they were installed. Running `npx claudepluginhub remove owner/repo --scope local` for a local install must be done from the same project directory.
 
 ## Requirements
 
 - Node.js 18+
-- [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) installed and available in PATH
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) installed and available in PATH (required for `owner/repo` installs)

package/dist/detect.d.ts

@@ -0,0 +1,28 @@
+import type { TreeEntry } from './github.js';
+export declare function isOwnerRepo(identifier: string): boolean;
+export interface MarketplaceDetection {
+    kind: 'marketplace';
+    manifest: {
+        name: string;
+        plugins: Array<{
+            name: string;
+            description: string | null;
+            source: {
+                source: string;
+                repo: string;
+            };
+            strict: boolean;
+        }>;
+    };
+}
+export interface PluginDetection {
+    kind: 'plugin';
+    name: string;
+    strict: boolean;
+}
+export interface UnknownDetection {
+    kind: 'unknown';
+}
+export type RepoDetection = MarketplaceDetection | PluginDetection | UnknownDetection;
+export declare function hasComponentFiles(tree: TreeEntry[], prefix?: string): boolean;
+export declare function detectRepo(ownerRepo: string): Promise<RepoDetection>;

package/dist/detect.js

@@ -0,0 +1,152 @@
+import { fetchDefaultBranch, fetchTree, downloadFile } from './github.js';
+import { printError } from './output.js';
+import { sanitizeName } from './wrapper.js';
+const OWNER_REPO_RE = /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
+const VALID_NAME_RE = /^[a-zA-Z0-9_.-]+$/;
+export function isOwnerRepo(identifier) {
+    if (!OWNER_REPO_RE.test(identifier))
+        return false;
+    const [owner, repo] = identifier.split('/');
+    // Reject segments that are purely dots (e.g. "..", ".")
+    if (/^\.+$/.test(owner) || /^\.+$/.test(repo))
+        return false;
+    return true;
+}
+const COMPONENT_PATTERNS = [
+    /^commands\/.*\.md$/,
+    /^agents\/.*\.md$/,
+    /^skills\/.*\/SKILL\.md$/,
+    /^hooks\/hooks\.json$/,
+    /^\.mcp\.json$/,
+    /^\.lsp\.json$/,
+];
+export function hasComponentFiles(tree, prefix) {
+    for (const entry of tree) {
+        if (entry.type !== 'blob')
+            continue;
+        const path = prefix ? entry.path.slice(prefix.length) : entry.path;
+        if (COMPONENT_PATTERNS.some((p) => p.test(path)))
+            return true;
+    }
+    return false;
+}
+export async function detectRepo(ownerRepo) {
+    const branch = await fetchDefaultBranch(ownerRepo);
+    if (!branch) {
+        printError(`Could not access repository ${ownerRepo}`);
+        process.exit(1);
+    }
+    const tree = await fetchTree(ownerRepo, branch);
+    if (!tree) {
+        printError(`Could not fetch file tree for ${ownerRepo}`);
+        process.exit(1);
+    }
+    if (tree.truncated) {
+        printError(`Repository tree is too large (truncated). Cannot detect plugin structure.`);
+        process.exit(1);
+    }
+    const hasMarketplace = tree.tree.some((e) => e.type === 'blob' && e.path === '.claude-plugin/marketplace.json');
+    const hasPluginJson = tree.tree.some((e) => e.type === 'blob' && e.path === '.claude-plugin/plugin.json');
+    // Marketplace repo
+    if (hasMarketplace) {
+        const content = await downloadFile(ownerRepo, branch, '.claude-plugin/marketplace.json');
+        if (!content) {
+            printError('Failed to download marketplace.json');
+            process.exit(1);
+        }
+        let manifest;
+        try {
+            manifest = JSON.parse(content);
+        }
+        catch {
+            printError('marketplace.json is not valid JSON');
+            process.exit(1);
+        }
+        if (!manifest.name || typeof manifest.name !== 'string') {
+            printError('marketplace.json is missing the required "name" field');
+            process.exit(1);
+        }
+        if (!VALID_NAME_RE.test(manifest.name)) {
+            printError(`marketplace.json has an invalid name: "${manifest.name}". Must match [a-zA-Z0-9_.-]+`);
+            process.exit(1);
+        }
+        const rawPlugins = manifest.plugins;
+        if (!Array.isArray(rawPlugins)) {
+            printError('marketplace.json "plugins" must be an array');
+            process.exit(1);
+        }
+        const validPlugins = [];
+        for (const p of rawPlugins) {
+            if (!p || typeof p !== 'object') {
+                printError('marketplace.json contains a non-object plugin entry');
+                process.exit(1);
+            }
+            const plugin = p;
+            const name = plugin.name;
+            if (typeof name !== 'string' || name.length === 0) {
+                printError(`marketplace.json plugin is missing the required "name" field`);
+                process.exit(1);
+            }
+            if (!VALID_NAME_RE.test(name)) {
+                printError(`marketplace.json plugin has an invalid name: "${name}". Must match [a-zA-Z0-9_.-]+`);
+                process.exit(1);
+            }
+            const rawSource = plugin.source;
+            const source = rawSource &&
+                typeof rawSource === 'object' &&
+                typeof rawSource.source === 'string' &&
+                typeof rawSource.repo === 'string'
+                ? rawSource
+                : { source: 'github', repo: ownerRepo };
+            validPlugins.push({
+                name,
+                description: typeof plugin.description === 'string' ? plugin.description : null,
+                source,
+                strict: plugin.strict === false ? false : true,
+            });
+        }
+        return {
+            kind: 'marketplace',
+            manifest: {
+                name: manifest.name,
+                plugins: validPlugins,
+            },
+        };
+    }
+    // Plugin with manifest
+    if (hasPluginJson) {
+        const content = await downloadFile(ownerRepo, branch, '.claude-plugin/plugin.json');
+        if (!content) {
+            printError('Failed to download plugin.json');
+            process.exit(1);
+        }
+        let pluginJson;
+        try {
+            pluginJson = JSON.parse(content);
+        }
+        catch {
+            printError('plugin.json is not valid JSON');
+            process.exit(1);
+        }
+        if (!('name' in pluginJson) || typeof pluginJson.name !== 'string') {
+            printError('plugin.json is missing the required "name" field');
+            process.exit(1);
+        }
+        if (!VALID_NAME_RE.test(pluginJson.name)) {
+            printError(`plugin.json has an invalid name: "${pluginJson.name}". Must match [a-zA-Z0-9_.-]+`);
+            process.exit(1);
+        }
+        const strict = pluginJson.strict !== false;
+        return { kind: 'plugin', name: pluginJson.name, strict };
+    }
+    // Plugin without manifest — check for component files at root
+    if (hasComponentFiles(tree.tree)) {
+        const repo = ownerRepo.split('/')[1];
+        return {
+            kind: 'plugin',
+            name: sanitizeName(repo),
+            strict: false,
+        };
+    }
+    return { kind: 'unknown' };
+}

package/dist/github-install.d.ts

@@ -0,0 +1,3 @@
+import type { Scope } from './prompts.js';
+export declare function runGithubInstall(ownerRepo: string, yes: boolean, scopeOverride: Scope | null): Promise<void>;
+export declare function runGithubRemove(ownerRepo: string, scopeOverride: Scope | null): Promise<void>;

package/dist/github-install.js

@@ -0,0 +1,214 @@
+import { scopePrompt, checkboxPrompt } from './prompts.js';
+import { detectRepo } from './detect.js';
+import { checkClaudeCli, claudeMarketplaceAdd, claudePluginInstall, claudePluginUninstall, claudeMarketplaceRemove, } from './native.js';
+import { writeWrapperMarketplace, readWrapperMeta, findWrapperScopes, removeWrapperDir, getWrapperDir, } from './wrapper.js';
+import { print, printStep, printSuccess, printFail, printError, printWarning, BOLD, RESET, DIM, GREEN, YELLOW, } from './output.js';
+export async function runGithubInstall(ownerRepo, yes, scopeOverride) {
+    if (!checkClaudeCli())
+        process.exit(1);
+    printStep('Detecting repository type...');
+    const detection = await detectRepo(ownerRepo);
+    if (detection.kind === 'unknown') {
+        printError(`No plugin or marketplace found in ${ownerRepo}. Expected .claude-plugin/ directory or component files (commands/, agents/, skills/, hooks/, .mcp.json, .lsp.json).`);
+        process.exit(1);
+    }
+    if (detection.kind === 'marketplace') {
+        await installMarketplace(ownerRepo, detection, yes, scopeOverride);
+    }
+    else {
+        await installStandalone(ownerRepo, detection, yes, scopeOverride);
+    }
+}
+async function installMarketplace(ownerRepo, detection, yes, scopeOverride) {
+    const { manifest } = detection;
+    printSuccess(`Marketplace "${manifest.name}" — ${manifest.plugins.length} plugin(s)`);
+    if (manifest.plugins.length === 0) {
+        printError('No valid plugins found in marketplace.');
+        process.exit(1);
+    }
+    // Plugin picker
+    let selectedPlugins = manifest.plugins;
+    if (!yes && manifest.plugins.length > 1) {
+        print('');
+        const items = manifest.plugins.map((p) => ({
+            label: p.name,
+            description: p.description ? `${DIM}${p.description}${RESET}` : undefined,
+            selected: true,
+        }));
+        const chosen = await checkboxPrompt('Select plugins to install:', items);
+        if (chosen === null) {
+            print('\nCancelled.');
+            process.exit(0);
+        }
+        selectedPlugins = chosen.map((i) => manifest.plugins[i]);
+        if (selectedPlugins.length === 0) {
+            printError('No plugins selected.');
+            process.exit(0);
+        }
+    }
+    // Scope picker
+    let scope = scopeOverride ?? 'project';
+    if (!yes && !scopeOverride) {
+        print('');
+        const chosenScope = await scopePrompt('project');
+        if (chosenScope === null) {
+            print('\nCancelled.');
+            process.exit(0);
+        }
+        scope = chosenScope;
+    }
+    // Add marketplace
+    print('');
+    printStep(`Adding marketplace from ${ownerRepo}...`);
+    const addResult = claudeMarketplaceAdd(ownerRepo, scope);
+    if (!addResult.ok) {
+        printError(`Failed to add marketplace: ${addResult.output}`);
+        process.exit(1);
+    }
+    printSuccess('Marketplace added');
+    // Install each selected plugin
+    let failures = 0;
+    for (const plugin of selectedPlugins) {
+        printStep(`Installing ${plugin.name}...`);
+        const result = claudePluginInstall(plugin.name, manifest.name, scope);
+        if (result.ok) {
+            printSuccess(plugin.name);
+        }
+        else {
+            printFail(plugin.name, result.output);
+            failures++;
+        }
+    }
+    print('');
+    if (failures === 0) {
+        print(`${GREEN}${BOLD}Done!${RESET} ${selectedPlugins.length} plugin(s) installed.`);
+    }
+    else {
+        print(`${YELLOW}${BOLD}Done.${RESET} ${selectedPlugins.length - failures} succeeded, ${failures} failed.`);
+    }
+    print('');
+    printNativeGuidance();
+}
+async function installStandalone(ownerRepo, detection, yes, scopeOverride) {
+    printSuccess(`Plugin "${detection.name}" (strict: ${detection.strict})`);
+    // Scope picker
+    let scope = scopeOverride ?? 'project';
+    if (!yes && !scopeOverride) {
+        print('');
+        const chosenScope = await scopePrompt('project');
+        if (chosenScope === null) {
+            print('\nCancelled.');
+            process.exit(0);
+        }
+        scope = chosenScope;
+    }
+    // Write wrapper marketplace
+    print('');
+    printStep('Creating wrapper marketplace...');
+    const { wrapperDir, marketplaceName } = writeWrapperMarketplace({
+        ownerRepo,
+        pluginName: detection.name,
+        scope,
+        strict: detection.strict,
+    });
+    printSuccess(`Wrapper at ${DIM}${wrapperDir}${RESET}`);
+    // Add wrapper marketplace
+    printStep('Adding marketplace...');
+    const addResult = claudeMarketplaceAdd(wrapperDir, scope);
+    if (!addResult.ok) {
+        printError(`Failed to add marketplace: ${addResult.output}`);
+        process.exit(1);
+    }
+    printSuccess('Marketplace added');
+    // Install the plugin
+    printStep(`Installing ${detection.name}...`);
+    const installResult = claudePluginInstall(detection.name, marketplaceName, scope);
+    if (!installResult.ok) {
+        printError(`Failed to install plugin: ${installResult.output}`);
+        process.exit(1);
+    }
+    printSuccess(detection.name);
+    print('');
+    print(`${GREEN}${BOLD}Done!${RESET} Plugin "${detection.name}" installed.`);
+    print('');
+    print(`${DIM}Manage with:${RESET}`);
+    print(`  ${DIM}npx claudepluginhub remove ${ownerRepo} --scope ${scope}${RESET}`);
+    print(`  ${DIM}claude plugin list${RESET}`);
+    print('');
+}
+export async function runGithubRemove(ownerRepo, scopeOverride) {
+    let scope;
+    if (scopeOverride) {
+        scope = scopeOverride;
+    }
+    else {
+        const scopes = findWrapperScopes(ownerRepo);
+        if (scopes.length === 0) {
+            printMarketplaceGuidance(ownerRepo);
+            return;
+        }
+        if (scopes.length === 1) {
+            scope = scopes[0];
+        }
+        else {
+            printError(`Found ${ownerRepo} in multiple scopes: ${scopes.join(', ')}. Use --scope to specify.`);
+            process.exit(1);
+        }
+    }
+    const meta = readWrapperMeta(ownerRepo, scope);
+    if (!meta) {
+        printMarketplaceGuidance(ownerRepo);
+        return;
+    }
+    printStep(`Removing ${ownerRepo} (scope: ${scope})...`);
+    let anyFailed = false;
+    // Best-effort: uninstall plugin
+    const uninstallResult = claudePluginUninstall(meta.pluginName, scope);
+    if (uninstallResult.ok) {
+        printSuccess(`Uninstalled plugin ${meta.pluginName}`);
+    }
+    else {
+        printWarning(`Could not uninstall plugin: ${uninstallResult.output}`);
+        anyFailed = true;
+    }
+    // Best-effort: remove marketplace
+    const removeResult = claudeMarketplaceRemove(meta.marketplaceName);
+    if (removeResult.ok) {
+        printSuccess(`Removed marketplace ${meta.marketplaceName}`);
+    }
+    else {
+        printWarning(`Could not remove marketplace: ${removeResult.output}`);
+        anyFailed = true;
+    }
+    if (anyFailed) {
+        // Keep wrapper metadata so the user can retry cleanup later
+        print('');
+        print(`${YELLOW}${BOLD}Partially removed.${RESET} Some cleanup steps failed.`);
+        const wrapperDir = getWrapperDir(ownerRepo, scope);
+        print(`Wrapper kept at ${DIM}${wrapperDir}${RESET} for retry.`);
+        print(`Use ${DIM}claude plugin list${RESET} to check remaining state.`);
+        print(`Retry with ${DIM}npx claudepluginhub remove ${ownerRepo} --scope ${scope}${RESET}`);
+    }
+    else {
+        // All native cleanup succeeded — safe to delete wrapper
+        removeWrapperDir(ownerRepo, scope);
+        printSuccess('Removed wrapper directory');
+        print('');
+        print(`${GREEN}${BOLD}Removed${RESET} ${ownerRepo}`);
+    }
+    print('');
+}
+function printMarketplaceGuidance(ownerRepo) {
+    print(`No standalone wrapper found for ${ownerRepo}.`);
+    print('');
+    print(`If installed as a marketplace, use Claude Code directly:`);
+    print(`  ${DIM}claude plugin marketplace remove <name>${RESET}`);
+    print(`  ${DIM}claude plugin uninstall <plugin>${RESET}`);
+}
+function printNativeGuidance() {
+    print(`${DIM}Manage with Claude Code:${RESET}`);
+    print(`  ${DIM}claude plugin list${RESET}`);
+    print(`  ${DIM}claude plugin uninstall <plugin>${RESET}`);
+    print(`  ${DIM}claude plugin marketplace remove <name>${RESET}`);
+    print('');
+}

package/dist/github.d.ts

@@ -1,11 +1,11 @@
-interface TreeEntry {
+export interface TreeEntry {
     path: string;
     mode: string;
     type: 'blob' | 'tree';
     sha: string;
     size?: number;
 }
-interface TreeResponse {
+export interface TreeResponse {
     sha: string;
     tree: TreeEntry[];
     truncated: boolean;
@@ -16,4 +16,3 @@ export declare function downloadFile(repo: string, branch: string, path: string)
 export declare function findTreeSha(tree: TreeResponse, dirPath: string): string | null;
 export declare function findBlobSha(tree: TreeResponse, filePath: string): string | null;
 export declare function listFilesUnder(tree: TreeResponse, dirPath: string): TreeEntry[];
-export {};

package/dist/index.js

@@ -5,6 +5,8 @@ import { runInstall } from './install.js';
 import { runUpdate } from './update.js';
 import { runRemove } from './remove.js';
 import { runList } from './list.js';
+import { isOwnerRepo } from './detect.js';
+import { runGithubInstall, runGithubRemove } from './github-install.js';
 import { print, printBanner, printStep, printSuccess, printError, DIM, RESET, GREEN, CYAN, YELLOW, } from './output.js';
 const VALID_SCOPES = ['user', 'project', 'local'];
 const TYPE_BADGES = {
@@ -19,16 +21,22 @@ function printUsage() {
     print(`Usage: npx claudepluginhub <command> [options]
 
 Commands:
-  <identifier>              Install components from a user-plugin collection
-  add <identifier>          Same as above (explicit)
-  update [identifier]       Update installed components
-  list                      List installed components
-  remove <identifier>       Remove installed components
+  <identifier>              Install from a source
+  add <identifier>          Same as above
+  update [identifier]       Update (u/ collections only)
+  list                      List (u/ collections only)
+  remove <identifier>       Remove
 
 Identifiers:
-  u/<userId>/<slug>         Short form
+  owner/repo                GitHub plugin or marketplace (via Claude Code)
+  u/<userId>/<slug>         ClaudePluginHub collection
   https://claudepluginhub.com/api/user-plugins/.../marketplace.json
 
+Note: owner/repo installs use Claude Code's plugin system.
+  - list/update only show u/ installs
+  - Use \`claude plugin list\` for Claude Code plugins
+  - Standalone: \`npx claudepluginhub remove owner/repo\` for cleanup
+
 Options:
   --yes, -y       Skip prompts (install all, project scope)
   --scope <scope> Set scope: user, project (default), local
@@ -86,6 +94,11 @@ async function main() {
             printError('Missing identifier. Usage: npx claudepluginhub remove <identifier>');
             process.exit(1);
         }
+        // owner/repo remove → github wrapper cleanup
+        if (isOwnerRepo(identifier)) {
+            await runGithubRemove(identifier, scopeOverride);
+            process.exit(0);
+        }
         await runRemove(identifier);
         process.exit(0);
     }
@@ -94,12 +107,17 @@ async function main() {
         printUsage();
         process.exit(1);
     }
+    // owner/repo → native Claude Code install
+    if (isOwnerRepo(identifier)) {
+        await runGithubInstall(identifier, yes, scopeOverride);
+        process.exit(0);
+    }
     // Resolve identifier to API URL
     const url = resolveMarketplaceUrl(identifier);
     if (!url) {
         printError(`Invalid identifier: ${identifier}`);
         print('');
-        print(`Expected: u/<userId>/<slug> or a claudepluginhub.com URL`);
+        print(`Expected: owner/repo, u/<userId>/<slug>, or a claudepluginhub.com URL`);
         process.exit(1);
     }
     // Derive the collection identifier from the input

package/dist/native.d.ts

@@ -0,0 +1,18 @@
+import type { Scope } from './prompts.js';
+export declare function checkClaudeCli(): boolean;
+export declare function claudeMarketplaceAdd(source: string, scope: Scope): {
+    ok: boolean;
+    output: string;
+};
+export declare function claudePluginInstall(plugin: string, marketplace: string, scope: Scope): {
+    ok: boolean;
+    output: string;
+};
+export declare function claudePluginUninstall(plugin: string, scope: Scope): {
+    ok: boolean;
+    output: string;
+};
+export declare function claudeMarketplaceRemove(name: string): {
+    ok: boolean;
+    output: string;
+};

package/dist/native.js

@@ -0,0 +1,42 @@
+import { execFileSync } from 'node:child_process';
+import { printError } from './output.js';
+function runClaude(args) {
+    try {
+        const output = execFileSync('claude', args, {
+            encoding: 'utf-8',
+            timeout: 60_000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return { ok: true, output: output.trim() };
+    }
+    catch (err) {
+        const error = err;
+        return { ok: false, output: error.stderr ?? error.message ?? 'Unknown error' };
+    }
+}
+export function checkClaudeCli() {
+    const result = runClaude(['plugin', '--help']);
+    if (!result.ok) {
+        printError('Claude CLI not found or does not support plugins. Install Claude Code first: https://docs.anthropic.com/en/docs/claude-code');
+        return false;
+    }
+    return true;
+}
+export function claudeMarketplaceAdd(source, scope) {
+    return runClaude(['plugin', 'marketplace', 'add', source, '--scope', scope]);
+}
+export function claudePluginInstall(plugin, marketplace, scope) {
+    return runClaude([
+        'plugin',
+        'install',
+        `${plugin}@${marketplace}`,
+        '--scope',
+        scope,
+    ]);
+}
+export function claudePluginUninstall(plugin, scope) {
+    return runClaude(['plugin', 'uninstall', plugin, '--scope', scope]);
+}
+export function claudeMarketplaceRemove(name) {
+    return runClaude(['plugin', 'marketplace', 'remove', name]);
+}

package/dist/output.d.ts

@@ -13,6 +13,7 @@ export declare const moveUp: (n: number) => string;
 export declare function print(message: string): void;
 export declare function printError(message: string): void;
 export declare function printBanner(): void;
+export declare function printWarning(message: string): void;
 export declare function printStep(label: string): void;
 export declare function printSuccess(label: string): void;
 export declare function printFail(label: string, error?: string): void;

package/dist/output.js

@@ -19,6 +19,9 @@ export function printError(message) {
 export function printBanner() {
     print(`\n${CYAN}${BOLD}ClaudePluginHub${RESET} ${DIM}Installer${RESET}\n`);
 }
+export function printWarning(message) {
+    console.error(`${YELLOW}Warning:${RESET} ${message}`);
+}
 export function printStep(label) {
     print(`${DIM}>${RESET} ${label}`);
 }

package/dist/wrapper.d.ts

@@ -0,0 +1,25 @@
+import type { Scope } from './prompts.js';
+export declare function sanitizeName(raw: string): string;
+export declare function validateManifestName(name: string): boolean;
+export declare function getWrapperDir(ownerRepo: string, scope: Scope): string;
+export declare function getMarketplaceName(ownerRepo: string, scope: Scope): string;
+export interface WrapperOptions {
+    ownerRepo: string;
+    pluginName: string;
+    scope: Scope;
+    strict: boolean;
+}
+export interface WrapperMeta {
+    ownerRepo: string;
+    pluginName: string;
+    marketplaceName: string;
+    scope: Scope;
+    cwd: string;
+}
+export declare function writeWrapperMarketplace(opts: WrapperOptions): {
+    wrapperDir: string;
+    marketplaceName: string;
+};
+export declare function readWrapperMeta(ownerRepo: string, scope: Scope): WrapperMeta | null;
+export declare function findWrapperScopes(ownerRepo: string): Scope[];
+export declare function removeWrapperDir(ownerRepo: string, scope: Scope): void;

package/dist/wrapper.js

@@ -0,0 +1,113 @@
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+const VALID_NAME_RE = /^[a-zA-Z0-9_.-]+$/;
+export function sanitizeName(raw) {
+    return (raw
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '') || 'plugin');
+}
+export function validateManifestName(name) {
+    return VALID_NAME_RE.test(name);
+}
+function cwdHash() {
+    return createHash('sha256').update(process.cwd()).digest('hex').slice(0, 8);
+}
+function wrapperBaseName(ownerRepo, scope) {
+    const [owner, repo] = ownerRepo.split('/');
+    if (scope === 'local') {
+        return `${owner}-${repo}-local-${cwdHash()}`;
+    }
+    return `${owner}-${repo}-${scope}`;
+}
+export function getWrapperDir(ownerRepo, scope) {
+    const name = wrapperBaseName(ownerRepo, scope);
+    if (scope === 'project') {
+        return join(process.cwd(), '.claude', '.cpd-wrappers', name);
+    }
+    // user and local both go under ~/.claude/
+    return join(homedir(), '.claude', '.cpd-wrappers', name);
+}
+export function getMarketplaceName(ownerRepo, scope) {
+    const [owner, repo] = ownerRepo.split('/');
+    if (scope === 'local') {
+        return `cpd-${sanitizeName(owner)}-${sanitizeName(repo)}-local-${cwdHash()}`;
+    }
+    return `cpd-${sanitizeName(owner)}-${sanitizeName(repo)}-${scope}`;
+}
+export function writeWrapperMarketplace(opts) {
+    const { ownerRepo, pluginName, scope, strict } = opts;
+    const wrapperDir = getWrapperDir(ownerRepo, scope);
+    const marketplaceName = getMarketplaceName(ownerRepo, scope);
+    const marketplace = {
+        name: marketplaceName,
+        owner: { name: 'ClaudePluginHub CLI' },
+        plugins: [
+            {
+                name: pluginName,
+                source: { source: 'github', repo: ownerRepo },
+                strict,
+            },
+        ],
+    };
+    const meta = {
+        ownerRepo,
+        pluginName,
+        marketplaceName,
+        scope,
+        cwd: process.cwd(),
+    };
+    mkdirSync(join(wrapperDir, '.claude-plugin'), { recursive: true });
+    writeFileSync(join(wrapperDir, '.claude-plugin', 'marketplace.json'), JSON.stringify(marketplace, null, 2) + '\n');
+    writeFileSync(join(wrapperDir, 'cpd-meta.json'), JSON.stringify(meta, null, 2) + '\n');
+    return { wrapperDir, marketplaceName };
+}
+export function readWrapperMeta(ownerRepo, scope) {
+    const dir = getWrapperDir(ownerRepo, scope);
+    const metaPath = join(dir, 'cpd-meta.json');
+    if (!existsSync(metaPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(metaPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function findWrapperScopes(ownerRepo) {
+    const scopes = [];
+    const [owner, repo] = ownerRepo.split('/');
+    // Check user scope
+    const userDir = join(homedir(), '.claude', '.cpd-wrappers');
+    if (existsSync(userDir)) {
+        const userWrapper = join(userDir, `${owner}-${repo}-user`);
+        if (existsSync(join(userWrapper, 'cpd-meta.json'))) {
+            scopes.push('user');
+        }
+    }
+    // Check project scope
+    const projectDir = join(process.cwd(), '.claude', '.cpd-wrappers');
+    if (existsSync(projectDir)) {
+        const projectWrapper = join(projectDir, `${owner}-${repo}-project`);
+        if (existsSync(join(projectWrapper, 'cpd-meta.json'))) {
+            scopes.push('project');
+        }
+    }
+    // Check local scope — only matches current cwd
+    if (existsSync(userDir)) {
+        const localWrapper = join(userDir, `${owner}-${repo}-local-${cwdHash()}`);
+        if (existsSync(join(localWrapper, 'cpd-meta.json'))) {
+            scopes.push('local');
+        }
+    }
+    return scopes;
+}
+export function removeWrapperDir(ownerRepo, scope) {
+    const dir = getWrapperDir(ownerRepo, scope);
+    if (existsSync(dir)) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudepluginhub",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "description": "Install Claude Code components from ClaudePluginHub",
   "bin": {
     "claudepluginhub": "dist/index.js"