natureco-cli 2.23.28 → 2.23.29

package/src/utils/config.js

@@ -1,11 +1,24 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const crypto = require('crypto');
+const { ConfigParseError, ConfigMutationConflictError, ConfigValidationError, handleError } = require('./errors');
+
+let json5;
+try {
+  json5 = require('json5');
+} catch {
+  json5 = null;
+}
 
 const CONFIG_DIR = path.join(os.homedir(), '.natureco');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const CONFIG_BACKUP_DIR = path.join(CONFIG_DIR, 'backups');
+const MAX_BACKUPS = 10;
+
+let _configCache = null;
+let _configHash = null;
 
-// --profile flag desteği: ~/.natureco-<profile>/
 function getProfileDir() {
   const profileArg = process.argv.find(a => a.startsWith('--profile='));
   const profileIdx = process.argv.indexOf('--profile');
@@ -27,50 +40,134 @@ function ensureConfigDir() {
   }
 }
 
-function saveConfig(data) {
+function computeHash(data) {
+  return crypto.createHash('sha256').update(JSON.stringify(data)).digest('hex');
+}
+
+function createBackup() {
+  if (!fs.existsSync(ACTIVE_CONFIG_FILE)) return;
   ensureConfigDir();
-  fs.writeFileSync(ACTIVE_CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8');
+  if (!fs.existsSync(CONFIG_BACKUP_DIR)) {
+    fs.mkdirSync(CONFIG_BACKUP_DIR, { recursive: true });
+  }
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupFile = path.join(CONFIG_BACKUP_DIR, `config-${timestamp}.json`);
+  fs.copyFileSync(ACTIVE_CONFIG_FILE, backupFile);
+  const backups = fs.readdirSync(CONFIG_BACKUP_DIR)
+    .filter(f => f.startsWith('config-') && f.endsWith('.json'))
+    .sort()
+    .reverse();
+  if (backups.length > MAX_BACKUPS) {
+    backups.slice(MAX_BACKUPS).forEach(f => {
+      try { fs.unlinkSync(path.join(CONFIG_BACKUP_DIR, f)); } catch {}
+    });
+  }
+}
+
+function parseConfigContent(content) {
+  if (!content || !content.trim()) return {};
+  const trimmed = content.trim();
+  if (trimmed.startsWith('{')) {
+    if (json5) {
+      try { return json5.parse(trimmed); } catch {}
+    }
+    return JSON.parse(trimmed);
+  }
+  return JSON.parse(trimmed);
+}
+
+function validateConfig(data) {
+  if (data === null || data === undefined) throw new ConfigValidationError('Config cannot be null', { field: 'root' });
+  if (typeof data !== 'object' || Array.isArray(data)) throw new ConfigValidationError('Config must be a JSON object', { field: 'root' });
+  if (data.apiKey !== undefined && typeof data.apiKey !== 'string') throw new ConfigValidationError('apiKey must be a string', { field: 'apiKey' });
+  if (data.providerUrl !== undefined && typeof data.providerUrl !== 'string') throw new ConfigValidationError('providerUrl must be a string', { field: 'providerUrl' });
+  if (data.providerModel !== undefined && typeof data.providerModel !== 'string') throw new ConfigValidationError('providerModel must be a string', { field: 'providerModel' });
+  return true;
+}
+
+function saveConfig(data, options = {}) {
+  const { skipBackup = false, skipValidation = false } = options;
+  ensureConfigDir();
+  if (!skipValidation) validateConfig(data);
+  if (!skipBackup) createBackup();
+  const content = JSON.stringify(data, null, 2);
+  fs.writeFileSync(ACTIVE_CONFIG_FILE, content, 'utf8');
+  _configCache = data;
+  _configHash = computeHash(data);
 }
 
-function loadConfig() {
+function loadConfig(options = {}) {
+  const { useCache = true, skipValidation = false } = options;
+  if (useCache && _configCache) return _configCache;
   if (!fs.existsSync(ACTIVE_CONFIG_FILE)) {
+    _configCache = null;
+    _configHash = null;
     return null;
   }
   try {
     const content = fs.readFileSync(ACTIVE_CONFIG_FILE, 'utf8');
-    return JSON.parse(content);
+    const data = parseConfigContent(content);
+    if (!skipValidation) validateConfig(data);
+    _configCache = data;
+    _configHash = computeHash(data);
+    return data;
   } catch (err) {
+    _configCache = null;
+    _configHash = null;
+    if (err instanceof ConfigValidationError || err instanceof ConfigParseError) throw err;
     return null;
   }
 }
 
+function loadConfigWithRetry(maxRetries = 3) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return loadConfig({ useCache: false });
+    } catch (err) {
+      if (i === maxRetries - 1) throw err;
+    }
+  }
+  return null;
+}
+
 function deleteConfig() {
   if (fs.existsSync(ACTIVE_CONFIG_FILE)) {
+    createBackup();
     fs.unlinkSync(ACTIVE_CONFIG_FILE);
   }
+  _configCache = null;
+  _configHash = null;
 }
 
 function getApiKey() {
   const config = loadConfig();
-  return config?.apiKey || null;
+  return config?.apiKey ?? null;
 }
 
 function saveApiKey(apiKey) {
-  const config = loadConfig() || {};
+  const config = loadConfig() ?? {};
   config.apiKey = apiKey;
   saveConfig(config);
 }
 
 function getConfig() {
-  return loadConfig() || {};
+  try {
+    return loadConfig() ?? {};
+  } catch {
+    return {};
+  }
 }
 
 function getAllConfig() {
-  return loadConfig() || {};
+  try {
+    return loadConfig() ?? {};
+  } catch {
+    return {};
+  }
 }
 
 function setConfigValue(key, value) {
-  const config = loadConfig() || {};
+  const config = loadConfig() ?? {};
   const keys = key.split('.');
   let current = config;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -83,15 +180,49 @@ function setConfigValue(key, value) {
   saveConfig(config);
 }
 
+function getConfigHash() {
+  return _configHash;
+}
+
+function listBackups() {
+  if (!fs.existsSync(CONFIG_BACKUP_DIR)) return [];
+  return fs.readdirSync(CONFIG_BACKUP_DIR)
+    .filter(f => f.startsWith('config-') && f.endsWith('.json'))
+    .sort()
+    .reverse();
+}
+
+function restoreConfig(backupFile) {
+  const backupPath = path.isAbsolute(backupFile)
+    ? backupFile
+    : path.join(CONFIG_BACKUP_DIR, backupFile);
+  if (!fs.existsSync(backupPath)) {
+    throw new ConfigValidationError(`Yedek dosyası bulunamadı: ${backupPath}`, { field: 'backupFile' });
+  }
+  const content = fs.readFileSync(backupPath, 'utf8');
+  const data = parseConfigContent(content);
+  validateConfig(data);
+  createBackup();
+  fs.writeFileSync(ACTIVE_CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8');
+  _configCache = data;
+  _configHash = computeHash(data);
+  return { path: backupPath, timestamp: path.basename(backupPath).replace(/^config-|\.json$/g, '') };
+}
+
 module.exports = {
   saveConfig,
   loadConfig,
+  loadConfigWithRetry,
   deleteConfig,
   getApiKey,
   saveApiKey,
   getConfig,
   getAllConfig,
   setConfigValue,
+  getConfigHash,
+  listBackups,
+  restoreConfig,
   CONFIG_FILE: ACTIVE_CONFIG_FILE,
   CONFIG_DIR: ACTIVE_CONFIG_DIR,
+  CONFIG_BACKUP_DIR,
 };

package/src/utils/errors.js

@@ -0,0 +1,148 @@
+const chalk = require('chalk');
+
+class NatureCoError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.cause = options.cause || null;
+    this.exitCode = options.exitCode || 1;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+class ConfigError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.configPath = options.configPath || null;
+  }
+}
+
+class ConfigParseError extends ConfigError {
+  constructor(message, options = {}) {
+    super(`Config parse error: ${message}`, options);
+  }
+}
+
+class ConfigMutationConflictError extends ConfigError {
+  constructor(message, options = {}) {
+    super(`Config conflict: ${message}`, options);
+    this.currentHash = options.currentHash || null;
+  }
+}
+
+class ConfigValidationError extends ConfigError {
+  constructor(message, options = {}) {
+    super(`Config validation error: ${message}`, options);
+    this.field = options.field || null;
+  }
+}
+
+class ApiError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.statusCode = options.statusCode || null;
+    this.provider = options.provider || null;
+  }
+}
+
+class ProviderError extends ApiError {
+  constructor(message, options = {}) {
+    super(`Provider error (${options.provider || 'unknown'}): ${message}`, options);
+  }
+}
+
+class AuthenticationError extends ApiError {
+  constructor(message, options = {}) {
+    super(`Authentication error: ${message}`, options);
+  }
+}
+
+class ToolError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.toolName = options.toolName || null;
+  }
+}
+
+class ToolInputError extends ToolError {
+  constructor(message, options = {}) {
+    super(`Invalid tool input: ${message}`, options);
+  }
+}
+
+class ToolExecutionError extends ToolError {
+  constructor(message, options = {}) {
+    super(`Tool execution failed: ${message}`, options);
+  }
+}
+
+class ChannelError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.channel = options.channel || null;
+  }
+}
+
+class GatewayError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+  }
+}
+
+class PluginError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.plugin = options.plugin || null;
+  }
+}
+
+class SkillError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.skill = options.skill || null;
+  }
+}
+
+class MigrationError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.step = options.step || null;
+  }
+}
+
+function handleError(err, options = {}) {
+  const { prefix = '', exit = true, log = true } = options;
+  
+  if (log) {
+    const message = err instanceof NatureCoError
+      ? `${prefix}${err.message}`
+      : `${prefix}${err.message || 'An unknown error occurred'}`;
+    console.log(chalk.red(`\n${message}\n`));
+  }
+  
+  if (exit) {
+    process.exit(err instanceof NatureCoError ? err.exitCode : 1);
+  }
+}
+
+module.exports = {
+  NatureCoError,
+  ConfigError,
+  ConfigParseError,
+  ConfigMutationConflictError,
+  ConfigValidationError,
+  ApiError,
+  ProviderError,
+  AuthenticationError,
+  ToolError,
+  ToolInputError,
+  ToolExecutionError,
+  ChannelError,
+  GatewayError,
+  PluginError,
+  SkillError,
+  MigrationError,
+  handleError,
+};

package/src/utils/inquirer-wrapper.js

@@ -1,4 +1,4 @@
-const { select, input, password, confirm } = require('@inquirer/prompts');
+const { select, input, password, confirm, checkbox } = require('@inquirer/prompts');
 
 module.exports = {
   async prompt(questions) {
@@ -14,7 +14,6 @@ module.exports = {
       } else if (q.type === 'password') {
         results[q.name] = await password({ message: q.message, mask: q.mask });
       } else if (q.type === 'checkbox') {
-        const { checkbox } = require('@inquirer/prompts');
         results[q.name] = await checkbox({
           message: q.message,
           choices: q.choices.map(c =>

package/src/utils/path-utils.js

@@ -3,19 +3,19 @@ const os = require('os');
 function normalizeWindowsPaths(str) {
   let result = str.replace(/\\/g, '/');
 
-  result = result
-    .replace(/C:\/\/\/\/Users\/\/\/\/user\/\/\/\//g, `${os.homedir()}/`)
-    .replace(/C:\/Users\/user\//g, `${os.homedir()}/`)
-    .replace(/C:\/Users\/user\//g, `${os.homedir()}/`)
-    .replace(/C:\/\/Users\/\/user\/\/\.natureco\/\//g, `${os.homedir()}/.natureco/`)
-    .replace(/C:\/\/Users\/\/user\/\//g, `${os.homedir()}/`)
-    .replace(/E:\/\/\.natureco\/\//g, `${os.homedir()}/.natureco/`)
-    .replace(/'C:\/Users\/user\/\.natureco\//g, `'${os.homedir()}/.natureco/`)
-    .replace(/"C:\/Users\/user\/\.natureco\//g, `"${os.homedir()}/.natureco/`)
-    .replace(/'C:\/\/\/\/Users\/\/\/\/user\/\/\/\/\.natureco\/\/\/\//g, `'${os.homedir()}/.natureco/`)
-    .replace(/E:\/\.openclaw\//g, `${os.homedir()}/.natureco/`)
-    .replace(/\.openclaw\//g, '.natureco/')
-    .replace(/workspace\/scripts\\/g, 'workspace/scripts/');
+  const homeDir = os.homedir().replace(/\\/g, '/');
+
+  // Replace any Windows user profile path with actual homedir
+  result = result.replace(/[A-Za-z]:\/Users\/[^/]+\//g, `${homeDir}/`);
+
+  // Replace bare drive-letter references pointing to .openclaw
+  result = result.replace(/[A-Za-z]:\/\.openclaw\//g, `${homeDir}/.natureco/`);
+
+  // Migrate .openclaw paths to .natureco
+  result = result.replace(/\.openclaw\//g, '.natureco/');
+
+  // Normalize mixed path separators
+  result = result.replace(/workspace\/scripts\\/g, 'workspace/scripts/');
 
   return result;
 }

package/src/utils/plugin-registry.js

@@ -0,0 +1,238 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const { PluginError, handleError } = require('./errors');
+
+const PLUGINS_DIR = path.join(os.homedir(), '.natureco', 'plugins');
+const REGISTRY_FILE = path.join(os.homedir(), '.natureco', 'plugin-registry.json');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function loadRegistry() {
+  if (!fs.existsSync(REGISTRY_FILE)) return { version: 1, plugins: [], updatedAt: null };
+  try {
+    return JSON.parse(fs.readFileSync(REGISTRY_FILE, 'utf-8'));
+  } catch {
+    return { version: 1, plugins: [], updatedAt: null };
+  }
+}
+
+function saveRegistry(registry) {
+  ensureDir(path.dirname(REGISTRY_FILE));
+  registry.updatedAt = new Date().toISOString();
+  fs.writeFileSync(REGISTRY_FILE, JSON.stringify(registry, null, 2), 'utf-8');
+}
+
+function scanInstalled() {
+  ensureDir(PLUGINS_DIR);
+  return fs.readdirSync(PLUGINS_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => {
+      const manifestFile = path.join(PLUGINS_DIR, d.name, 'plugin.json');
+      const pkgFile = path.join(PLUGINS_DIR, d.name, 'package.json');
+      const manifest = readManifest(manifestFile, pkgFile, d.name);
+      const disabledFile = path.join(PLUGINS_DIR, d.name, '.disabled');
+      return { ...manifest, slug: d.name, enabled: !fs.existsSync(disabledFile), installPath: path.join(PLUGINS_DIR, d.name) };
+    });
+}
+
+function readManifest(manifestFile, pkgFile, fallbackName) {
+  let meta = { name: fallbackName, description: '', version: '1.0.0', author: '', license: 'MIT', keywords: [], entry: 'index.js' };
+  if (fs.existsSync(pkgFile)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgFile, 'utf-8'));
+      meta = { ...meta, name: pkg.name || meta.name, description: pkg.description || meta.description, version: pkg.version || meta.version, author: pkg.author || meta.author, license: pkg.license || meta.license, keywords: pkg.keywords || meta.keywords, entry: pkg.main || meta.entry, dependencies: pkg.dependencies, openclaw: pkg.openclaw };
+    } catch {}
+  }
+  if (fs.existsSync(manifestFile)) {
+    try {
+      const m = JSON.parse(fs.readFileSync(manifestFile, 'utf-8'));
+      meta = { ...meta, ...m };
+    } catch {}
+  }
+  return meta;
+}
+
+function validateManifest(manifest) {
+  const errors = [];
+  if (!manifest.name) errors.push('Plugin adı (name) gerekli');
+  if (!manifest.entry && !manifest.openclaw?.tool) errors.push('Entry noktası (entry/index.js) gerekli');
+  if (manifest.version && !/^\d+\.\d+\.\d+/.test(manifest.version)) errors.push('Version semver formatında olmalı (x.y.z)');
+  return errors;
+}
+
+function getInstalledIds() {
+  const registry = loadRegistry();
+  const installed = new Set(registry.plugins.map(p => p.id));
+  scanInstalled().forEach(p => installed.add(p.slug));
+  return [...installed];
+}
+
+function getPlugin(slug) {
+  return scanInstalled().find(p => p.slug === slug) || null;
+}
+
+async function installPlugin(spec) {
+  ensureDir(PLUGINS_DIR);
+
+  if (spec.startsWith('./') || spec.startsWith('/') || spec.startsWith('.\\') || spec.includes(':\\') || spec.startsWith('\\\\')) {
+    return installLocal(spec);
+  }
+  if (spec.startsWith('clawhub:') || spec.startsWith('naturehub:')) {
+    return installFromHub(spec);
+  }
+  if (spec.startsWith('npm:')) {
+    return installFromNpm(spec.slice(4));
+  }
+  if (spec.startsWith('git:')) {
+    return installFromGit(spec.slice(4));
+  }
+  if (spec.includes('/') && !spec.startsWith('@')) {
+    return installFromNpm(spec);
+  }
+  return installFromNpm(spec);
+}
+
+function installLocal(spec) {
+  const src = path.resolve(spec);
+  if (!fs.existsSync(src)) throw new PluginError(`Yol bulunamadı: ${src}`, 'install', spec);
+  const slug = path.basename(src);
+  const dest = path.join(PLUGINS_DIR, slug);
+  if (fs.existsSync(dest)) {
+    fs.rmSync(dest, { recursive: true, force: true });
+  }
+  fs.cpSync(src, dest, { recursive: true });
+  const manifest = readManifest(path.join(dest, 'plugin.json'), path.join(dest, 'package.json'), slug);
+  const errors = validateManifest(manifest);
+  if (errors.length > 0) {
+    fs.rmSync(dest, { recursive: true, force: true });
+    throw new PluginError(`Geçersiz manifest: ${errors.join(', ')}`, 'install', spec);
+  }
+  const registry = loadRegistry();
+  registry.plugins = registry.plugins.filter(p => p.id !== slug);
+  registry.plugins.push({ id: slug, name: manifest.name, version: manifest.version, source: 'local', spec, installedAt: new Date().toISOString() });
+  saveRegistry(registry);
+  return { slug, name: manifest.name, version: manifest.version, source: 'local' };
+}
+
+function installFromNpm(pkg) {
+  const tmpDir = path.join(os.tmpdir(), `nc-plugin-${Date.now()}`);
+  ensureDir(tmpDir);
+  try {
+    execSync(`npm install ${pkg} --prefix "${tmpDir}" --no-save --ignore-scripts --no-audit --no-fund`, { stdio: 'pipe', timeout: 120000 });
+    const pkgDir = path.join(tmpDir, 'node_modules', pkg.split('/').pop());
+    const scopedPkgDir = pkg.startsWith('@') ? path.join(tmpDir, 'node_modules', pkg) : null;
+    const srcDir = scopedPkgDir && fs.existsSync(scopedPkgDir) ? scopedPkgDir : (fs.existsSync(pkgDir) ? pkgDir : null);
+    if (!srcDir) throw new PluginError(`Paket bulunamadı: ${pkg}`, 'install', pkg);
+    const pkgJson = JSON.parse(fs.readFileSync(path.join(srcDir, 'package.json'), 'utf-8'));
+    const slug = pkgJson.name?.replace(/@/g, '').replace(/\//g, '-') || pkg.replace(/[@\/]/g, '-').replace(/^-/, '');
+    const dest = path.join(PLUGINS_DIR, slug);
+    if (fs.existsSync(dest)) fs.rmSync(dest, { recursive: true, force: true });
+    fs.cpSync(srcDir, dest, { recursive: true });
+    const manifest = readManifest(path.join(dest, 'plugin.json'), path.join(dest, 'package.json'), slug);
+    const errors = validateManifest(manifest);
+    if (errors.length > 0) {
+      fs.rmSync(dest, { recursive: true, force: true });
+      throw new PluginError(`Geçersiz manifest: ${errors.join(', ')}`, 'install', pkg);
+    }
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    const registry = loadRegistry();
+    registry.plugins = registry.plugins.filter(p => p.id !== slug);
+    registry.plugins.push({ id: slug, name: manifest.name, version: manifest.version, source: 'npm', spec: pkg, installedAt: new Date().toISOString() });
+    saveRegistry(registry);
+    return { slug, name: manifest.name, version: manifest.version, source: 'npm' };
+  } catch (err) {
+    if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
+    throw err;
+  }
+}
+
+function installFromGit(spec) {
+  const repoUrl = spec.startsWith('github.com/') ? `https://${spec}` : spec.startsWith('http') ? spec : spec.includes('/') ? `https://github.com/${spec}` : spec;
+  const tmpDir = path.join(os.tmpdir(), `nc-plugin-git-${Date.now()}`);
+  ensureDir(tmpDir);
+  try {
+    execSync(`git clone --depth 1 "${repoUrl}" "${tmpDir}"`, { stdio: 'pipe', timeout: 60000 });
+    const slug = spec.split('/').pop().replace(/\.git$/, '');
+    const dest = path.join(PLUGINS_DIR, slug);
+    if (fs.existsSync(dest)) fs.rmSync(dest, { recursive: true, force: true });
+    const items = fs.readdirSync(tmpDir);
+    const subDir = items.length === 1 && fs.statSync(path.join(tmpDir, items[0])).isDirectory() ? path.join(tmpDir, items[0]) : tmpDir;
+    fs.cpSync(subDir, dest, { recursive: true });
+    const manifest = readManifest(path.join(dest, 'plugin.json'), path.join(dest, 'package.json'), slug);
+    const errors = validateManifest(manifest);
+    if (errors.length > 0) {
+      fs.rmSync(dest, { recursive: true, force: true });
+      throw new PluginError(`Geçersiz manifest: ${errors.join(', ')}`, 'install', spec);
+    }
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    const registry = loadRegistry();
+    registry.plugins = registry.plugins.filter(p => p.id !== slug);
+    registry.plugins.push({ id: slug, name: manifest.name, version: manifest.version, source: 'git', spec: repoUrl, installedAt: new Date().toISOString() });
+    saveRegistry(registry);
+    return { slug, name: manifest.name, version: manifest.version, source: 'git' };
+  } catch (err) {
+    if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
+    throw err;
+  }
+}
+
+function installFromHub(spec) {
+  const pkg = spec.replace(/^(clawhub|naturehub):\/?/, '');
+  return installFromNpm(pkg);
+}
+
+async function uninstallPlugin(slug, options = {}) {
+  const plugin = getPlugin(slug);
+  if (!plugin) throw new PluginError(`Plugin bulunamadı: ${slug}`, 'uninstall', slug);
+  if (!options.keepFiles) {
+    fs.rmSync(plugin.installPath, { recursive: true, force: true });
+  }
+  const registry = loadRegistry();
+  registry.plugins = registry.plugins.filter(p => p.id !== slug);
+  saveRegistry(registry);
+  return { slug, name: plugin.name };
+}
+
+async function updatePlugin(slug) {
+  const plugin = getPlugin(slug);
+  if (!plugin) throw new PluginError(`Plugin bulunamadı: ${slug}`, 'update', slug);
+  const registry = loadRegistry();
+  const record = registry.plugins.find(p => p.id === slug);
+  if (!record || !record.spec) throw new PluginError(`Plugin kaydı bulunamadı veya spec eksik: ${slug}`, 'update', slug);
+  if (record.source === 'npm') {
+    fs.rmSync(plugin.installPath, { recursive: true, force: true });
+    return installFromNpm(record.spec);
+  }
+  if (record.source === 'git' && record.spec) {
+    fs.rmSync(plugin.installPath, { recursive: true, force: true });
+    return installFromGit(record.spec);
+  }
+  throw new PluginError(`${record.source} kaynağından güncelleme desteklenmiyor`, 'update', slug);
+}
+
+function searchRegistry(query) {
+  const registry = loadRegistry();
+  const q = query.toLowerCase();
+  return registry.plugins.filter(p =>
+    p.id.toLowerCase().includes(q) ||
+    (p.name || '').toLowerCase().includes(q)
+  );
+}
+
+module.exports = {
+  PLUGINS_DIR,
+  loadRegistry,
+  saveRegistry,
+  scanInstalled,
+  getPlugin,
+  getInstalledIds,
+  installPlugin,
+  uninstallPlugin,
+  updatePlugin,
+  searchRegistry,
+  validateManifest,
+};