coding-tool-x 3.5.5 → 3.5.6

package/src/server/services/plugins-service.js

@@ -208,6 +208,123 @@ function stripJsonComments(input = '') {
   return result;
 }
 
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function getNestedValue(source, segments = []) {
+  return segments.reduce((acc, segment) => (acc && acc[segment] !== undefined ? acc[segment] : undefined), source);
+}
+
+function normalizeContentText(value = '') {
+  return String(value || '').trim();
+}
+
+function normalizeContentEntry(raw, fallback = {}) {
+  if (typeof raw === 'string') {
+    const name = normalizeContentText(raw);
+    if (!name) return null;
+    return {
+      name,
+      path: normalizeRepoPath(fallback.path || ''),
+      description: normalizeContentText(fallback.description || '')
+    };
+  }
+
+  if (!isPlainObject(raw)) {
+    return null;
+  }
+
+  const candidateName = [
+    raw.name,
+    raw.displayName,
+    raw.id,
+    raw.title,
+    raw.fileName,
+    raw.directory,
+    raw.path,
+    fallback.name
+  ].map(normalizeContentText).find(Boolean) || '';
+  const itemPath = normalizeRepoPath(raw.path || raw.file || raw.fileName || raw.directory || fallback.path || '');
+  const description = normalizeContentText(raw.description || raw.prompt || raw.usage || fallback.description || '');
+  const derivedName = candidateName || (itemPath ? path.posix.basename(itemPath, path.posix.extname(itemPath)) : '');
+
+  if (!derivedName && !itemPath) {
+    return null;
+  }
+
+  return {
+    name: derivedName,
+    path: itemPath,
+    description
+  };
+}
+
+function normalizeContentCollection(value, fallback = {}) {
+  if (Array.isArray(value)) {
+    return value.map(item => normalizeContentEntry(item, fallback)).filter(Boolean);
+  }
+
+  if (isPlainObject(value)) {
+    return Object.entries(value)
+      .map(([key, item]) => {
+        if (isPlainObject(item)) {
+          return normalizeContentEntry({
+            ...item,
+            name: item.name || key
+          }, fallback);
+        }
+
+        if (typeof item === 'string') {
+          return normalizeContentEntry({
+            name: key,
+            description: item
+          }, fallback);
+        }
+
+        return normalizeContentEntry({ name: key }, fallback);
+      })
+      .filter(Boolean);
+  }
+
+  return [];
+}
+
+function mergeContentCollections(...collections) {
+  const merged = [];
+  const seen = new Set();
+
+  for (const collection of collections) {
+    for (const rawEntry of collection || []) {
+      const entry = normalizeContentEntry(rawEntry);
+      if (!entry) continue;
+
+      const normalizedPath = normalizeRepoPath(entry.path || '');
+      const normalizedName = normalizeContentText(entry.name || '');
+      const key = normalizedPath
+        ? `path:${normalizedPath.toLowerCase()}`
+        : (normalizedName ? `name:${normalizedName.toLowerCase()}` : '');
+
+      if (!key || seen.has(key)) {
+        continue;
+      }
+
+      seen.add(key);
+      merged.push({
+        name: normalizedName || path.posix.basename(normalizedPath, path.posix.extname(normalizedPath)),
+        path: normalizedPath,
+        description: normalizeContentText(entry.description || '')
+      });
+    }
+  }
+
+  return merged.sort((a, b) => {
+    const left = a.name || a.path;
+    const right = b.name || b.path;
+    return left.localeCompare(right);
+  });
+}
+
 class PluginsService {
   constructor(platform = 'claude') {
     this.platform = ['claude', 'opencode'].includes(platform) ? platform : 'claude';
@@ -221,6 +338,202 @@ class PluginsService {
     this._marketCache = null;
   }
 
+  _createEmptyContentSummary() {
+    return {
+      skills: [],
+      agents: [],
+      commands: [],
+      hooks: [],
+      files: [],
+      totalFiles: 0,
+      additionalFileCount: 0
+    };
+  }
+
+  _getManifestCollection(manifest = null, paths = []) {
+    if (!isPlainObject(manifest)) {
+      return [];
+    }
+
+    return mergeContentCollections(
+      ...paths.map(segments => normalizeContentCollection(getNestedValue(manifest, segments)))
+    );
+  }
+
+  _summarizeManifestContent(manifest = null) {
+    const emptySummary = this._createEmptyContentSummary();
+    if (!isPlainObject(manifest)) {
+      return emptySummary;
+    }
+
+    return {
+      ...emptySummary,
+      skills: this._getManifestCollection(manifest, [
+        ['skills'],
+        ['ctx', 'skills'],
+        ['contributes', 'skills']
+      ]),
+      agents: this._getManifestCollection(manifest, [
+        ['agents'],
+        ['ctx', 'agents'],
+        ['contributes', 'agents']
+      ]),
+      commands: this._getManifestCollection(manifest, [
+        ['commands'],
+        ['ctx', 'commands'],
+        ['contributes', 'commands']
+      ]),
+      hooks: this._getManifestCollection(manifest, [
+        ['hooks'],
+        ['ctx', 'hooks'],
+        ['contributes', 'hooks']
+      ])
+    };
+  }
+
+  _summarizeContentFromFiles(files = [], directory = '') {
+    const emptySummary = this._createEmptyContentSummary();
+    const normalizedDirectory = normalizeRepoPath(directory);
+    const directoryLooksLikeFile = /\.[a-z0-9]+$/i.test(path.posix.basename(normalizedDirectory || ''));
+    const allFiles = (Array.isArray(files) ? files : [])
+      .filter(item => item && item.type === 'blob' && item.path)
+      .map(item => ({
+        ...item,
+        path: normalizeRepoPath(item.path)
+      }))
+      .sort((a, b) => a.path.localeCompare(b.path));
+
+    let scopedFiles = allFiles;
+    if (normalizedDirectory) {
+      if (directoryLooksLikeFile) {
+        scopedFiles = allFiles.filter(item => item.path === normalizedDirectory);
+      } else {
+        const directoryPrefix = `${normalizedDirectory}/`;
+        scopedFiles = allFiles.filter(item => item.path.startsWith(directoryPrefix));
+      }
+    }
+
+    const toScopedPath = (filePath = '') => {
+      if (!normalizedDirectory || directoryLooksLikeFile) {
+        return normalizeRepoPath(filePath);
+      }
+      const prefix = `${normalizedDirectory}/`;
+      return filePath.startsWith(prefix) ? filePath.slice(prefix.length) : filePath;
+    };
+
+    const skillEntries = [];
+    const agentEntries = [];
+    const commandEntries = [];
+
+    for (const file of scopedFiles) {
+      const scopedPath = toScopedPath(file.path);
+      const skillMatch = scopedPath.match(/^skills\/([^/]+)\/SKILL\.md$/i);
+      if (skillMatch) {
+        skillEntries.push({ name: skillMatch[1], path: scopedPath });
+      }
+
+      const agentMatch = scopedPath.match(/^agents\/(.+)\.md$/i);
+      if (agentMatch) {
+        agentEntries.push({
+          name: agentMatch[1].split('/').pop(),
+          path: scopedPath
+        });
+      }
+
+      const commandMatch = scopedPath.match(/^(?:commands|prompts)\/(.+)\.md$/i);
+      if (commandMatch) {
+        commandEntries.push({
+          name: commandMatch[1].split('/').pop(),
+          path: scopedPath
+        });
+      }
+    }
+
+    const filePreview = scopedFiles.slice(0, 8).map(file => {
+      const scopedPath = toScopedPath(file.path);
+      return {
+        name: path.posix.basename(scopedPath),
+        path: scopedPath
+      };
+    });
+
+    return {
+      ...emptySummary,
+      skills: mergeContentCollections(skillEntries),
+      agents: mergeContentCollections(agentEntries),
+      commands: mergeContentCollections(commandEntries),
+      files: filePreview,
+      totalFiles: scopedFiles.length,
+      additionalFileCount: Math.max(0, scopedFiles.length - filePreview.length)
+    };
+  }
+
+  _mergeContentSummary(...summaries) {
+    const emptySummary = this._createEmptyContentSummary();
+    const validSummaries = summaries.filter(Boolean);
+    const fileSummary = validSummaries.find(summary => Array.isArray(summary.files) && summary.files.length > 0) || emptySummary;
+
+    return {
+      ...emptySummary,
+      skills: mergeContentCollections(...validSummaries.map(summary => summary.skills)),
+      agents: mergeContentCollections(...validSummaries.map(summary => summary.agents)),
+      commands: mergeContentCollections(...validSummaries.map(summary => summary.commands)),
+      hooks: mergeContentCollections(...validSummaries.map(summary => summary.hooks)),
+      files: fileSummary.files || [],
+      totalFiles: fileSummary.totalFiles || 0,
+      additionalFileCount: fileSummary.additionalFileCount || 0
+    };
+  }
+
+  _scanInstallPath(installPath = '') {
+    const resolvedPath = String(installPath || '').trim();
+    if (!resolvedPath || !fs.existsSync(resolvedPath)) {
+      return [];
+    }
+
+    try {
+      const stat = fs.statSync(resolvedPath);
+      if (stat.isFile()) {
+        const fileName = path.basename(resolvedPath);
+        return [{ path: fileName, type: 'blob', name: fileName }];
+      }
+
+      const tree = [];
+      this.scanLocalRepoTree(resolvedPath, resolvedPath, tree);
+      return tree;
+    } catch {
+      return [];
+    }
+  }
+
+  _readPluginManifestFromInstallPath(installPath = '') {
+    const resolvedPath = String(installPath || '').trim();
+    if (!resolvedPath || !fs.existsSync(resolvedPath)) {
+      return null;
+    }
+
+    try {
+      const stat = fs.statSync(resolvedPath);
+      if (stat.isFile()) {
+        if (!resolvedPath.endsWith('.json')) {
+          return null;
+        }
+        return JSON.parse(stripJsonComments(fs.readFileSync(resolvedPath, 'utf8')));
+      }
+
+      const candidates = ['plugin.json', 'package.json'];
+      for (const candidate of candidates) {
+        const manifestPath = path.join(resolvedPath, candidate);
+        if (!fs.existsSync(manifestPath)) continue;
+        return JSON.parse(stripJsonComments(fs.readFileSync(manifestPath, 'utf8')));
+      }
+    } catch {
+      return null;
+    }
+
+    return null;
+  }
+
   normalizeRepoConfig(repo = {}) {
     const provider = SUPPORTED_REPO_PROVIDERS.includes(repo.provider)
       ? repo.provider
@@ -719,7 +1032,173 @@ class PluginsService {
       description: manifest?.description || '',
       author: manifest?.author || '',
       commands: manifest?.commands || [],
-      hooks: manifest?.hooks || [],
+      hooks: manifest?.hooks || manifest?.ctx?.hooks || [],
+      manifest
+    };
+  }
+
+  resolvePluginRepo(plugin = {}) {
+    let repo = null;
+
+    if (plugin.repoProvider || plugin.repoLocalPath || plugin.repoProjectPath || plugin.repoOwner) {
+      try {
+        repo = this.normalizeRepoConfig({
+          id: plugin.repoId,
+          provider: plugin.repoProvider,
+          host: plugin.repoHost,
+          owner: plugin.repoOwner,
+          name: plugin.repoName,
+          branch: plugin.repoBranch || 'main',
+          projectPath: plugin.repoProjectPath,
+          localPath: plugin.repoLocalPath,
+          repoUrl: plugin.repoUrl
+        });
+      } catch {
+        repo = null;
+      }
+    } else if (plugin.source) {
+      repo = this.parseRepoTreeSource(plugin.source);
+    }
+
+    if (!repo && plugin.repoUrl) {
+      const parsedTreeSource = this.parseRepoTreeSource(plugin.repoUrl);
+      if (parsedTreeSource) {
+        repo = parsedTreeSource;
+      } else if (plugin.repoUrl.includes('github.com')) {
+        const match = plugin.repoUrl.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
+        if (match) {
+          try {
+            repo = this.normalizeRepoConfig({
+              provider: 'github',
+              owner: match[1],
+              name: match[2],
+              branch: plugin.repoBranch || 'main'
+            });
+          } catch {
+            repo = null;
+          }
+        }
+      }
+    }
+
+    return repo;
+  }
+
+  async _readPluginManifestFromRepo(plugin = {}, repo = null) {
+    const resolvedRepo = repo || this.resolvePluginRepo(plugin);
+    if (!resolvedRepo) {
+      return null;
+    }
+
+    const normalizedDirectory = normalizeRepoPath(plugin.directory || '');
+    const candidates = [];
+
+    if (normalizedDirectory) {
+      if (/\.[a-z0-9]+$/i.test(path.posix.basename(normalizedDirectory))) {
+        candidates.push(normalizedDirectory);
+      } else {
+        candidates.push(`${normalizedDirectory}/plugin.json`, `${normalizedDirectory}/package.json`);
+      }
+    }
+
+    candidates.push('plugin.json', 'package.json');
+
+    for (const candidate of Array.from(new Set(candidates))) {
+      try {
+        return await this.fetchRepoJson(resolvedRepo, candidate);
+      } catch {
+        // try next candidate
+      }
+    }
+
+    return null;
+  }
+
+  async getPluginDetail(pluginInput = {}) {
+    const requestedPlugin = typeof pluginInput === 'string'
+      ? { name: pluginInput }
+      : { ...(pluginInput || {}) };
+    const requestedName = String(requestedPlugin.name || '').trim();
+
+    if (!requestedName && !requestedPlugin.directory) {
+      return null;
+    }
+
+    const installedPlugin = this.listPlugins().plugins.find(plugin => {
+      if (requestedName && (plugin.name === requestedName || plugin.directory === requestedName)) {
+        return true;
+      }
+      if (requestedPlugin.installPath && plugin.installPath === requestedPlugin.installPath) {
+        return true;
+      }
+      return Boolean(
+        requestedPlugin.repoId &&
+        plugin.repoId === requestedPlugin.repoId &&
+        plugin.directory === requestedPlugin.directory
+      );
+    }) || null;
+    const legacyPlugin = (!this._isOpenCode() && requestedName) ? getPlugin(requestedName) : null;
+
+    const mergedPlugin = {
+      ...requestedPlugin,
+      ...(installedPlugin || {}),
+      ...(legacyPlugin || {})
+    };
+    mergedPlugin.name = requestedName || mergedPlugin.name || mergedPlugin.directory || '';
+
+    if (!mergedPlugin.name) {
+      return null;
+    }
+
+    const fallbackInstallPath = (!mergedPlugin.installPath && !this._isOpenCode())
+      ? path.join(INSTALLED_DIR, mergedPlugin.name)
+      : '';
+    const installPath = mergedPlugin.installPath || (fallbackInstallPath && fs.existsSync(fallbackInstallPath) ? fallbackInstallPath : '');
+
+    let manifest = this._readPluginManifestFromInstallPath(installPath);
+    const repo = this.resolvePluginRepo(mergedPlugin);
+    if (!manifest) {
+      manifest = await this._readPluginManifestFromRepo(mergedPlugin, repo);
+    }
+
+    let fileSummary = this._createEmptyContentSummary();
+    if (installPath && fs.existsSync(installPath)) {
+      fileSummary = this._summarizeContentFromFiles(this._scanInstallPath(installPath));
+    } else if (repo) {
+      try {
+        const repoTree = await this.fetchRepoTree(repo);
+        fileSummary = this._summarizeContentFromFiles(repoTree, mergedPlugin.directory || '');
+      } catch {
+        fileSummary = this._createEmptyContentSummary();
+      }
+    }
+
+    const manifestSummary = this._summarizeManifestContent(manifest);
+    const contentSummary = this._mergeContentSummary(manifestSummary, fileSummary);
+    const commands = mergeContentCollections(
+      contentSummary.commands,
+      normalizeContentCollection(mergedPlugin.commands)
+    );
+    const hooks = mergeContentCollections(
+      contentSummary.hooks,
+      normalizeContentCollection(mergedPlugin.hooks)
+    );
+    const installed = mergedPlugin.installed !== undefined
+      ? !!mergedPlugin.installed
+      : Boolean(mergedPlugin.isInstalled || installPath || installedPlugin);
+
+    return {
+      ...mergedPlugin,
+      installPath,
+      installed,
+      description: mergedPlugin.description || manifest?.description || '',
+      author: mergedPlugin.author || manifest?.author || '',
+      version: mergedPlugin.version || manifest?.version || (this._isOpenCode() ? 'latest' : '1.0.0'),
+      commands,
+      hooks,
+      skills: contentSummary.skills,
+      agents: contentSummary.agents,
+      contentSummary,
       manifest
     };
   }
@@ -1892,44 +2371,7 @@ class PluginsService {
         }
       }
 
-      let repo = null;
-      if (plugin.repoProvider || plugin.repoLocalPath || plugin.repoProjectPath || plugin.repoOwner) {
-        try {
-          repo = this.normalizeRepoConfig({
-            id: plugin.repoId,
-            provider: plugin.repoProvider,
-            host: plugin.repoHost,
-            owner: plugin.repoOwner,
-            name: plugin.repoName,
-            branch: plugin.repoBranch || 'main',
-            projectPath: plugin.repoProjectPath,
-            localPath: plugin.repoLocalPath,
-            repoUrl: plugin.repoUrl
-          });
-        } catch {
-          repo = null;
-        }
-      } else if (plugin.source) {
-        repo = this.parseRepoTreeSource(plugin.source);
-      }
-
-      if (!repo && plugin.repoUrl) {
-        const parsedTreeSource = this.parseRepoTreeSource(plugin.repoUrl);
-        if (parsedTreeSource) {
-          repo = parsedTreeSource;
-        } else if (plugin.repoUrl.includes('github.com')) {
-          const match = plugin.repoUrl.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
-          if (match) {
-            repo = this.normalizeRepoConfig({
-              provider: 'github',
-              owner: match[1],
-              name: match[2],
-              branch: plugin.repoBranch || 'main'
-            });
-          }
-        }
-      }
-
+      const repo = this.resolvePluginRepo(plugin);
       if (!repo) return '';
 
       for (const candidate of readmeCandidates) {
@@ -1980,6 +2422,7 @@ class PluginsService {
       lspServers: data.lspServers || null,
       commands: data.commands || [],
       hooks: data.hooks || [],
+      contentSummary: data.contentSummary || this._createEmptyContentSummary(),
       isInstalled: false
     };
   }
@@ -2019,7 +2462,11 @@ class PluginsService {
           directory: file.path,
           installSource: githubRepo ? '' : installSource,
           marketplaceFormat: 'opencode-plugin-json',
-          repoUrl
+          repoUrl,
+          contentSummary: this._mergeContentSummary(
+            this._summarizeManifestContent(manifest),
+            this._summarizeContentFromFiles(tree, file.path)
+          )
         });
       })
     );
@@ -2086,7 +2533,11 @@ class PluginsService {
                 version: plugin.version || '1.0.0',
                 category: plugin.category || 'general',
                 directory: plugin.source?.replace(/^\.\//, '') || plugin.name,
-                lspServers: plugin.lspServers || null
+                lspServers: plugin.lspServers || null,
+                contentSummary: this._summarizeContentFromFiles(
+                  files,
+                  plugin.source?.replace(/^\.\//, '') || plugin.name
+                )
               }));
             }
             continue; // Skip legacy format check
@@ -2112,6 +2563,8 @@ class PluginsService {
         for (const dir of pluginDirs) {
           try {
             const manifest = await readJson(`${dir}/plugin.json`);
+            const manifestSummary = this._summarizeManifestContent(manifest);
+            const fileSummary = this._summarizeContentFromFiles(files, dir);
 
             marketPlugins.push(this.buildMarketPluginItem(repo, {
               name: manifest.name || dir,
@@ -2119,8 +2572,9 @@ class PluginsService {
               author: manifest.author || repo.owner,
               version: manifest.version || '1.0.0',
               directory: dir,
-              commands: manifest.commands || [],
-              hooks: manifest.hooks || []
+              commands: manifestSummary.commands,
+              hooks: manifestSummary.hooks,
+              contentSummary: this._mergeContentSummary(manifestSummary, fileSummary)
             }));
           } catch (e) {
             // OpenCode 仓库常见 package.json 格式
@@ -2132,7 +2586,11 @@ class PluginsService {
                   description: pkg.description || '',
                   author: pkg.author || repo.owner,
                   version: pkg.version || '1.0.0',
-                  directory: dir
+                  directory: dir,
+                  contentSummary: this._mergeContentSummary(
+                    this._summarizeManifestContent(pkg),
+                    this._summarizeContentFromFiles(files, dir)
+                  )
                 }));
               } catch (pkgErr) {
                 // neither plugin.json nor package.json

package/src/server/services/session-launch-command.js

@@ -0,0 +1,81 @@
+const { isWindowsLikePlatform } = require('../../utils/home-dir');
+
+function escapeForDoubleQuotes(value) {
+  return String(value).replace(/"/g, '\\"');
+}
+
+function escapeForPowerShellSingleQuotes(value) {
+  return String(value).replace(/'/g, "''");
+}
+
+function buildDisplayCommand(executable, args = []) {
+  return [String(executable || ''), ...args.map(arg => String(arg))].filter(Boolean).join(' ').trim();
+}
+
+function buildWindowsCopyCommand(cwd, executable, args = []) {
+  const quotedCwd = `'${escapeForPowerShellSingleQuotes(cwd)}'`;
+  const quotedExecutable = `'${escapeForPowerShellSingleQuotes(executable)}'`;
+  const quotedArgs = args.map(arg => `'${escapeForPowerShellSingleQuotes(arg)}'`).join(' ');
+  const invokeCommand = quotedArgs
+    ? `& ${quotedExecutable} ${quotedArgs}`
+    : `& ${quotedExecutable}`;
+
+  return `powershell -NoProfile -ExecutionPolicy Bypass -Command "& { Set-Location -LiteralPath ${quotedCwd}; ${invokeCommand} }"`;
+}
+
+function buildPosixCopyCommand(cwd, command) {
+  const quotedCwd = `"${escapeForDoubleQuotes(cwd)}"`;
+  return `cd ${quotedCwd} && ${command}`;
+}
+
+function buildCopyCommand({
+  cwd,
+  command,
+  executable,
+  args = [],
+  runtimePlatform = process.platform,
+  runtimeEnv = process.env
+}) {
+  const resolvedCommand = command || buildDisplayCommand(executable, args);
+  if (!cwd) {
+    return resolvedCommand;
+  }
+
+  if (isWindowsLikePlatform(runtimePlatform, runtimeEnv)) {
+    return buildWindowsCopyCommand(cwd, executable, args);
+  }
+
+  return buildPosixCopyCommand(cwd, resolvedCommand);
+}
+
+function buildLaunchCommand({
+  cwd,
+  executable,
+  args = [],
+  runtimePlatform = process.platform,
+  runtimeEnv = process.env
+}) {
+  const command = buildDisplayCommand(executable, args);
+  return {
+    command,
+    copyCommand: buildCopyCommand({
+      cwd,
+      command,
+      executable,
+      args,
+      runtimePlatform,
+      runtimeEnv
+    })
+  };
+}
+
+module.exports = {
+  buildLaunchCommand,
+  _test: {
+    buildDisplayCommand,
+    buildCopyCommand,
+    buildWindowsCopyCommand,
+    buildPosixCopyCommand,
+    escapeForPowerShellSingleQuotes
+  }
+};