allagents 0.8.1 → 0.8.3

package/dist/index.js

@@ -22313,6 +22313,10 @@ var MarketplaceManifestSchema = exports_external.object({
   owner: ContactSchema.optional(),
   plugins: exports_external.array(MarketplacePluginEntrySchema)
 });
+var MarketplaceManifestLenientSchema = exports_external.object({
+  name: exports_external.string().optional(),
+  plugins: exports_external.array(exports_external.unknown())
+}).passthrough();
 
 // src/utils/marketplace-manifest-parser.ts
 var MANIFEST_PATH = ".claude-plugin/marketplace.json";
@@ -22342,17 +22346,79 @@ async function parseMarketplaceManifest(marketplacePath) {
       error: "Failed to parse marketplace.json as JSON: invalid syntax"
     };
   }
-  const result = MarketplaceManifestSchema.safeParse(json2);
-  if (!result.success) {
-    const issues = result.error.issues.map((i2) => `  ${i2.path.join(".")}: ${i2.message}`).join(`
-`);
+  const strictResult = MarketplaceManifestSchema.safeParse(json2);
+  if (strictResult.success) {
+    return { success: true, data: strictResult.data, warnings: [] };
+  }
+  return parseLeniently(json2);
+}
+function parseLeniently(json2) {
+  const lenientResult = MarketplaceManifestLenientSchema.safeParse(json2);
+  if (!lenientResult.success) {
     return {
       success: false,
-      error: `Marketplace manifest validation failed:
-${issues}`
+      error: 'Marketplace manifest must contain a "plugins" array'
     };
   }
-  return { success: true, data: result.data };
+  const raw = lenientResult.data;
+  const warnings = [];
+  const obj = json2;
+  const validPlugins = [];
+  for (let i2 = 0;i2 < raw.plugins.length; i2++) {
+    const entry = raw.plugins[i2];
+    const entryResult = MarketplacePluginEntrySchema.safeParse(entry);
+    if (entryResult.success) {
+      validPlugins.push(entryResult.data);
+      continue;
+    }
+    const extracted = extractPluginEntry(entry, i2, warnings);
+    if (extracted) {
+      validPlugins.push(extracted);
+    }
+  }
+  const data = {
+    name: typeof raw.name === "string" ? raw.name : "unknown",
+    description: typeof obj.description === "string" ? obj.description : "",
+    plugins: validPlugins
+  };
+  return { success: true, data, warnings };
+}
+function extractPluginEntry(entry, index, warnings) {
+  if (!entry || typeof entry !== "object") {
+    warnings.push(`plugins[${index}]: not an object, skipped`);
+    return null;
+  }
+  const obj = entry;
+  const name = typeof obj.name === "string" && obj.name ? obj.name : undefined;
+  if (!name) {
+    warnings.push(`plugins[${index}]: missing "name" field, skipped`);
+    return null;
+  }
+  let description = "";
+  if (typeof obj.description === "string" && obj.description) {
+    description = obj.description;
+  } else if (obj.metadata && typeof obj.metadata === "object" && typeof obj.metadata.description === "string") {
+    description = obj.metadata.description;
+    warnings.push(`plugins[${index}] ("${name}"): "description" found in metadata instead of top level`);
+  } else {
+    warnings.push(`plugins[${index}] ("${name}"): missing "description" field`);
+  }
+  let source = "";
+  if (typeof obj.source === "string") {
+    source = obj.source;
+  } else if (obj.source && typeof obj.source === "object" && obj.source.source === "url" && typeof obj.source.url === "string") {
+    source = obj.source;
+  } else {
+    warnings.push(`plugins[${index}] ("${name}"): missing or invalid "source" field`);
+  }
+  return {
+    name,
+    description,
+    source,
+    ...typeof obj.version === "string" && { version: obj.version },
+    ...typeof obj.category === "string" && { category: obj.category },
+    ...typeof obj.homepage === "string" && { homepage: obj.homepage }
+  };
 }
 function resolvePluginSourcePath(source, marketplacePath) {
   if (typeof source === "object") {
@@ -22599,9 +22665,9 @@ async function updateMarketplace(name) {
 async function getMarketplacePluginsFromManifest(marketplacePath) {
   const result = await parseMarketplaceManifest(marketplacePath);
   if (!result.success) {
-    return [];
+    return { plugins: [], warnings: [] };
   }
-  return result.data.plugins.map((plugin) => {
+  const plugins = result.data.plugins.map((plugin) => {
     const resolvedSource = resolvePluginSourcePath(plugin.source, marketplacePath);
     const info = {
       name: plugin.name,
@@ -22615,28 +22681,30 @@ async function getMarketplacePluginsFromManifest(marketplacePath) {
       info.homepage = plugin.homepage;
     return info;
   });
+  return { plugins, warnings: result.warnings };
 }
 async function listMarketplacePlugins(name) {
   const marketplace = await getMarketplace(name);
   if (!marketplace) {
-    return [];
+    return { plugins: [], warnings: [] };
   }
-  const manifestPlugins = await getMarketplacePluginsFromManifest(marketplace.path);
-  if (manifestPlugins.length > 0) {
-    return manifestPlugins;
+  const manifestResult = await getMarketplacePluginsFromManifest(marketplace.path);
+  if (manifestResult.plugins.length > 0) {
+    return manifestResult;
   }
   const pluginsDir = join6(marketplace.path, "plugins");
   if (!existsSync5(pluginsDir)) {
-    return [];
+    return { plugins: [], warnings: manifestResult.warnings };
   }
   try {
     const entries = await readdir3(pluginsDir, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory()).map((e) => ({
+    const plugins = entries.filter((e) => e.isDirectory()).map((e) => ({
       name: e.name,
       path: join6(pluginsDir, e.name)
     })).sort((a, b) => a.name.localeCompare(b.name));
+    return { plugins, warnings: manifestResult.warnings };
   } catch {
-    return [];
+    return { plugins: [], warnings: manifestResult.warnings };
   }
 }
 function parsePluginSpec(spec) {
@@ -22675,26 +22743,42 @@ async function resolvePluginSpec(spec, options2 = {}) {
     return null;
   }
   const marketplaceName = options2.marketplaceNameOverride ?? parsed.marketplaceName;
-  const marketplace = await getMarketplace(marketplaceName);
-  if (!marketplace) {
-    return null;
+  let marketplacePath = options2.marketplacePathOverride ?? null;
+  if (!marketplacePath) {
+    const marketplace = await getMarketplace(marketplaceName);
+    if (!marketplace) {
+      return null;
+    }
+    marketplacePath = marketplace.path;
   }
-  const manifestResult = await parseMarketplaceManifest(marketplace.path);
+  const manifestResult = await parseMarketplaceManifest(marketplacePath);
   if (manifestResult.success) {
     const pluginEntry = manifestResult.data.plugins.find((p) => p.name === parsed.plugin);
     if (pluginEntry) {
-      const resolvedSource = typeof pluginEntry.source === "string" ? resolve4(marketplace.path, pluginEntry.source) : pluginEntry.source.url;
-      if (typeof resolvedSource === "string" && existsSync5(resolvedSource)) {
-        return {
-          path: resolvedSource,
-          marketplace: marketplaceName,
-          plugin: parsed.plugin
-        };
+      if (typeof pluginEntry.source === "string") {
+        const resolvedPath = resolve4(marketplacePath, pluginEntry.source);
+        if (existsSync5(resolvedPath)) {
+          return {
+            path: resolvedPath,
+            marketplace: marketplaceName,
+            plugin: parsed.plugin
+          };
+        }
+      } else {
+        const fetchFn = options2.fetchFn ?? fetchPlugin;
+        const fetchResult = await fetchFn(pluginEntry.source.url);
+        if (fetchResult.success && fetchResult.cachePath) {
+          return {
+            path: fetchResult.cachePath,
+            marketplace: marketplaceName,
+            plugin: parsed.plugin
+          };
+        }
       }
     }
   }
   const subpath = options2.subpath ?? parsed.subpath ?? "plugins";
-  const pluginPath = join6(marketplace.path, subpath, parsed.plugin);
+  const pluginPath = join6(marketplacePath, subpath, parsed.plugin);
   if (!existsSync5(pluginPath)) {
     return null;
   }
@@ -24765,28 +24849,42 @@ var pluginListCmd = import_cmd_ts2.command({
       }
       if (isJsonMode()) {
         const allPlugins = [];
+        const allWarnings = [];
         for (const mp of toList) {
-          const plugins = await listMarketplacePlugins(mp.name);
-          for (const plugin of plugins) {
+          const result = await listMarketplacePlugins(mp.name);
+          for (const plugin of result.plugins) {
             allPlugins.push({ name: plugin.name, marketplace: mp.name });
           }
+          for (const warning of result.warnings) {
+            allWarnings.push(`${mp.name}: ${warning}`);
+          }
         }
         jsonOutput({
           success: true,
           command: "plugin list",
-          data: { plugins: allPlugins, total: allPlugins.length }
+          data: {
+            plugins: allPlugins,
+            total: allPlugins.length,
+            ...allWarnings.length > 0 && { warnings: allWarnings }
+          }
         });
         return;
       }
       let totalPlugins = 0;
       for (const mp of toList) {
-        const plugins = await listMarketplacePlugins(mp.name);
-        if (plugins.length === 0) {
+        const result = await listMarketplacePlugins(mp.name);
+        if (result.plugins.length === 0 && result.warnings.length === 0) {
           console.log(`${mp.name}: (no plugins found)`);
           continue;
         }
         console.log(`${mp.name}:`);
-        for (const plugin of plugins) {
+        for (const warning of result.warnings) {
+          console.log(`  Warning: ${warning}`);
+        }
+        if (result.plugins.length === 0) {
+          console.log("  (no plugins found)");
+        }
+        for (const plugin of result.plugins) {
           console.log(`  - ${plugin.name}@${mp.name}`);
           totalPlugins++;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allagents",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
   "type": "module",
   "bin": {