fix: claude code marketplace schema (#29)

Signed-off-by: Yordis Prieto <[email protected]>

Author: yordis

package.json

@@ -18,6 +18,7 @@
     "aipm": "./src/cli.ts"
   },
   "scripts": {
+    "ci:all": "bun run format:check && bun run typecheck && bun run test",
     "test": "bun test",
     "test:coverage": "bun test --coverage",
     "typecheck": "tsc --noEmit",

src/commands/info.ts

@@ -5,7 +5,7 @@ import { loadPluginsConfig } from '../config/loader';
 import { DirectoryNotFoundError, isNodeError, PluginNotFoundError } from '../errors';
 import { resolveMarketplacePath } from '../helpers/git';
 import { defaultIO } from '../helpers/io';
-import { getPluginSourcePath, loadMarketplaceManifest } from '../helpers/marketplace';
+import { getMarketplaceType, getPluginSourcePath, loadMarketplaceManifest } from '../helpers/marketplace';
 import { loadPluginManifest } from '../helpers/plugin';
 
 const InfoOptionsSchema = z.object({
@@ -52,7 +52,7 @@ export async function info(options: unknown): Promise<void> {
       return;
     }
 
-    const marketplaceManifest = await loadMarketplaceManifest(marketplacePath);
+    const marketplaceManifest = await loadMarketplaceManifest(marketplacePath, getMarketplaceType(marketplaceName));
     const pluginPath = getPluginSourcePath(marketplacePath, pluginName, marketplaceManifest);
 
     let pluginStats;

src/commands/plugin-install.ts

@@ -5,7 +5,12 @@ import { DIR_CURSOR } from '../constants';
 import { fileExists, writeJsonFile } from '../helpers/fs';
 import { resolveMarketplacePath } from '../helpers/git';
 import { defaultIO } from '../helpers/io';
-import { getPluginSourcePath, isPluginInManifest, loadMarketplaceManifest } from '../helpers/marketplace';
+import {
+  getMarketplaceType,
+  getPluginSourcePath,
+  isPluginInManifest,
+  loadMarketplaceManifest,
+} from '../helpers/marketplace';
 import { validatePluginStructure } from '../helpers/plugin';
 import { formatSyncResult, syncPluginToCursor } from '../helpers/sync-strategy';
 import { PluginsConfigSchema } from '../schema';
@@ -67,7 +72,9 @@ export async function pluginInstall(options: unknown): Promise<void> {
       throw error;
     }
 
-    const manifest = !cmd.dryRun ? await loadMarketplaceManifest(marketplacePath) : null;
+    const manifest = !cmd.dryRun
+      ? await loadMarketplaceManifest(marketplacePath, getMarketplaceType(marketplaceName))
+      : null;
 
     if (!isPluginInManifest(pluginName, manifest)) {
       const error = new Error(`Plugin '${pluginName}' not found in marketplace '${marketplaceName}'`);

src/commands/plugin-search.ts

@@ -3,7 +3,7 @@ import { getConfigPaths, loadPluginsConfig } from '../config/loader';
 import { fileExists } from '../helpers/fs';
 import { resolveMarketplacePath } from '../helpers/git';
 import { defaultIO } from '../helpers/io';
-import { getAvailablePlugins, loadMarketplaceManifest } from '../helpers/marketplace';
+import { getAvailablePlugins, getMarketplaceType, loadMarketplaceManifest } from '../helpers/marketplace';
 
 const PluginSearchOptionsSchema = z.object({
   query: z.string().optional(),
@@ -48,7 +48,7 @@ export async function pluginSearch(options: unknown): Promise<void> {
           continue;
         }
 
-        const manifest = await loadMarketplaceManifest(marketplacePath);
+        const manifest = await loadMarketplaceManifest(marketplacePath, getMarketplaceType(marketplaceName));
         const availablePlugins = await getAvailablePlugins(marketplacePath, manifest);
 
         for (const pluginName of availablePlugins) {

src/commands/plugin-update.ts

@@ -5,7 +5,12 @@ import { DIR_CURSOR } from '../constants';
 import { fileExists } from '../helpers/fs';
 import { resolveMarketplacePath } from '../helpers/git';
 import { defaultIO } from '../helpers/io';
-import { getPluginSourcePath, isPluginInManifest, loadMarketplaceManifest } from '../helpers/marketplace';
+import {
+  getMarketplaceType,
+  getPluginSourcePath,
+  isPluginInManifest,
+  loadMarketplaceManifest,
+} from '../helpers/marketplace';
 import { validatePluginStructure } from '../helpers/plugin';
 import { formatSyncResult, syncPluginToCursor } from '../helpers/sync-strategy';
 
@@ -67,7 +72,9 @@ export async function pluginUpdate(options: unknown): Promise<void> {
       throw error;
     }
 
-    const manifest = !cmd.dryRun ? await loadMarketplaceManifest(marketplacePath) : null;
+    const manifest = !cmd.dryRun
+      ? await loadMarketplaceManifest(marketplacePath, getMarketplaceType(marketplaceName))
+      : null;
 
     if (!isPluginInManifest(pluginName, manifest)) {
       const error = new Error(`Plugin '${pluginName}' not found in marketplace '${marketplaceName}'`);

src/commands/sync.ts

@@ -6,7 +6,12 @@ import { DIR_CURSOR, DIR_MARKETPLACE } from '../constants';
 import { ensureDir, fileExists } from '../helpers/fs';
 import { resolveMarketplacePath } from '../helpers/git';
 import { defaultIO } from '../helpers/io';
-import { getPluginSourcePath, isPluginInManifest, loadMarketplaceManifest } from '../helpers/marketplace';
+import {
+  getMarketplaceType,
+  getPluginSourcePath,
+  isPluginInManifest,
+  loadMarketplaceManifest,
+} from '../helpers/marketplace';
 import { formatSyncResult, syncPluginToCursor } from '../helpers/sync-strategy';
 
 const SyncOptionsSchema = z.object({
@@ -100,7 +105,9 @@ export async function sync(options: SyncOptions = {}): Promise<void> {
         continue;
       }
 
-      const manifest = !cmd.dryRun ? await loadMarketplaceManifest(marketplacePath) : null;
+      const manifest = !cmd.dryRun
+        ? await loadMarketplaceManifest(marketplacePath, getMarketplaceType(marketplaceName))
+        : null;
 
       if (!isPluginInManifest(pluginName, manifest)) {
         defaultIO.logError(`Plugin '${pluginName}' not found in marketplace.json for '${marketplaceName}'`);

src/config/loader.ts

@@ -85,8 +85,8 @@ export async function loadPluginsConfig(baseDir: string): Promise<PluginsConfig
     if (await isClaudeCodeInstalled()) {
       const claudeCodeMarketplaces = await readClaudeCodeMarketplaces();
 
-      for (const marketplace of claudeCodeMarketplaces) {
-        const prefixedName = `claude:${marketplace.name}`;
+      for (const [marketplaceName, marketplaceConfig] of Object.entries(claudeCodeMarketplaces)) {
+        const prefixedName = `claude:${marketplaceName}`;
 
         if (globalMarketplaces[prefixedName] || config.marketplaces[prefixedName] || localMarketplaces[prefixedName]) {
           console.warn(
@@ -95,7 +95,7 @@ export async function loadPluginsConfig(baseDir: string): Promise<PluginsConfig
           continue;
         }
 
-        claudeMarketplaces[prefixedName] = convertClaudeMarketplaceToAIPM(marketplace);
+        claudeMarketplaces[prefixedName] = convertClaudeMarketplaceToAIPM(marketplaceName, marketplaceConfig);
       }
     }
 

src/helpers/claude-code-config.ts

@@ -23,10 +23,33 @@ const ClaudeMarketplaceEntrySchema = z.object({
   enabled: z.boolean().optional(),
 });
 
-const ClaudeKnownMarketplacesSchema = z.object({
-  marketplaces: z.array(ClaudeMarketplaceEntrySchema),
+/**
+ * Schema for Claude Code's actual marketplace format (object with marketplace names as keys)
+ */
+const ClaudeMarketplaceObjectEntrySchema = z.object({
+  source: z
+    .object({
+      source: z.string(),
+      repo: z.string().optional(),
+      url: z.string().optional(),
+      branch: z.string().optional(),
+    })
+    .or(z.string())
+    .optional(),
+  installLocation: z.string().optional(),
+  lastUpdated: z.string().optional(),
+  path: z.string().optional(),
+  url: z.string().optional(),
+  branch: z.string().optional(),
+  enabled: z.boolean().optional(),
 });
 
+/**
+ * Schema for Claude Code's known_marketplaces.json
+ * Claude Code uses object format: { "marketplace-name": { ... } }
+ */
+const ClaudeKnownMarketplacesSchema = z.record(z.string(), ClaudeMarketplaceObjectEntrySchema);
+
 /**
  * Schema for Claude Code's installed_plugins.json
  */
@@ -53,6 +76,8 @@ const ClaudeCodeConfigSchema = z
   .loose();
 
 export type ClaudeMarketplaceEntry = z.infer<typeof ClaudeMarketplaceEntrySchema>;
+export type ClaudeMarketplaceObjectEntry = z.infer<typeof ClaudeMarketplaceObjectEntrySchema>;
+export type ClaudeKnownMarketplaces = z.infer<typeof ClaudeKnownMarketplacesSchema>;
 export type ClaudeInstalledPlugin = z.infer<typeof ClaudeInstalledPluginSchema>;
 export type ClaudeCodeConfig = z.infer<typeof ClaudeCodeConfigSchema>;
 
@@ -78,14 +103,15 @@ export async function isClaudeCodeInstalled(): Promise<boolean> {
 
 /**
  * Read Claude Code's known_marketplaces.json
+ * Returns Claude Code's format as-is: { "marketplace-name": { ... } }
  */
-export async function readClaudeCodeMarketplaces(): Promise<ClaudeMarketplaceEntry[]> {
+export async function readClaudeCodeMarketplaces(): Promise<ClaudeKnownMarketplaces> {
   try {
     const claudePluginsDir = getClaudeCodePluginsDir();
     const marketplacesPath = join(claudePluginsDir, FILE_CLAUDE_KNOWN_MARKETPLACES);
 
     if (!(await fileExists(marketplacesPath))) {
-      return [];
+      return {};
     }
 
     const file = Bun.file(marketplacesPath);
@@ -95,18 +121,18 @@ export async function readClaudeCodeMarketplaces(): Promise<ClaudeMarketplaceEnt
     if (!result.success) {
       console.warn('\n⚠️  AIPM: Failed to parse Claude Code marketplaces');
       console.warn(`    File: ${marketplacesPath}`);
-      console.warn(`    Error: ${result.error.message}`);
+      console.warn(`    Error: ${JSON.stringify(result.error.issues, null, 2)}`);
       console.warn('    This might be due to a Claude Code format change.');
       console.warn('    Please report this at: https://github.com/TrogonStack/aipm/discussions/categories/buggy\n');
-      return [];
+      return {};
     }
 
-    return result.data.marketplaces;
+    return result.data;
   } catch (error) {
     console.warn('\n⚠️  AIPM: Failed to read Claude Code marketplaces');
     console.warn(`    Error: ${error}`);
     console.warn('    Please report this at: https://github.com/TrogonStack/aipm/discussions/categories/buggy\n');
-    return [];
+    return {};
   }
 }
 
@@ -180,34 +206,141 @@ export async function readClaudeCodeConfig(): Promise<ClaudeCodeConfig | null> {
 
 /**
  * Get the full path to a Claude Code marketplace
+ *
+ * Resolves relative paths relative to Claude Code's plugins directory.
+ * Returns absolute paths as-is (supports both POSIX and Windows paths).
+ * For git/url sources without a path, returns the expected cache location.
+ *
+ * @param marketplaceName - The name of the marketplace
+ * @param marketplaceConfig - The Claude Code marketplace configuration
+ * @returns The resolved absolute path to the marketplace
  */
-export function getClaudeCodeMarketplacePath(marketplace: ClaudeMarketplaceEntry): string {
+export function getClaudeCodeMarketplacePath(
+  marketplaceName: string,
+  marketplaceConfig: ClaudeMarketplaceObjectEntry,
+): string {
   const claudePluginsDir = getClaudeCodePluginsDir();
 
-  if (marketplace.source === 'directory' && marketplace.path) {
+  // Use installLocation or path if available
+  const marketplacePath = marketplaceConfig.installLocation || marketplaceConfig.path;
+  if (marketplacePath) {
     // Check if path is absolute on either Windows or POSIX systems
-    // This allows Claude Code configs to work cross-platform
-    if (path.isAbsolute(marketplace.path) || path.win32.isAbsolute(marketplace.path)) {
-      return marketplace.path;
+    if (path.isAbsolute(marketplacePath) || path.win32.isAbsolute(marketplacePath)) {
+      return marketplacePath;
     }
-    return join(claudePluginsDir, 'marketplaces', marketplace.path);
+    return join(claudePluginsDir, 'marketplaces', marketplacePath);
   }
 
   // For git/url sources, Claude Code caches them in the marketplaces directory
-  // This assumes Claude Code has already cloned/synced the marketplace
-  return join(claudePluginsDir, 'marketplaces', marketplace.name);
+  return join(claudePluginsDir, 'marketplaces', marketplaceName);
+}
+
+/**
+ * Extract source info from Claude Code marketplace config
+ * Validates and normalizes the source type
+ */
+function extractSourceInfo(source: ClaudeMarketplaceObjectEntry['source']): {
+  source: 'directory' | 'git' | 'url';
+  url?: string;
+  branch?: string;
+} {
+  if (!source) {
+    return { source: 'directory' };
+  }
+
+  if (typeof source === 'string') {
+    // Validate source type
+    if (source === 'directory' || source === 'git' || source === 'url') {
+      return { source };
+    }
+    // Default to directory for unknown string values
+    return { source: 'directory' };
+  }
+
+  // Handle nested source object
+  if (source.source === 'github' && source.repo) {
+    return {
+      source: 'git',
+      url: `https://github.com/${source.repo}.git`,
+      branch: source.branch,
+    };
+  }
+
+  if (source.url) {
+    const sourceType = source.url.startsWith('http') ? 'url' : 'git';
+    return {
+      source: sourceType,
+      url: source.url,
+      branch: source.branch,
+    };
+  }
+
+  return { source: 'directory' };
+}
+
+/**
+ * Determine path from Claude Code marketplace config
+ */
+function determinePath(config: ClaudeMarketplaceObjectEntry): string | undefined {
+  return config.installLocation || config.path;
+}
+
+/**
+ * Apply fallback URL/branch from top-level config if not already set
+ * Determines final source type based on available information
+ */
+function applyFallbackUrlBranch(
+  sourceInfo: ReturnType<typeof extractSourceInfo>,
+  config: ClaudeMarketplaceObjectEntry,
+) {
+  const url = sourceInfo.url || config.url;
+  const branch = sourceInfo.branch || config.branch;
+
+  // Determine source type: if we got URL from fallback and source was directory, infer from URL
+  const source =
+    !sourceInfo.url && url && sourceInfo.source === 'directory'
+      ? url.startsWith('http')
+        ? ('url' as const)
+        : ('git' as const)
+      : sourceInfo.source;
+
+  return { source, url, branch };
 }
 
 /**
  * Convert Claude Code marketplace to AIPM marketplace format
+ * Resolves paths relative to Claude Code's plugins directory
  */
-export function convertClaudeMarketplaceToAIPM(marketplace: ClaudeMarketplaceEntry) {
-  const path = getClaudeCodeMarketplacePath(marketplace);
+export function convertClaudeMarketplaceToAIPM(
+  marketplaceName: string,
+  marketplaceConfig: ClaudeMarketplaceObjectEntry,
+) {
+  // If installLocation exists, treat as directory (already cloned)
+  if (marketplaceConfig.installLocation) {
+    return {
+      source: 'directory',
+      path: marketplaceConfig.installLocation,
+    };
+  }
+
+  // Extract source info and apply fallbacks
+  const sourceInfo = extractSourceInfo(marketplaceConfig.source);
+  const path = determinePath(marketplaceConfig);
+  const finalSourceInfo = applyFallbackUrlBranch(sourceInfo, marketplaceConfig);
+
+  // Return AIPM format
+  if (finalSourceInfo.source === 'directory' && path) {
+    // Resolve path relative to Claude Code's plugins directory
+    const resolvedPath = getClaudeCodeMarketplacePath(marketplaceName, marketplaceConfig);
+    return {
+      source: 'directory',
+      path: resolvedPath,
+    };
+  }
 
   return {
-    source: marketplace.source,
-    url: marketplace.url,
-    path: marketplace.source === 'directory' ? path : undefined,
-    branch: marketplace.branch,
+    source: finalSourceInfo.source,
+    url: finalSourceInfo.url,
+    branch: finalSourceInfo.branch,
   };
 }