@piecemaker-legal/piecemaker 1.0.6 → 1.0.8

package/server/piecemaker/library/connector-installation.ts

@@ -0,0 +1,248 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const TOML = require('@iarna/toml') as {
+  parse(value: string): Record<string, unknown>;
+  stringify(value: Record<string, unknown>): string;
+};
+
+export type LibraryConnectorConfig = {
+  transport: 'http' | 'stdio';
+  url?: string;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  headers?: Record<string, string>;
+};
+
+type FileSnapshot = { filePath: string; previous: string | null };
+
+function readJson(filePath: string) {
+  if (!fs.existsSync(filePath)) return {};
+  const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function readToml(filePath: string) {
+  if (!fs.existsSync(filePath)) return {};
+  const value = TOML.parse(fs.readFileSync(filePath, 'utf8'));
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function writeJson(filePath: string, value: Record<string, unknown>) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+}
+
+function writeToml(filePath: string, value: Record<string, unknown>) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(filePath, TOML.stringify(value), { mode: 0o600 });
+}
+
+function snapshotFile(filePath: string): FileSnapshot {
+  return { filePath, previous: fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : null };
+}
+
+function restoreFile({ filePath, previous }: FileSnapshot) {
+  if (previous === null) {
+    fs.rmSync(filePath, { force: true });
+    return;
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(filePath, previous, { mode: 0o600 });
+}
+
+function assertWorkspaceFile(workspace: string, filePath: string) {
+  const resolvedWorkspace = fs.realpathSync(workspace);
+  const parent = path.dirname(filePath);
+  if (fs.existsSync(parent)) {
+    const resolvedParent = fs.realpathSync(parent);
+    if (resolvedParent !== resolvedWorkspace && !resolvedParent.startsWith(resolvedWorkspace + path.sep)) {
+      throw new Error(`Répertoire de composants hors du dossier : ${parent}`);
+    }
+  } else if (!parent.startsWith(resolvedWorkspace + path.sep) && parent !== resolvedWorkspace) {
+    throw new Error(`Répertoire de composants hors du dossier : ${parent}`);
+  }
+}
+
+function objectRecord(value: unknown) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function claudeServer(config: LibraryConnectorConfig) {
+  if (config.transport === 'http') {
+    return {
+      type: 'http',
+      url: config.url,
+      ...(config.headers && Object.keys(config.headers).length ? { headers: config.headers } : {}),
+    };
+  }
+  return {
+    type: 'stdio',
+    command: config.command,
+    args: config.args ?? [],
+    ...(config.env && Object.keys(config.env).length ? { env: config.env } : {}),
+  };
+}
+
+function cursorServer(config: LibraryConnectorConfig, enabled: boolean) {
+  const server = config.transport === 'http'
+    ? { url: config.url, ...(config.headers && Object.keys(config.headers).length ? { headers: config.headers } : {}) }
+    : { command: config.command, args: config.args ?? [], ...(config.env && Object.keys(config.env).length ? { env: config.env } : {}) };
+  return enabled ? server : { ...server, disabled: true };
+}
+
+function codexServer(config: LibraryConnectorConfig, enabled: boolean) {
+  if (config.transport === 'http') {
+    return {
+      url: config.url,
+      enabled,
+      ...(config.headers && Object.keys(config.headers).length ? { http_headers: config.headers } : {}),
+    };
+  }
+  return {
+    command: config.command,
+    args: config.args ?? [],
+    enabled,
+    ...(config.env && Object.keys(config.env).length ? { env: config.env } : {}),
+  };
+}
+
+function grokServer(config: LibraryConnectorConfig, enabled: boolean) {
+  if (config.transport === 'http') {
+    return {
+      url: config.url,
+      enabled,
+      ...(config.headers && Object.keys(config.headers).length ? { headers: config.headers } : {}),
+    };
+  }
+  return {
+    command: config.command,
+    args: config.args ?? [],
+    enabled,
+    ...(config.env && Object.keys(config.env).length ? { env: config.env } : {}),
+  };
+}
+
+function opencodeServer(config: LibraryConnectorConfig, enabled: boolean) {
+  if (config.transport === 'http') {
+    return {
+      type: 'remote',
+      url: config.url,
+      enabled,
+      ...(config.headers && Object.keys(config.headers).length ? { headers: config.headers } : {}),
+    };
+  }
+  return {
+    type: 'local',
+    command: [config.command, ...(config.args ?? [])].filter(Boolean),
+    enabled,
+    ...(config.env && Object.keys(config.env).length ? { environment: config.env } : {}),
+  };
+}
+
+function opencodeConfigPath(workspace: string) {
+  const jsonPath = path.join(workspace, 'opencode.json');
+  const jsoncPath = path.join(workspace, 'opencode.jsonc');
+  if (fs.existsSync(jsonPath)) return jsonPath;
+  if (fs.existsSync(jsoncPath)) return jsoncPath;
+  return jsonPath;
+}
+
+export function parseConnectorConfig(content: string): LibraryConnectorConfig {
+  const parsed = JSON.parse(content) as LibraryConnectorConfig;
+  if (parsed?.transport !== 'http' && parsed?.transport !== 'stdio') throw new Error('Connecteur invalide.');
+  if (parsed.transport === 'http' && typeof parsed.url !== 'string') throw new Error('Connecteur invalide.');
+  if (parsed.transport === 'stdio' && typeof parsed.command !== 'string') throw new Error('Connecteur invalide.');
+  return parsed;
+}
+
+export function normalizeProviderConnector(raw: unknown): LibraryConnectorConfig | null {
+  const config = objectRecord(raw);
+  if (typeof config.url === 'string' || config.type === 'http' || config.type === 'remote' || config.type === 'sse') {
+    const url = typeof config.url === 'string' ? config.url : '';
+    if (!url) return null;
+    const headers = { ...objectRecord(config.headers), ...objectRecord(config.http_headers) };
+    return {
+      transport: 'http',
+      url,
+      headers: Object.fromEntries(Object.entries(headers).filter((entry): entry is [string, string] => typeof entry[1] === 'string')),
+    };
+  }
+  const commandParts = typeof config.command === 'string'
+    ? [config.command, ...(Array.isArray(config.args) ? config.args.filter((value): value is string => typeof value === 'string') : [])]
+    : Array.isArray(config.command) ? config.command.filter((value): value is string => typeof value === 'string') : [];
+  if (!commandParts[0]) return null;
+  const env = { ...objectRecord(config.env), ...objectRecord(config.environment) };
+  return {
+    transport: 'stdio',
+    command: commandParts[0],
+    args: commandParts.slice(1),
+    env: Object.fromEntries(Object.entries(env).filter((entry): entry is [string, string] => typeof entry[1] === 'string')),
+  };
+}
+
+export function prepareConnectorInstallation(workspace: string, name: string, config: LibraryConnectorConfig, enabled: boolean) {
+  const mcpJsonPath = path.join(workspace, '.mcp.json');
+  const claudeSettingsPath = path.join(workspace, '.claude', 'settings.local.json');
+  const codexPath = path.join(workspace, '.codex', 'config.toml');
+  const cursorPath = path.join(workspace, '.cursor', 'mcp.json');
+  const opencodePath = opencodeConfigPath(workspace);
+  const grokPath = path.join(workspace, '.grok', 'config.toml');
+  for (const filePath of [mcpJsonPath, claudeSettingsPath, codexPath, cursorPath, opencodePath, grokPath]) {
+    assertWorkspaceFile(workspace, filePath);
+  }
+
+  const snapshots = [mcpJsonPath, claudeSettingsPath, codexPath, cursorPath, opencodePath, grokPath].map(snapshotFile);
+
+  return () => {
+    try {
+      const mcpJson = readJson(mcpJsonPath);
+      const mcpServers = objectRecord(mcpJson.mcpServers);
+      if (enabled) mcpServers[name] = claudeServer(config);
+      else delete mcpServers[name];
+      mcpJson.mcpServers = mcpServers;
+      writeJson(mcpJsonPath, mcpJson);
+
+      const claudeSettings = readJson(claudeSettingsPath);
+      const disabled = Array.isArray(claudeSettings.disabledMcpServers)
+        ? claudeSettings.disabledMcpServers.filter((entry) => entry !== name)
+        : [];
+      claudeSettings.disabledMcpServers = enabled ? disabled : [...disabled, name];
+      writeJson(claudeSettingsPath, claudeSettings);
+
+      const codexConfig = readToml(codexPath);
+      const codexServers = objectRecord(codexConfig.mcp_servers);
+      codexServers[name] = enabled
+        ? codexServer(config, true)
+        : { ...objectRecord(codexServers[name]), ...codexServer(config, false), enabled: false };
+      codexConfig.mcp_servers = codexServers;
+      writeToml(codexPath, codexConfig);
+
+      const cursorConfig = readJson(cursorPath);
+      const cursorServers = objectRecord(cursorConfig.mcpServers);
+      cursorServers[name] = cursorServer(config, enabled);
+      cursorConfig.mcpServers = cursorServers;
+      writeJson(cursorPath, cursorConfig);
+
+      const opencodeConfig = readJson(opencodePath);
+      const opencodeServers = objectRecord(opencodeConfig.mcp);
+      opencodeServers[name] = opencodeServer(config, enabled);
+      opencodeConfig.mcp = opencodeServers;
+      writeJson(opencodePath, opencodeConfig);
+
+      const grokConfig = readToml(grokPath);
+      const grokServers = objectRecord(grokConfig.mcp_servers);
+      grokServers[name] = enabled
+        ? grokServer(config, true)
+        : { ...objectRecord(grokServers[name]), ...grokServer(config, false), enabled: false };
+      grokConfig.mcp_servers = grokServers;
+      writeToml(grokPath, grokConfig);
+    } catch (error) {
+      for (const snapshot of snapshots.reverse()) restoreFile(snapshot);
+      throw error;
+    }
+  };
+}

package/server/piecemaker/library/index.ts

@@ -9,13 +9,17 @@ import express from 'express';
 import { createLibraryStore } from './store.js';
 import { createLibraryRouter } from './routes.js';
 import { createLibraryMarketplaceRouter, scanInstalledLibraryCollections } from './marketplace.js';
+import { scanAndPersistLibraryProviderAgents } from './provider-agents.js';
+import { scanAndPersistLibraryProviderConnectors } from './provider-connectors.js';
 import { scanAndPersistLibraryProviderSkills } from './provider-skills.js';
 
 export { installLibraryRuntime } from './runtime.js';
 
 export async function startLibraryBackend(home: string, applicationRoot: string) {
   const store = createLibraryStore(home);
-  try { await scanAndPersistLibraryProviderSkills(store, undefined); } catch {}
+  try { await scanAndPersistLibraryProviderSkills(store, undefined, undefined, os.homedir()); } catch {}
+  try { scanAndPersistLibraryProviderAgents(store, os.homedir()); } catch {}
+  try { scanAndPersistLibraryProviderConnectors(store, os.homedir()); } catch {}
   try { scanInstalledLibraryCollections(store, os.homedir()); } catch {}
   const require = createRequire(import.meta.url);
   const { createActivationRouter } = require(path.join(applicationRoot, 'server/piecemaker/activation/index.cjs'));

package/server/piecemaker/library/marketplace.ts

@@ -6,7 +6,11 @@ import { spawnSync } from 'node:child_process';
 import express from 'express';
 
 import type { createLibraryStore } from './store.js';
+import { normalizeProviderConnector } from './connector-installation.js';
 import { importLibraryDirectory } from './migrate.js';
+import { scanAndPersistLibraryProviderAgents } from './provider-agents.js';
+import { scanAndPersistLibraryProviderConnectors } from './provider-connectors.js';
+import { scanAndPersistLibraryProviderSkills } from './provider-skills.js';
 
 type MarketplaceKind = 'connector' | 'skill' | 'plugin' | 'agent';
 
@@ -37,13 +41,26 @@ function marketplacePackageKinds(userHome: string, marketplaceName: string, plug
     if (fs.existsSync(path.join(root, 'agents'))) kinds.add('agent');
   }
   if (Array.isArray(entry?.skills) && entry.skills.length) kinds.add('skill');
-  const searchable = `${plugin.name} ${plugin.description || ''}`.toLowerCase();
-  if (/\bmcp\b|\bconnect(?:or|eur|s|ed|ion)?\b|\bintegration\b/.test(searchable)) kinds.add('connector');
-  if (/\bskills?\b|\btoolkit\b|\bworkflow\b/.test(searchable)) kinds.add('skill');
-  if (/\bagents?\b/.test(searchable)) kinds.add('agent');
+  if (marketplaceName === 'mcp-legifrance') kinds.add('connector');
   return [...kinds];
 }
 
+function disableNativeClaudePlugin(userHome: string, id: string) {
+  const settingsFilename = path.join(userHome, '.claude/settings.json');
+  const settings = fs.existsSync(settingsFilename)
+    ? JSON.parse(fs.readFileSync(settingsFilename, 'utf8'))
+    : {};
+  const enabledPlugins = settings.enabledPlugins && typeof settings.enabledPlugins === 'object' && !Array.isArray(settings.enabledPlugins)
+    ? settings.enabledPlugins
+    : {};
+  if (enabledPlugins[id] === false) return;
+  settings.enabledPlugins = { ...enabledPlugins, [id]: false };
+  fs.mkdirSync(path.dirname(settingsFilename), { recursive: true, mode: 0o700 });
+  const temporary = `${settingsFilename}.library.tmp`;
+  fs.writeFileSync(temporary, JSON.stringify(settings, null, 2), { mode: 0o600 });
+  fs.renameSync(temporary, settingsFilename);
+}
+
 export function scanInstalledLibraryCollections(store: ReturnType<typeof createLibraryStore>, userHome: string) {
   const filename = path.join(userHome, '.claude/plugins/installed_plugins.json');
   const registry = fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')).plugins || {} : {};
@@ -51,7 +68,6 @@ export function scanInstalledLibraryCollections(store: ReturnType<typeof createL
   if (!fs.existsSync(pluginsDirectory) || fs.lstatSync(pluginsDirectory).isSymbolicLink()) return;
   const pluginsRoot = fs.realpathSync(pluginsDirectory);
   for (const [id, installs] of Object.entries(registry)) {
-    if (store.hasCollection(id)) continue;
     if (!Array.isArray(installs)) continue;
     const install = installs.find((entry) => entry && typeof entry.installPath === 'string') as { installPath: string } | undefined;
     if (!install || !fs.existsSync(install.installPath)) continue;
@@ -60,7 +76,7 @@ export function scanInstalledLibraryCollections(store: ReturnType<typeof createL
     let manifest: { name?: string; displayName?: string; description?: string } = {};
     const manifestPath = path.join(installRoot, '.claude-plugin', 'plugin.json');
     try { manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')); } catch {}
-    const imported = [
+    const imported: Array<{ source: string; id: string; linked: boolean; rootPath?: string }> = [
       ...importLibraryDirectory(store, path.join(installRoot, 'skills'), 'skill', false),
       ...importLibraryDirectory(store, path.join(installRoot, 'agents'), 'agent', false),
     ];
@@ -72,23 +88,32 @@ export function scanInstalledLibraryCollections(store: ReturnType<typeof createL
         imported.push({ source, id: store.importFile(source, 'skill', false), linked: false });
       }
     }
-    const files: Array<{ path: string; content: Buffer }> = [];
-    let totalSize = 0;
-    const collect = (directory: string, relative = '') => {
-      for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-        if (entry.name === '.git' || entry.name === 'node_modules' || entry.name === '__pycache__' || entry.isSymbolicLink()) continue;
-        const relativePath = path.posix.join(relative.split(path.sep).join('/'), entry.name);
-        const absolutePath = path.join(directory, entry.name);
-        if (entry.isDirectory()) collect(absolutePath, relativePath);
-        else if (entry.isFile()) {
-          const content = fs.readFileSync(absolutePath);
-          totalSize += content.length;
-          if (totalSize > 30 * 1024 * 1024 || files.length >= 5000) throw new Error(`Plugin trop volumineux : ${id}`);
-          files.push({ path: relativePath, content });
+    const mcpPath = path.join(installRoot, '.mcp.json');
+    if (fs.existsSync(mcpPath) && !fs.lstatSync(mcpPath).isSymbolicLink()) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
+        const servers = parsed?.mcpServers && typeof parsed.mcpServers === 'object' && !Array.isArray(parsed.mcpServers)
+          ? parsed.mcpServers as Record<string, unknown>
+          : {};
+        for (const [name, raw] of Object.entries(servers)) {
+          const config = normalizeProviderConnector(raw);
+          if (!config) continue;
+          const source = `${mcpPath}#${name}`;
+          imported.push({
+            source,
+            id: store.importConnector({
+              name,
+              description: config.url || config.command || name,
+              config,
+              source,
+              namespace: id,
+            }),
+            linked: false,
+            rootPath: `mcp/${name}.json`,
+          });
         }
-      }
-    };
-    collect(installRoot);
+      } catch {}
+    }
     const fallbackEntryName = imported.length ? store.document(imported[0].id).name : null;
     store.upsertCollection({
       id,
@@ -97,13 +122,46 @@ export function scanInstalledLibraryCollections(store: ReturnType<typeof createL
       source: installRoot,
       entries: imported.map((entry) => ({
         entryId: entry.id,
-        rootPath: path.relative(installRoot, entry.source).split(path.sep).join('/'),
+        rootPath: entry.rootPath || path.relative(installRoot, entry.source).split(path.sep).join('/'),
       })),
-      files,
+      files: [],
     });
   }
 }
 
+function readInstalledClaudePlugins(userHome: string) {
+  const filename = path.join(userHome, '.claude/plugins/installed_plugins.json');
+  if (!fs.existsSync(filename)) return {};
+  const config = JSON.parse(fs.readFileSync(filename, 'utf8'));
+  return config.plugins && typeof config.plugins === 'object' && !Array.isArray(config.plugins)
+    ? config.plugins as Record<string, unknown>
+    : {};
+}
+
+function synchronizeInstalledPluginActivation(
+  store: ReturnType<typeof createLibraryStore>,
+  userHome: string,
+  workspacePath: string,
+) {
+  const settingsFilename = path.join(userHome, '.claude/settings.json');
+  if (!fs.existsSync(settingsFilename)) return store.listCollections(workspacePath);
+  const settings = JSON.parse(fs.readFileSync(settingsFilename, 'utf8'));
+  const enabledPlugins = settings.enabledPlugins && typeof settings.enabledPlugins === 'object' && !Array.isArray(settings.enabledPlugins)
+    ? settings.enabledPlugins as Record<string, unknown>
+    : {};
+  const installedPlugins = readInstalledClaudePlugins(userHome);
+  const collections = store.listCollections(workspacePath);
+
+  for (const id of Object.keys(installedPlugins)) {
+    const collection = collections.find((entry) => entry.id === id);
+    const enabled = enabledPlugins[id];
+    if (!collection || collection.componentCount === 0 || typeof enabled !== 'boolean' || collection.enabled === enabled) continue;
+    store.setCollectionEnabled(workspacePath, id, enabled);
+  }
+
+  return store.listCollections(workspacePath);
+}
+
 export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLibraryStore>, applicationRoot: string, userHome: string) {
   const require = createRequire(import.meta.url);
   const { listMarketplaceConnectors, registerOfficialMarketplace } = require(path.join(applicationRoot, 'server/piecemaker/vendor/websocket-server/admin-routes.cjs'));
@@ -123,15 +181,6 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
     return fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')).plugins || {} : {};
   };
   const importInstalledCollections = () => scanInstalledLibraryCollections(store, userHome);
-  const disable = (id: string) => {
-    const filename = path.join(userHome, '.claude/settings.json');
-    const settings = fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')) : {};
-    settings.enabledPlugins = { ...settings.enabledPlugins, [id]: false };
-    fs.mkdirSync(path.dirname(filename), { recursive: true, mode: 0o700 });
-    const temporary = `${filename}.library.tmp`;
-    fs.writeFileSync(temporary, JSON.stringify(settings, null, 2), { mode: 0o600 });
-    fs.renameSync(temporary, filename);
-  };
   router.get('/plugin/marketplace', (req, res) => {
     try {
       const marketplace = scope(req.query.scope);
@@ -152,7 +201,23 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
   });
   router.get('/plugins', (req, res) => {
     try {
-      res.json({ plugins: store.listCollections(typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined) });
+      const workspacePath = typeof req.query.workspacePath === 'string' ? req.query.workspacePath : undefined;
+      res.json({ plugins: store.listCollections(workspacePath) });
+    } catch (error) { res.status(400).json({ error: (error as Error).message }); }
+  });
+  router.post('/plugins/sync', async (req, res) => {
+    try {
+      const workspacePath = typeof req.body?.workspacePath === 'string' ? req.body.workspacePath : undefined;
+      await scanAndPersistLibraryProviderSkills(store, workspacePath, undefined, userHome);
+      scanAndPersistLibraryProviderAgents(store, userHome);
+      scanAndPersistLibraryProviderConnectors(store, userHome);
+      scanInstalledLibraryCollections(store, userHome);
+      res.json({
+        ok: true,
+        plugins: workspacePath
+          ? synchronizeInstalledPluginActivation(store, userHome, workspacePath)
+          : store.listCollections(),
+      });
     } catch (error) { res.status(400).json({ error: (error as Error).message }); }
   });
   router.post('/plugins/scan', (_req, res) => {
@@ -183,14 +248,14 @@ export function createLibraryMarketplaceRouter(store: ReturnType<typeof createLi
     try {
       const marketplace = scope(req.body?.scope);
       const id = req.body?.id;
-      if (typeof id !== 'string' || !/^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+$/.test(id) || !id.endsWith(`@${marketplace.name}`)) throw new Error('Connecteur invalide.');
-      if (installed()[id]) throw new Error('Connecteur déjà installé. Son activation se règle par dossier.');
+      if (typeof id !== 'string' || !/^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+$/.test(id) || !id.endsWith(`@${marketplace.name}`)) throw new Error('Élément invalide.');
+      if (installed()[id]) throw new Error('Déjà installé. Son activation se règle par dossier.');
       const catalog = listMarketplaceConnectors(run, { marketplaceName: marketplace.name });
-      if (!catalog.plugins.some((plugin: { id: string }) => plugin.id === id)) throw new Error('Connecteur absent du catalogue.');
-      disable(id);
+      if (!catalog.plugins.some((plugin: { id: string }) => plugin.id === id)) throw new Error('Élément absent du catalogue.');
+      disableNativeClaudePlugin(userHome, id);
       let result;
       try { result = run('claude', ['plugin', 'install', id, '--scope', 'user']); }
-      finally { disable(id); }
+      finally { disableNativeClaudePlugin(userHome, id); }
       if (!result.ok) throw new Error(result.output || 'Installation impossible.');
       importInstalledCollections();
       res.json({ ok: true, enabled: false });

package/server/piecemaker/library/migrate.ts

@@ -29,12 +29,19 @@ export function migratePersonalLibrary(store: ReturnType<typeof createLibrarySto
     [path.join(userHome, '.claude', 'skills'), 'skill'],
     [path.join(userHome, '.codex', 'skills'), 'skill'],
     [path.join(userHome, '.agents', 'skills'), 'skill'],
+    [path.join(userHome, '.cursor', 'skills'), 'skill'],
+    [path.join(userHome, '.config', 'opencode', 'skills'), 'skill'],
+    [path.join(userHome, '.grok', 'skills'), 'skill'],
     [path.join(userHome, '.claude', 'agents'), 'agent'],
+    [path.join(userHome, '.cursor', 'agents'), 'agent'],
+    [path.join(userHome, '.grok', 'agents'), 'agent'],
+    [path.join(userHome, '.config', 'opencode', 'agents'), 'agent'],
+    [path.join(userHome, '.config', 'opencode', 'agent'), 'agent'],
     [path.join(userHome, '.piecemaker', 'library', 'skills'), 'skill'],
     [path.join(userHome, '.piecemaker', 'library', 'agents'), 'agent'],
   ] as const) imported.push(...importLibraryDirectory(store, directory, kind));
   if (withdraw) {
-    const candidates = imported.filter((entry) => ['.claude', '.codex', '.agents'].some((provider) => entry.source.startsWith(path.join(userHome, provider) + path.sep)));
+    const candidates = imported.filter((entry) => ['.claude', '.codex', '.agents', '.cursor', '.grok', path.join('.config', 'opencode')].some((provider) => entry.source.startsWith(path.join(userHome, provider) + path.sep)));
     const backup = path.join(store.directory, `migration-${Date.now()}`);
     fs.mkdirSync(backup, { recursive: true, mode: 0o700 });
     fs.writeFileSync(path.join(backup, 'manifest.json'), JSON.stringify(candidates, null, 2), { mode: 0o600 });

package/server/piecemaker/library/provider-agents.ts

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+import { importLibraryDirectory } from './migrate.js';
+import type { createLibraryStore } from './store.js';
+
+const require = createRequire(import.meta.url);
+const TOML = require('@iarna/toml') as { parse(value: string): Record<string, unknown> };
+
+function importTomlAgents(store: ReturnType<typeof createLibraryStore>, directory: string) {
+  if (!fs.existsSync(directory) || fs.lstatSync(directory).isSymbolicLink()) return [];
+  const imported: string[] = [];
+  for (const item of fs.readdirSync(directory, { withFileTypes: true })) {
+    if (!item.isFile() || !item.name.toLowerCase().endsWith('.toml')) continue;
+    const source = path.join(directory, item.name);
+    if (fs.lstatSync(source).isSymbolicLink()) continue;
+    try {
+      const parsed = TOML.parse(fs.readFileSync(source, 'utf8'));
+      const name = typeof parsed.name === 'string' && parsed.name.trim() ? parsed.name : path.basename(item.name, '.toml');
+      const description = typeof parsed.description === 'string' ? parsed.description : '';
+      const body = typeof parsed.developer_instructions === 'string' ? parsed.developer_instructions : '';
+      imported.push(store.importContent(source, 'agent', `---\nname: ${name}\ndescription: ${description}\n---\n${body}\n`));
+    } catch {}
+  }
+  return imported;
+}
+
+export function scanAndPersistLibraryProviderAgents(store: ReturnType<typeof createLibraryStore>, userHome: string) {
+  const markdownDirectories = [
+    path.join(userHome, '.claude', 'agents'),
+    path.join(userHome, '.cursor', 'agents'),
+    path.join(userHome, '.config', 'opencode', 'agent'),
+    path.join(userHome, '.config', 'opencode', 'agents'),
+    path.join(userHome, '.grok', 'agents'),
+  ];
+  for (const directory of markdownDirectories) {
+    try { importLibraryDirectory(store, directory, 'agent', false); } catch {}
+  }
+  try { importTomlAgents(store, path.join(userHome, '.codex', 'agents')); } catch {}
+}
+
+export function scanAndPersistLibraryClaudeAgents(
+  store: ReturnType<typeof createLibraryStore>,
+  _workspacePath: string | undefined,
+  userHome: string,
+) {
+  scanAndPersistLibraryProviderAgents(store, userHome);
+}

package/server/piecemaker/library/provider-connectors.ts

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+import { normalizeProviderConnector, type LibraryConnectorConfig } from './connector-installation.js';
+import type { createLibraryStore } from './store.js';
+
+const require = createRequire(import.meta.url);
+const TOML = require('@iarna/toml') as { parse(value: string): Record<string, unknown> };
+
+export const REGISTRE_PUBLIC_CONNECTOR = Object.freeze({
+  name: 'registre-public',
+  url: 'https://registre-public.com/api/mcp',
+});
+
+type ImportedConnector = {
+  name: string;
+  description: string;
+  config: LibraryConnectorConfig;
+  source: string;
+};
+
+function readJson(filePath: string) {
+  if (!fs.existsSync(filePath)) return {};
+  try {
+    const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
+function readToml(filePath: string) {
+  if (!fs.existsSync(filePath)) return {};
+  try {
+    const value = TOML.parse(fs.readFileSync(filePath, 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  } catch {
+    return {};
+  }
+}
+
+function objectRecord(value: unknown) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function collectServers(source: string, servers: Record<string, unknown>, collected: ImportedConnector[]) {
+  for (const [name, raw] of Object.entries(servers)) {
+    const config = normalizeProviderConnector(raw);
+    if (!config) continue;
+    collected.push({
+      name,
+      description: config.url || config.command || name,
+      config,
+      source: `${source}#${name}`,
+    });
+  }
+}
+
+export function listUserProviderConnectors(userHome: string) {
+  const collected: ImportedConnector[] = [];
+  collectServers(path.join(userHome, '.claude.json'), objectRecord(readJson(path.join(userHome, '.claude.json')).mcpServers), collected);
+  collectServers(path.join(userHome, '.codex', 'config.toml'), objectRecord(readToml(path.join(userHome, '.codex', 'config.toml')).mcp_servers), collected);
+  collectServers(path.join(userHome, '.cursor', 'mcp.json'), objectRecord(readJson(path.join(userHome, '.cursor', 'mcp.json')).mcpServers), collected);
+  const opencodeJson = path.join(userHome, '.config', 'opencode', 'opencode.json');
+  const opencodeJsonc = path.join(userHome, '.config', 'opencode', 'opencode.jsonc');
+  const opencodePath = fs.existsSync(opencodeJson) ? opencodeJson : opencodeJsonc;
+  collectServers(opencodePath, objectRecord(readJson(opencodePath).mcp), collected);
+  collectServers(path.join(userHome, '.grok', 'config.toml'), objectRecord(readToml(path.join(userHome, '.grok', 'config.toml')).mcp_servers), collected);
+  return collected;
+}
+
+export function seedDefaultLibraryConnectors(store: ReturnType<typeof createLibraryStore>) {
+  return store.importConnector({
+    name: REGISTRE_PUBLIC_CONNECTOR.name,
+    description: REGISTRE_PUBLIC_CONNECTOR.url,
+    config: { transport: 'http', url: REGISTRE_PUBLIC_CONNECTOR.url },
+    source: 'piecemaker:default:registre-public',
+  });
+}
+
+export function scanAndPersistLibraryProviderConnectors(store: ReturnType<typeof createLibraryStore>, userHome: string) {
+  seedDefaultLibraryConnectors(store);
+  const imported: string[] = [];
+  for (const connector of listUserProviderConnectors(userHome)) {
+    try { imported.push(store.importConnector(connector)); } catch {}
+  }
+  return imported;
+}