capns 0.76.17552 → 0.77.17595

package/capns.js

@@ -3657,6 +3657,440 @@ class StdinSource {
   }
 }
 
+// =============================================================================
+// Plugin Repository System
+// =============================================================================
+
+/**
+ * Plugin capability summary from registry
+ */
+class PluginCapSummary {
+  constructor(urn, title, description = '') {
+    this.urn = urn;
+    this.title = title;
+    this.description = description;
+  }
+}
+
+/**
+ * Plugin information from registry
+ */
+class PluginInfo {
+  constructor(data) {
+    this.id = data.id;
+    this.name = data.name;
+    this.version = data.version || '';
+    this.description = data.description || '';
+    this.author = data.author || '';
+    this.pageUrl = data.pageUrl || '';
+    this.teamId = data.teamId || '';
+    this.signedAt = data.signedAt || '';
+    this.minAppVersion = data.minAppVersion || '';
+    this.caps = (data.caps || []).map(c => new PluginCapSummary(c.urn, c.title, c.description || ''));
+    this.categories = data.categories || [];
+    this.tags = data.tags || [];
+    this.changelog = data.changelog || {};
+    // Distribution fields
+    this.platform = data.platform || '';
+    this.packageName = data.packageName || '';
+    this.packageSha256 = data.packageSha256 || '';
+    this.packageSize = data.packageSize || 0;
+    this.binaryName = data.binaryName || '';
+    this.binarySha256 = data.binarySha256 || '';
+    this.binarySize = data.binarySize || 0;
+    this.availableVersions = data.availableVersions || [];
+  }
+
+  /**
+   * Check if plugin is signed (has team_id and signed_at)
+   */
+  isSigned() {
+    return this.teamId.length > 0 && this.signedAt.length > 0;
+  }
+
+  /**
+   * Check if binary download info is available
+   */
+  hasBinary() {
+    return this.binaryName.length > 0 && this.binarySha256.length > 0;
+  }
+}
+
+/**
+ * Plugin suggestion for a missing cap
+ */
+class PluginSuggestion {
+  constructor(data) {
+    this.pluginId = data.pluginId;
+    this.pluginName = data.pluginName;
+    this.pluginDescription = data.pluginDescription;
+    this.capUrn = data.capUrn;
+    this.capTitle = data.capTitle;
+    this.latestVersion = data.latestVersion;
+    this.repoUrl = data.repoUrl;
+    this.pageUrl = data.pageUrl;
+  }
+}
+
+/**
+ * Plugin registry cache entry
+ */
+class PluginRepoCache {
+  constructor(repoUrl) {
+    this.plugins = new Map(); // plugin_id -> PluginInfo
+    this.capToPlugins = new Map(); // cap_urn -> [plugin_ids]
+    this.lastUpdated = Date.now();
+    this.repoUrl = repoUrl;
+  }
+}
+
+/**
+ * Plugin repository client - fetches and caches plugin registry
+ */
+class PluginRepoClient {
+  constructor(cacheTtlSeconds = 3600) {
+    this.caches = new Map(); // repo_url -> PluginRepoCache
+    this.cacheTtl = cacheTtlSeconds * 1000; // Convert to milliseconds
+  }
+
+  /**
+   * Fetch registry from a URL
+   */
+  async fetchRegistry(repoUrl) {
+    const response = await fetch(repoUrl);
+
+    if (!response.ok) {
+      throw new Error(`Plugin registry request failed: HTTP ${response.status} from ${repoUrl}`);
+    }
+
+    const data = await response.json();
+
+    if (!data.plugins || !Array.isArray(data.plugins)) {
+      throw new Error(`Invalid plugin registry response from ${repoUrl}: missing plugins array`);
+    }
+
+    return data.plugins.map(p => new PluginInfo(p));
+  }
+
+  /**
+   * Update cache from registry data
+   */
+  updateCache(repoUrl, plugins) {
+    const cache = new PluginRepoCache(repoUrl);
+
+    for (const plugin of plugins) {
+      cache.plugins.set(plugin.id, plugin);
+
+      for (const cap of plugin.caps) {
+        if (!cache.capToPlugins.has(cap.urn)) {
+          cache.capToPlugins.set(cap.urn, []);
+        }
+        cache.capToPlugins.get(cap.urn).push(plugin.id);
+      }
+    }
+
+    this.caches.set(repoUrl, cache);
+  }
+
+  /**
+   * Check if cache is stale
+   */
+  isCacheStale(cache) {
+    return (Date.now() - cache.lastUpdated) > this.cacheTtl;
+  }
+
+  /**
+   * Sync plugin data from repository URLs
+   */
+  async syncRepos(repoUrls) {
+    for (const repoUrl of repoUrls) {
+      try {
+        const plugins = await this.fetchRegistry(repoUrl);
+        this.updateCache(repoUrl, plugins);
+      } catch (e) {
+        console.warn(`Failed to sync plugin repo ${repoUrl}: ${e.message}`);
+        // Continue with other repos
+      }
+    }
+  }
+
+  /**
+   * Check if any repo needs syncing
+   */
+  needsSync(repoUrls) {
+    for (const repoUrl of repoUrls) {
+      const cache = this.caches.get(repoUrl);
+      if (!cache || this.isCacheStale(cache)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Get plugin suggestions for a cap URN
+   */
+  getSuggestionsForCap(capUrn) {
+    const suggestions = [];
+
+    for (const cache of this.caches.values()) {
+      const pluginIds = cache.capToPlugins.get(capUrn);
+      if (!pluginIds) continue;
+
+      for (const pluginId of pluginIds) {
+        const plugin = cache.plugins.get(pluginId);
+        if (!plugin) continue;
+
+        const capInfo = plugin.caps.find(c => c.urn === capUrn);
+        if (!capInfo) continue;
+
+        const pageUrl = plugin.pageUrl || cache.repoUrl;
+
+        suggestions.push(new PluginSuggestion({
+          pluginId: plugin.id,
+          pluginName: plugin.name,
+          pluginDescription: plugin.description,
+          capUrn: capUrn,
+          capTitle: capInfo.title,
+          latestVersion: plugin.version,
+          repoUrl: cache.repoUrl,
+          pageUrl: pageUrl
+        }));
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Get all available plugins from all repos
+   */
+  getAllPlugins() {
+    const plugins = [];
+    for (const cache of this.caches.values()) {
+      for (const [pluginId, pluginInfo] of cache.plugins) {
+        plugins.push([pluginId, pluginInfo]);
+      }
+    }
+    return plugins;
+  }
+
+  /**
+   * Get all available cap URNs from plugins
+   */
+  getAllAvailableCaps() {
+    const caps = new Set();
+    for (const cache of this.caches.values()) {
+      for (const capUrn of cache.capToPlugins.keys()) {
+        caps.add(capUrn);
+      }
+    }
+    return Array.from(caps).sort();
+  }
+
+  /**
+   * Get plugin info by ID
+   */
+  getPlugin(pluginId) {
+    for (const cache of this.caches.values()) {
+      const plugin = cache.plugins.get(pluginId);
+      if (plugin) {
+        return plugin;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get suggestions for missing caps
+   */
+  getSuggestionsForMissingCaps(availableCaps, requestedCaps) {
+    const availableSet = new Set(availableCaps);
+    const suggestions = [];
+
+    for (const capUrn of requestedCaps) {
+      if (!availableSet.has(capUrn)) {
+        suggestions.push(...this.getSuggestionsForCap(capUrn));
+      }
+    }
+
+    return suggestions;
+  }
+}
+
+/**
+ * Plugin repository server - serves registry data with queries
+ */
+class PluginRepoServer {
+  constructor(registry) {
+    this.registry = registry;
+    this.validateRegistry();
+  }
+
+  /**
+   * Validate registry schema
+   */
+  validateRegistry() {
+    if (!this.registry) {
+      throw new Error('Registry is required');
+    }
+    if (this.registry.schemaVersion !== '3.0') {
+      throw new Error(`Unsupported registry schema version: ${this.registry.schemaVersion}. Required: 3.0`);
+    }
+    if (!this.registry.plugins || typeof this.registry.plugins !== 'object') {
+      throw new Error('Registry must have plugins object');
+    }
+  }
+
+  /**
+   * Validate version data has all required fields
+   */
+  validateVersionData(id, version, versionData) {
+    if (!versionData.platform) {
+      throw new Error(`Plugin ${id} v${version}: missing required field 'platform'`);
+    }
+    if (!versionData.package || !versionData.package.name) {
+      throw new Error(`Plugin ${id} v${version}: missing required field 'package'`);
+    }
+    if (!versionData.binary || !versionData.binary.name) {
+      throw new Error(`Plugin ${id} v${version}: missing required field 'binary'`);
+    }
+  }
+
+  /**
+   * Compare version strings
+   */
+  compareVersions(a, b) {
+    const partsA = a.split('.').map(x => parseInt(x) || 0);
+    const partsB = b.split('.').map(x => parseInt(x) || 0);
+
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+      const numA = partsA[i] || 0;
+      const numB = partsB[i] || 0;
+      if (numA !== numB) {
+        return numA - numB;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * Build changelog map from versions
+   */
+  buildChangelogMap(versions) {
+    const changelog = {};
+    for (const [version, versionData] of Object.entries(versions)) {
+      if (versionData.changelog && Array.isArray(versionData.changelog)) {
+        changelog[version] = versionData.changelog;
+      }
+    }
+    return changelog;
+  }
+
+  /**
+   * Transform registry to flat plugin array
+   */
+  transformToPluginArray() {
+    const pluginsObject = this.registry.plugins || {};
+    const plugins = [];
+
+    for (const [id, plugin] of Object.entries(pluginsObject)) {
+      const latestVersion = plugin.latestVersion;
+      const versionData = plugin.versions[latestVersion];
+
+      if (!versionData) {
+        throw new Error(`Plugin ${id}: latest version ${latestVersion} not found in versions`);
+      }
+
+      // Validate required fields - fail hard
+      this.validateVersionData(id, latestVersion, versionData);
+
+      // Get all version numbers sorted descending
+      const availableVersions = Object.keys(plugin.versions).sort((a, b) => {
+        return this.compareVersions(b, a);
+      });
+
+      // Build flat plugin object with latest version data
+      const packageUrl = `https://filegrind.com/plugins/packages/${versionData.package.name}`;
+      plugins.push({
+        id,
+        name: plugin.name,
+        version: latestVersion,
+        description: plugin.description,
+        author: plugin.author,
+        pageUrl: plugin.pageUrl || packageUrl,
+        teamId: plugin.teamId,
+        signedAt: versionData.releaseDate,
+        minAppVersion: versionData.minAppVersion || plugin.minAppVersion,
+        caps: plugin.caps || [],
+        categories: plugin.categories,
+        tags: plugin.tags,
+        changelog: this.buildChangelogMap(plugin.versions),
+        // Distribution fields - ALL REQUIRED
+        platform: versionData.platform,
+        packageName: versionData.package.name,
+        packageSha256: versionData.package.sha256,
+        packageSize: versionData.package.size,
+        binaryName: versionData.binary.name,
+        binarySha256: versionData.binary.sha256,
+        binarySize: versionData.binary.size,
+        // All available versions
+        availableVersions
+      });
+    }
+
+    return plugins;
+  }
+
+  /**
+   * Get all plugins (API response format)
+   */
+  getPlugins() {
+    return {
+      plugins: this.transformToPluginArray()
+    };
+  }
+
+  /**
+   * Get plugin by ID
+   */
+  getPluginById(id) {
+    const plugins = this.transformToPluginArray();
+    return plugins.find(p => p.id === id);
+  }
+
+  /**
+   * Search plugins by query
+   */
+  searchPlugins(query) {
+    const plugins = this.transformToPluginArray();
+    const lowerQuery = query.toLowerCase();
+
+    return plugins.filter(p =>
+      p.name.toLowerCase().includes(lowerQuery) ||
+      p.description.toLowerCase().includes(lowerQuery) ||
+      p.tags.some(t => t.toLowerCase().includes(lowerQuery)) ||
+      p.caps.some(c => c.urn.toLowerCase().includes(lowerQuery) || c.title.toLowerCase().includes(lowerQuery))
+    );
+  }
+
+  /**
+   * Get plugins by category
+   */
+  getPluginsByCategory(category) {
+    const plugins = this.transformToPluginArray();
+    return plugins.filter(p => p.categories.includes(category));
+  }
+
+  /**
+   * Get plugins that provide a specific cap
+   */
+  getPluginsByCap(capUrn) {
+    const plugins = this.transformToPluginArray();
+    return plugins.filter(p => p.caps.some(c => c.urn === capUrn));
+  }
+}
+
 // Export for CommonJS
 module.exports = {
   CapUrn,
@@ -3756,5 +4190,12 @@ module.exports = {
   CapGraphStats,
   CapGraph,
   StdinSource,
-  StdinSourceKind
+  StdinSourceKind,
+  // Plugin Repository
+  PluginCapSummary,
+  PluginInfo,
+  PluginSuggestion,
+  PluginRepoCache,
+  PluginRepoClient,
+  PluginRepoServer
 };

package/capns.test.js

@@ -8,6 +8,7 @@ const {
   Cap, MediaSpec, MediaSpecError, MediaSpecErrorCodes,
   resolveMediaUrn, buildExtensionIndex, mediaUrnsForExtension, getExtensionMappings,
   CapMatrixError, CapMatrix, BestCapSetMatch, CompositeCapSet, CapBlock,
+  PluginInfo, PluginCapSummary, PluginSuggestion, PluginRepoClient, PluginRepoServer,
   CapGraphEdge, CapGraphStats, CapGraph,
   StdinSource, StdinSourceKind,
   validateNoMediaSpecRedefinitionSync,
@@ -1903,6 +1904,361 @@ function testJS_mediaSpecConstruction() {
   assertEqual(spec2.profile, null, 'Should have null profile');
 }
 
+// =============================================================================
+// Plugin Repository Tests (TEST320-TEST335)
+// =============================================================================
+
+// Sample registry for testing
+const sampleRegistry = {
+  schemaVersion: '3.0',
+  lastUpdated: '2026-02-07T16:48:28Z',
+  plugins: {
+    pdfcartridge: {
+      name: 'pdfcartridge',
+      description: 'PDF document processor',
+      author: 'test-author',
+      pageUrl: 'https://example.com/pdf',
+      teamId: 'P336JK947M',
+      minAppVersion: '1.0.0',
+      categories: ['document'],
+      tags: ['pdf', 'extractor'],
+      caps: [
+        {
+          urn: 'cap:in="media:pdf;bytes";op=disbind;out="media:disbound-page;textable;form=list"',
+          title: 'Disbind PDF',
+          description: 'Extract pages'
+        },
+        {
+          urn: 'cap:in="media:pdf;bytes";op=extract_metadata;out="media:file-metadata;textable;form=map"',
+          title: 'Extract Metadata',
+          description: 'Get PDF metadata'
+        }
+      ],
+      latestVersion: '0.81.5325',
+      versions: {
+        '0.81.5325': {
+          releaseDate: '2026-02-07T16:40:28Z',
+          changelog: ['Initial release'],
+          minAppVersion: '1.0.0',
+          platform: 'darwin-arm64',
+          package: {
+            name: 'pdfcartridge-0.81.5325.pkg',
+            sha256: '9b68724eb9220ecf01e8ed4f5f80c594fbac2239bc5bf675005ec882ecc5eba0',
+            size: 5187485
+          },
+          binary: {
+            name: 'pdfcartridge-0.81.5325-darwin-arm64',
+            sha256: '908187ec35632758f1a00452ff4755ba01020ea288619098b6998d5d33851d19',
+            size: 12980288
+          }
+        }
+      }
+    },
+    txtcartridge: {
+      name: 'txtcartridge',
+      description: 'Text file processor',
+      author: 'test-author',
+      pageUrl: 'https://example.com/txt',
+      teamId: 'P336JK947M',
+      minAppVersion: '1.0.0',
+      categories: ['text'],
+      tags: ['txt', 'text'],
+      caps: [
+        {
+          urn: 'cap:in="media:txt;textable";op=disbind;out="media:disbound-page;textable;form=list"',
+          title: 'Disbind Text',
+          description: 'Extract text pages'
+        }
+      ],
+      latestVersion: '0.54.6408',
+      versions: {
+        '0.54.6408': {
+          releaseDate: '2026-02-07T17:44:00Z',
+          changelog: ['First version'],
+          minAppVersion: '1.0.0',
+          platform: 'darwin-arm64',
+          package: {
+            name: 'txtcartridge-0.54.6408.pkg',
+            sha256: 'abc123',
+            size: 821000
+          },
+          binary: {
+            name: 'txtcartridge-0.54.6408-darwin-arm64',
+            sha256: 'def456',
+            size: 1700000
+          }
+        }
+      }
+    }
+  }
+};
+
+// TEST320: Plugin info construction
+function test320_pluginInfoConstruction() {
+  const data = {
+    id: 'testplugin',
+    name: 'Test Plugin',
+    version: '1.0.0',
+    description: 'A test',
+    teamId: 'TEAM123',
+    signedAt: '2026-01-01',
+    binaryName: 'test-binary',
+    binarySha256: 'abc123',
+    caps: [{urn: 'cap:in="media:void";op=test;out="media:void"', title: 'Test', description: ''}]
+  };
+  const plugin = new PluginInfo(data);
+  assert(plugin.id === 'testplugin', 'ID should match');
+  assert(plugin.teamId === 'TEAM123', 'Team ID should match');
+  assert(plugin.caps.length === 1, 'Should have 1 cap');
+  assert(plugin.caps[0].urn === 'cap:in="media:void";op=test;out="media:void"', 'Cap URN should match');
+}
+
+// TEST321: Plugin info is signed check
+function test321_pluginInfoIsSigned() {
+  const signed = new PluginInfo({id: 'test', teamId: 'TEAM', signedAt: '2026-01-01', caps: []});
+  assert(signed.isSigned() === true, 'Plugin with teamId and signedAt should be signed');
+
+  const unsigned1 = new PluginInfo({id: 'test', teamId: '', signedAt: '2026-01-01', caps: []});
+  assert(unsigned1.isSigned() === false, 'Plugin without teamId should not be signed');
+
+  const unsigned2 = new PluginInfo({id: 'test', teamId: 'TEAM', signedAt: '', caps: []});
+  assert(unsigned2.isSigned() === false, 'Plugin without signedAt should not be signed');
+}
+
+// TEST322: Plugin info has binary check
+function test322_pluginInfoHasBinary() {
+  const withBinary = new PluginInfo({id: 'test', binaryName: 'test-bin', binarySha256: 'abc', caps: []});
+  assert(withBinary.hasBinary() === true, 'Plugin with binary info should return true');
+
+  const noBinary1 = new PluginInfo({id: 'test', binaryName: '', binarySha256: 'abc', caps: []});
+  assert(noBinary1.hasBinary() === false, 'Plugin without binaryName should return false');
+
+  const noBinary2 = new PluginInfo({id: 'test', binaryName: 'test', binarySha256: '', caps: []});
+  assert(noBinary2.hasBinary() === false, 'Plugin without binarySha256 should return false');
+}
+
+// TEST323: PluginRepoServer validate registry
+function test323_pluginRepoServerValidateRegistry() {
+  // Valid registry
+  const server = new PluginRepoServer(sampleRegistry);
+  assert(server.registry.schemaVersion === '3.0', 'Should accept valid registry');
+
+  // Invalid schema version
+  let threw = false;
+  try {
+    new PluginRepoServer({schemaVersion: '2.0', plugins: {}});
+  } catch (e) {
+    threw = true;
+    assert(e.message.includes('schema version'), 'Should reject wrong schema version');
+  }
+  assert(threw, 'Should throw for invalid schema');
+
+  // Missing plugins
+  threw = false;
+  try {
+    new PluginRepoServer({schemaVersion: '3.0'});
+  } catch (e) {
+    threw = true;
+    assert(e.message.includes('plugins'), 'Should reject missing plugins');
+  }
+  assert(threw, 'Should throw for missing plugins');
+}
+
+// TEST324: PluginRepoServer transform to array
+function test324_pluginRepoServerTransformToArray() {
+  const server = new PluginRepoServer(sampleRegistry);
+  const plugins = server.transformToPluginArray();
+
+  assert(Array.isArray(plugins), 'Should return array');
+  assert(plugins.length === 2, 'Should have 2 plugins');
+  
+  const pdf = plugins.find(p => p.id === 'pdfcartridge');
+  assert(pdf !== undefined, 'Should include pdfcartridge');
+  assert(pdf.version === '0.81.5325', 'Should have latest version');
+  assert(pdf.teamId === 'P336JK947M', 'Should have teamId');
+  assert(pdf.signedAt === '2026-02-07T16:40:28Z', 'Should have signedAt from releaseDate');
+  assert(pdf.binaryName === 'pdfcartridge-0.81.5325-darwin-arm64', 'Should have binary name');
+  assert(pdf.binarySha256 === '908187ec35632758f1a00452ff4755ba01020ea288619098b6998d5d33851d19', 'Should have SHA256');
+  assert(Array.isArray(pdf.caps), 'Should have caps array');
+  assert(pdf.caps.length === 2, 'Should have 2 caps');
+}
+
+// TEST325: PluginRepoServer get plugins
+function test325_pluginRepoServerGetPlugins() {
+  const server = new PluginRepoServer(sampleRegistry);
+  const response = server.getPlugins();
+
+  assert(response.plugins !== undefined, 'Should have plugins field');
+  assert(Array.isArray(response.plugins), 'Plugins should be array');
+  assert(response.plugins.length === 2, 'Should have 2 plugins');
+}
+
+// TEST326: PluginRepoServer get plugin by ID
+function test326_pluginRepoServerGetPluginById() {
+  const server = new PluginRepoServer(sampleRegistry);
+
+  const pdf = server.getPluginById('pdfcartridge');
+  assert(pdf !== undefined, 'Should find pdfcartridge');
+  assert(pdf.id === 'pdfcartridge', 'Should have correct ID');
+
+  const notFound = server.getPluginById('nonexistent');
+  assert(notFound === undefined, 'Should return undefined for missing plugin');
+}
+
+// TEST327: PluginRepoServer search plugins
+function test327_pluginRepoServerSearchPlugins() {
+  const server = new PluginRepoServer(sampleRegistry);
+
+  const pdfResults = server.searchPlugins('pdf');
+  assert(pdfResults.length === 1, 'Should find 1 PDF plugin');
+  assert(pdfResults[0].id === 'pdfcartridge', 'Should find pdfcartridge');
+
+  const metadataResults = server.searchPlugins('metadata');
+  assert(metadataResults.length === 1, 'Should find plugin by cap title');
+
+  const noResults = server.searchPlugins('nonexistent');
+  assert(noResults.length === 0, 'Should return empty for no matches');
+}
+
+// TEST328: PluginRepoServer get by category
+function test328_pluginRepoServerGetByCategory() {
+  const server = new PluginRepoServer(sampleRegistry);
+
+  const docPlugins = server.getPluginsByCategory('document');
+  assert(docPlugins.length === 1, 'Should find 1 document plugin');
+  assert(docPlugins[0].id === 'pdfcartridge', 'Should be pdfcartridge');
+
+  const textPlugins = server.getPluginsByCategory('text');
+  assert(textPlugins.length === 1, 'Should find 1 text plugin');
+  assert(textPlugins[0].id === 'txtcartridge', 'Should be txtcartridge');
+}
+
+// TEST329: PluginRepoServer get by cap
+function test329_pluginRepoServerGetByCap() {
+  const server = new PluginRepoServer(sampleRegistry);
+
+  const disbindCap = 'cap:in="media:pdf;bytes";op=disbind;out="media:disbound-page;textable;form=list"';
+  const plugins = server.getPluginsByCap(disbindCap);
+
+  assert(plugins.length === 1, 'Should find 1 plugin with this cap');
+  assert(plugins[0].id === 'pdfcartridge', 'Should be pdfcartridge');
+
+  const metadataCap = 'cap:in="media:pdf;bytes";op=extract_metadata;out="media:file-metadata;textable;form=map"';
+  const metadataPlugins = server.getPluginsByCap(metadataCap);
+  assert(metadataPlugins.length === 1, 'Should find metadata cap');
+}
+
+// TEST330: PluginRepoClient update cache
+function test330_pluginRepoClientUpdateCache() {
+  const client = new PluginRepoClient(3600);
+  const server = new PluginRepoServer(sampleRegistry);
+  const plugins = server.transformToPluginArray().map(p => new PluginInfo(p));
+
+  client.updateCache('https://example.com/api/plugins', plugins);
+
+  const cache = client.caches.get('https://example.com/api/plugins');
+  assert(cache !== undefined, 'Cache should exist');
+  assert(cache.plugins.size === 2, 'Should have 2 plugins in cache');
+  assert(cache.capToPlugins.size > 0, 'Should have cap mappings');
+}
+
+// TEST331: PluginRepoClient get suggestions
+function test331_pluginRepoClientGetSuggestions() {
+  const client = new PluginRepoClient(3600);
+  const server = new PluginRepoServer(sampleRegistry);
+  const plugins = server.transformToPluginArray().map(p => new PluginInfo(p));
+
+  client.updateCache('https://example.com/api/plugins', plugins);
+
+  const disbindCap = 'cap:in="media:pdf;bytes";op=disbind;out="media:disbound-page;textable;form=list"';
+  const suggestions = client.getSuggestionsForCap(disbindCap);
+
+  assert(suggestions.length === 1, 'Should find 1 suggestion');
+  assert(suggestions[0].pluginId === 'pdfcartridge', 'Should suggest pdfcartridge');
+  assert(suggestions[0].capUrn === disbindCap, 'Should have correct cap URN');
+  assert(suggestions[0].capTitle === 'Disbind PDF', 'Should have cap title');
+}
+
+// TEST332: PluginRepoClient get plugin
+function test332_pluginRepoClientGetPlugin() {
+  const client = new PluginRepoClient(3600);
+  const server = new PluginRepoServer(sampleRegistry);
+  const plugins = server.transformToPluginArray().map(p => new PluginInfo(p));
+
+  client.updateCache('https://example.com/api/plugins', plugins);
+
+  const plugin = client.getPlugin('pdfcartridge');
+  assert(plugin !== null, 'Should find plugin');
+  assert(plugin.id === 'pdfcartridge', 'Should have correct ID');
+
+  const notFound = client.getPlugin('nonexistent');
+  assert(notFound === null, 'Should return null for missing plugin');
+}
+
+// TEST333: PluginRepoClient get all caps
+function test333_pluginRepoClientGetAllCaps() {
+  const client = new PluginRepoClient(3600);
+  const server = new PluginRepoServer(sampleRegistry);
+  const plugins = server.transformToPluginArray().map(p => new PluginInfo(p));
+
+  client.updateCache('https://example.com/api/plugins', plugins);
+
+  const caps = client.getAllAvailableCaps();
+  assert(Array.isArray(caps), 'Should return array');
+  assert(caps.length === 3, 'Should have 3 unique caps');
+  assert(caps.every(c => typeof c === 'string'), 'All caps should be strings');
+}
+
+// TEST334: PluginRepoClient needs sync
+function test334_pluginRepoClientNeedsSync() {
+  const client = new PluginRepoClient(1); // 1 second TTL
+  const server = new PluginRepoServer(sampleRegistry);
+  const plugins = server.transformToPluginArray().map(p => new PluginInfo(p));
+
+  const urls = ['https://example.com/api/plugins'];
+
+  // Should need sync initially
+  assert(client.needsSync(urls) === true, 'Should need sync with empty cache');
+
+  // Update cache
+  client.updateCache(urls[0], plugins);
+
+  // Should not need sync immediately
+  assert(client.needsSync(urls) === false, 'Should not need sync right after update');
+
+  // Wait for cache to expire (1 second)
+  // Note: Can't test this synchronously, would need async test
+}
+
+// TEST335: PluginRepoServer and Client integration
+function test335_pluginRepoServerClientIntegration() {
+  // Server creates API response
+  const server = new PluginRepoServer(sampleRegistry);
+  const apiResponse = server.getPlugins();
+
+  // Client consumes API response
+  const client = new PluginRepoClient(3600);
+  const plugins = apiResponse.plugins.map(p => new PluginInfo(p));
+  client.updateCache('https://example.com/api/plugins', plugins);
+
+  // Client can find plugin
+  const plugin = client.getPlugin('pdfcartridge');
+  assert(plugin !== null, 'Client should find plugin from server data');
+  assert(plugin.isSigned(), 'Plugin should be signed');
+  assert(plugin.hasBinary(), 'Plugin should have binary');
+
+  // Client can get suggestions
+  const capUrn = 'cap:in="media:pdf;bytes";op=disbind;out="media:disbound-page;textable;form=list"';
+  const suggestions = client.getSuggestionsForCap(capUrn);
+  assert(suggestions.length === 1, 'Should get suggestions');
+  assert(suggestions[0].pluginId === 'pdfcartridge', 'Should suggest correct plugin');
+
+  // Server can search
+  const searchResults = server.searchPlugins('pdf');
+  assert(searchResults.length === 1, 'Server search should work');
+  assert(searchResults[0].id === plugin.id, 'Search and client should agree');
+}
+
 // ============================================================================
 // Test runner
 // ============================================================================
@@ -2078,6 +2434,25 @@ async function runTests() {
   if (p2) await p2;
   runTest('JS: media_spec_construction', testJS_mediaSpecConstruction);
 
+  // plugin_repo: PluginRepoServer and PluginRepoClient tests
+  console.log('\n--- plugin_repo ---');
+  runTest('TEST320: plugin_info_construction', test320_pluginInfoConstruction);
+  runTest('TEST321: plugin_info_is_signed', test321_pluginInfoIsSigned);
+  runTest('TEST322: plugin_info_has_binary', test322_pluginInfoHasBinary);
+  runTest('TEST323: plugin_repo_server_validate_registry', test323_pluginRepoServerValidateRegistry);
+  runTest('TEST324: plugin_repo_server_transform_to_array', test324_pluginRepoServerTransformToArray);
+  runTest('TEST325: plugin_repo_server_get_plugins', test325_pluginRepoServerGetPlugins);
+  runTest('TEST326: plugin_repo_server_get_plugin_by_id', test326_pluginRepoServerGetPluginById);
+  runTest('TEST327: plugin_repo_server_search_plugins', test327_pluginRepoServerSearchPlugins);
+  runTest('TEST328: plugin_repo_server_get_by_category', test328_pluginRepoServerGetByCategory);
+  runTest('TEST329: plugin_repo_server_get_by_cap', test329_pluginRepoServerGetByCap);
+  runTest('TEST330: plugin_repo_client_update_cache', test330_pluginRepoClientUpdateCache);
+  runTest('TEST331: plugin_repo_client_get_suggestions', test331_pluginRepoClientGetSuggestions);
+  runTest('TEST332: plugin_repo_client_get_plugin', test332_pluginRepoClientGetPlugin);
+  runTest('TEST333: plugin_repo_client_get_all_caps', test333_pluginRepoClientGetAllCaps);
+  runTest('TEST334: plugin_repo_client_needs_sync', test334_pluginRepoClientNeedsSync);
+  runTest('TEST335: plugin_repo_server_client_integration', test335_pluginRepoServerClientIntegration);
+
   // Summary
   console.log(`\n${passCount + failCount} tests: ${passCount} passed, ${failCount} failed`);
   if (failCount > 0) {

package/package.json

@@ -32,5 +32,5 @@
   "scripts": {
     "test": "node capns.test.js"
   },
-  "version": "0.76.17552"
+  "version": "0.77.17595"
 }