fix: claude code marketplace schema

Author: yordis

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/helpers/claude-code-config.ts

@@ -23,10 +23,39 @@ 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 that accepts both formats:
+ * 1. Array format: { marketplaces: [...] }
+ * 2. Object format: { "marketplace-name": { ... } }
+ */
+const ClaudeKnownMarketplacesSchema = z.union([
+  z.object({
+    marketplaces: z.array(ClaudeMarketplaceEntrySchema),
+  }),
+  z.record(z.string(), ClaudeMarketplaceObjectEntrySchema),
+]);
+
 /**
  * Schema for Claude Code's installed_plugins.json
  */
@@ -76,6 +105,78 @@ export async function isClaudeCodeInstalled(): Promise<boolean> {
   }
 }
 
+/**
+ * Normalize Claude Code marketplace data to our standard format
+ */
+function normalizeClaudeMarketplaces(data: z.infer<typeof ClaudeKnownMarketplacesSchema>): ClaudeMarketplaceEntry[] {
+  // Handle array format: { marketplaces: [...] }
+  if ('marketplaces' in data && Array.isArray(data.marketplaces)) {
+    return data.marketplaces;
+  }
+
+  // Handle object format: { "marketplace-name": { ... } }
+  const entries: ClaudeMarketplaceEntry[] = [];
+  const objectData = data as Record<string, z.infer<typeof ClaudeMarketplaceObjectEntrySchema>>;
+
+  for (const [name, config] of Object.entries(objectData)) {
+    // Determine source type
+    let source: 'directory' | 'git' | 'url' = 'directory';
+    let url: string | undefined;
+    let branch: string | undefined;
+    let path: string | undefined;
+
+    if (config.source) {
+      if (typeof config.source === 'string') {
+        source = config.source as 'directory' | 'git' | 'url';
+      } else if (typeof config.source === 'object') {
+        if (config.source.source === 'github' && config.source.repo) {
+          source = 'git';
+          url = `https://github.com/${config.source.repo}.git`;
+          branch = config.source.branch;
+        } else if (config.source.url) {
+          source = config.source.url.startsWith('http') ? 'url' : 'git';
+          url = config.source.url;
+          branch = config.source.branch;
+        }
+      }
+    }
+
+    // Use installLocation or path if available
+    if (config.installLocation) {
+      path = config.installLocation;
+      // If installLocation exists, Claude Code has already cloned/synced the marketplace
+      // So we should treat it as a directory source, not git/url
+      source = 'directory';
+    } else if (config.path) {
+      path = config.path;
+    }
+
+    // Fallback to url/branch from top level if not set (only if we don't have installLocation)
+    if (!path) {
+      if (!url && config.url) {
+        url = config.url;
+        if (source === 'directory') {
+          source = url.startsWith('http') ? 'url' : 'git';
+        }
+      }
+      if (!branch && config.branch) {
+        branch = config.branch;
+      }
+    }
+
+    entries.push({
+      name,
+      source,
+      path,
+      url,
+      branch,
+      enabled: config.enabled,
+    });
+  }
+
+  return entries;
+}
+
 /**
  * Read Claude Code's known_marketplaces.json
  */
@@ -95,13 +196,13 @@ 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 result.data.marketplaces;
+    return normalizeClaudeMarketplaces(result.data);
   } catch (error) {
     console.warn('\n⚠️  AIPM: Failed to read Claude Code marketplaces');
     console.warn(`    Error: ${error}`);
@@ -202,12 +303,20 @@ export function getClaudeCodeMarketplacePath(marketplace: ClaudeMarketplaceEntry
  * Convert Claude Code marketplace to AIPM marketplace format
  */
 export function convertClaudeMarketplaceToAIPM(marketplace: ClaudeMarketplaceEntry) {
-  const path = getClaudeCodeMarketplacePath(marketplace);
+  // If it's a directory source, use the path directly
+  if (marketplace.source === 'directory' && marketplace.path) {
+    return {
+      source: 'directory',
+      path: marketplace.path,
+    };
+  }
 
+  // For git/url sources, return the source info
+  // Note: If installLocation was set, we already converted it to directory above
   return {
     source: marketplace.source,
     url: marketplace.url,
-    path: marketplace.source === 'directory' ? path : undefined,
+    path: undefined,
     branch: marketplace.branch,
   };
 }

src/helpers/git.ts

@@ -1,4 +1,5 @@
 import { rm, writeFile } from 'node:fs/promises';
+import * as path from 'node:path';
 import { join } from 'node:path';
 import { DIR_CACHE } from '../constants';
 import type { MarketplaceSource } from '../schema';
@@ -17,8 +18,12 @@ export async function resolveMarketplacePath(
       if (!marketplace.path) {
         return null;
       }
-      const path = join(cwd, marketplace.path);
-      return path;
+      // If path is absolute, use it directly; otherwise join with cwd
+      if (path.isAbsolute(marketplace.path) || path.win32.isAbsolute(marketplace.path)) {
+        return marketplace.path;
+      }
+      const resolvedPath = join(cwd, marketplace.path);
+      return resolvedPath;
     }
 
     case 'git': {

src/helpers/marketplace.ts

@@ -1,21 +1,83 @@
 import { readdir, realpath } from 'node:fs/promises';
 import { join, relative, sep } from 'node:path';
 import { DIR_CLAUDE_PLUGIN, FILE_MARKETPLACE_MANIFEST } from '../constants';
-import type { MarketplaceManifest } from '../schema';
+import { isNodeError } from '../errors';
+import type { MarketplaceManifest, MarketplaceType } from '../schema';
 import { MarketplaceManifestSchema } from '../schema';
-import { fileExists, readJsonFile } from './fs';
+import { fileExists, JsonFileError, readJsonFile } from './fs';
+
+/**
+ * Determines the marketplace type based on the marketplace name.
+ * Claude Code marketplaces are prefixed with 'claude:'.
+ */
+export function getMarketplaceType(marketplaceName: string): MarketplaceType {
+  return marketplaceName.startsWith('claude:') ? 'claude' : 'aipm';
+}
 
-export async function loadMarketplaceManifest(marketplacePath: string): Promise<MarketplaceManifest | null> {
+export async function loadAipmMarketplaceManifest(marketplacePath: string): Promise<MarketplaceManifest | null> {
   const manifestPath = join(marketplacePath, FILE_MARKETPLACE_MANIFEST);
 
   try {
-    const manifest = await readJsonFile(manifestPath, MarketplaceManifestSchema);
-    return manifest;
-  } catch (_error) {
+    return await readJsonFile(manifestPath, MarketplaceManifestSchema);
+  } catch (error) {
+    // Handle missing file gracefully
+    if (isNodeError(error) && error.code === 'ENOENT') {
+      return null;
+    }
+
+    // Handle JSON parsing/validation errors
+    if (error instanceof JsonFileError) {
+      console.warn('\n⚠️  AIPM: Failed to parse marketplace manifest');
+      console.warn(`    File: ${manifestPath}`);
+      if (error.cause && typeof error.cause === 'object' && 'issues' in error.cause) {
+        console.warn(`    Error: ${JSON.stringify(error.cause.issues, null, 2)}`);
+      } else if (error.cause) {
+        console.warn(`    Error: ${JSON.stringify(error.cause, null, 2)}`);
+      }
+      console.warn('    This might be due to a corrupted or invalid manifest file.');
+      console.warn('    Please report this at: https://github.com/TrogonStack/aipm/discussions/categories/buggy\n');
+    }
     return null;
   }
 }
 
+export async function loadClaudeCodeMarketplaceManifest(marketplacePath: string): Promise<MarketplaceManifest | null> {
+  const claudePluginManifestPath = join(marketplacePath, DIR_CLAUDE_PLUGIN, FILE_MARKETPLACE_MANIFEST);
+
+  try {
+    return await readJsonFile(claudePluginManifestPath, MarketplaceManifestSchema);
+  } catch (error) {
+    // Handle missing file gracefully
+    if (isNodeError(error) && error.code === 'ENOENT') {
+      return null;
+    }
+
+    // Handle JSON parsing/validation errors
+    if (error instanceof JsonFileError) {
+      console.warn('\n⚠️  AIPM: Failed to parse Claude Code marketplace manifest');
+      console.warn(`    File: ${claudePluginManifestPath}`);
+      if (error.cause && typeof error.cause === 'object' && 'issues' in error.cause) {
+        console.warn(`    Error: ${JSON.stringify(error.cause.issues, null, 2)}`);
+      } else if (error.cause) {
+        console.warn(`    Error: ${JSON.stringify(error.cause, null, 2)}`);
+      }
+      console.warn('    This might be due to a corrupted or invalid manifest file.');
+      console.warn('    Please report this at: https://github.com/TrogonStack/aipm/discussions/categories/buggy\n');
+    }
+    return null;
+  }
+}
+
+export async function loadMarketplaceManifest(
+  marketplacePath: string,
+  marketplaceType: MarketplaceType,
+): Promise<MarketplaceManifest | null> {
+  if (marketplaceType === 'claude') {
+    return await loadClaudeCodeMarketplaceManifest(marketplacePath);
+  }
+  return await loadAipmMarketplaceManifest(marketplacePath);
+}
+
 export async function fetchRemoteMarketplaceManifest(url: string): Promise<MarketplaceManifest> {
   const response = await fetch(url);
 

src/schema.ts

@@ -8,6 +8,8 @@ export const MarketplaceSourceSchema = z.object({
   branch: z.string().optional(),
 });
 
+export const MarketplaceTypeSchema = z.enum(['aipm', 'claude']);
+
 export const MarketplaceOwnerSchema = z.object({
   name: z.string(),
   email: z.string().optional(),
@@ -70,6 +72,7 @@ export const GlobalMarketplaceConfigSchema = z.object({
 });
 
 export type MarketplaceSource = z.infer<typeof MarketplaceSourceSchema>;
+export type MarketplaceType = z.infer<typeof MarketplaceTypeSchema>;
 export type MarketplaceMetadata = z.infer<typeof MarketplaceMetadataSchema>;
 export type MarketplaceOwner = z.infer<typeof MarketplaceOwnerSchema>;
 export type MarketplacePluginEntry = z.infer<typeof MarketplacePluginEntrySchema>;