natureco-cli 2.23.28 → 2.23.30

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,
+};

package/src/utils/secrets.js

@@ -0,0 +1,177 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { NatureCoError } = require('./errors');
+
+const ENV_SHORTHAND_RE = /^\$\{([A-Z][A-Z0-9_]{0,127})\}$/;
+const ENV_SHORT_RE = /^\$([A-Z][A-Z0-9_]{0,127})$/;
+const SECRET_REF_ENV_PREFIX = 'secretref-env:';
+const SECRET_REF_ENV_LEGACY = '__env__:';
+
+class UnresolvedSecretError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.ref = options.ref || null;
+    this.path = options.path || null;
+  }
+}
+
+// Cache for resolved secrets
+const _secretCache = new Map();
+
+function resolveEnvVar(name) {
+  return process.env[name] ?? null;
+}
+
+function coerceSecretRef(value) {
+  if (!value || typeof value !== 'string') return null;
+
+  // Structured ref: {"source":"env","provider":"default","id":"MY_KEY"}
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed && typeof parsed === 'object' && parsed.source && parsed.provider && parsed.id) {
+      return { source: parsed.source, provider: parsed.provider, id: parsed.id };
+    }
+  } catch {}
+
+  // Env shorthand: ${MY_KEY} or $MY_KEY
+  let m = value.match(ENV_SHORTHAND_RE);
+  if (m) return { source: 'env', provider: 'default', id: m[1] };
+  m = value.match(ENV_SHORT_RE);
+  if (m) return { source: 'env', provider: 'default', id: m[1] };
+
+  // Legacy: secretref-env:MY_KEY or __env__:MY_KEY
+  if (value.startsWith(SECRET_REF_ENV_PREFIX)) {
+    return { source: 'env', provider: 'default', id: value.slice(SECRET_REF_ENV_PREFIX.length) };
+  }
+  if (value.startsWith(SECRET_REF_ENV_LEGACY)) {
+    return { source: 'env', provider: 'default', id: value.slice(SECRET_REF_ENV_LEGACY.length) };
+  }
+
+  return null;
+}
+
+function resolveSecretRef(ref, options = {}) {
+  const { cache = true, throwOnMissing = false } = options;
+  const cacheKey = `${ref.source}:${ref.provider}:${ref.id}`;
+
+  if (cache && _secretCache.has(cacheKey)) {
+    return _secretCache.get(cacheKey);
+  }
+
+  let resolved = null;
+
+  if (ref.source === 'env') {
+    resolved = resolveEnvVar(ref.id);
+  } else if (ref.source === 'file') {
+    try {
+      const content = fs.readFileSync(ref.id, 'utf8').trim();
+      resolved = content;
+    } catch {}
+  }
+
+  if (resolved === null && throwOnMissing) {
+    throw new UnresolvedSecretError(
+      `Secret not found: ${cacheKey}`,
+      { ref, path: cacheKey }
+    );
+  }
+
+  if (cache && resolved !== null) {
+    _secretCache.set(cacheKey, resolved);
+  }
+
+  return resolved;
+}
+
+function resolveSecretValue(value, options = {}) {
+  if (!value || typeof value !== 'string') return value;
+
+  const ref = coerceSecretRef(value);
+  if (ref) {
+    const resolved = resolveSecretRef(ref, options);
+    return resolved ?? value;
+  }
+
+  return value;
+}
+
+function resolveConfigSecrets(config, options = {}) {
+  if (!config || typeof config !== 'object') return config;
+
+  const resolved = Array.isArray(config) ? [] : {};
+  for (const [key, value] of Object.entries(config)) {
+    if (value && typeof value === 'object') {
+      resolved[key] = resolveConfigSecrets(value, options);
+    } else if (typeof value === 'string') {
+      resolved[key] = resolveSecretValue(value, options);
+    } else {
+      resolved[key] = value;
+    }
+  }
+  return resolved;
+}
+
+function loadEnvFile(filePath) {
+  const envPath = filePath || path.join(process.cwd(), '.env');
+  if (!fs.existsSync(envPath)) return {};
+
+  const env = {};
+  const content = fs.readFileSync(envPath, 'utf8');
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) continue;
+    const eqIdx = trimmed.indexOf('=');
+    const key = trimmed.slice(0, eqIdx).trim();
+    let val = trimmed.slice(eqIdx + 1).trim();
+    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    if (key) env[key] = val;
+  }
+  return env;
+}
+
+function injectEnvFile(envPath) {
+  const env = loadEnvFile(envPath);
+  for (const [key, val] of Object.entries(env)) {
+    if (!(key in process.env)) {
+      process.env[key] = val;
+    }
+  }
+  return env;
+}
+
+function clearSecretCache() {
+  _secretCache.clear();
+}
+
+function listSecretRefs(config, prefix = '') {
+  const refs = [];
+  if (!config || typeof config !== 'object') return refs;
+
+  for (const [key, value] of Object.entries(config)) {
+    const fullPath = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      refs.push(...listSecretRefs(value, fullPath));
+    } else if (typeof value === 'string') {
+      const ref = coerceSecretRef(value);
+      if (ref) {
+        refs.push({ path: fullPath, ref, value });
+      }
+    }
+  }
+  return refs;
+}
+
+module.exports = {
+  UnresolvedSecretError,
+  coerceSecretRef,
+  resolveSecretRef,
+  resolveSecretValue,
+  resolveConfigSecrets,
+  loadEnvFile,
+  injectEnvFile,
+  clearSecretCache,
+  listSecretRefs,
+};

package/src/utils/skills.js

@@ -299,30 +299,17 @@ Bu skill ${name} işlemlerini yapar.
   return path.join(skillDir, 'SKILL.md');
 }
 
-// Popular skills list
-const POPULAR_SKILLS = [
-  { slug: 'github', name: 'GitHub', description: 'GitHub repo işlemleri', source: 'clawhub' },
-  { slug: 'filesystem', name: 'Filesystem', description: 'Dosya sistemi işlemleri', source: 'clawhub' },
-  { slug: 'web-search', name: 'Web Search', description: 'Web arama', source: 'clawhub' },
-  { slug: 'summarize', name: 'Summarize', description: 'Metin özetleme', source: 'clawhub' },
-  { slug: 'code-review', name: 'Code Review', description: 'Kod inceleme', source: 'clawhub' },
-  { slug: 'translate', name: 'Translate', description: 'Çeviri', source: 'clawhub' },
-  { slug: 'weather', name: 'Weather', description: 'Hava durumu', source: 'clawhub' },
-  { slug: 'calendar', name: 'Calendar', description: 'Takvim yönetimi', source: 'clawhub' },
-];
-
-// Get popular skills from ClawHub API (fallback to hardcoded list)
+// Get popular skills from ClawHub API (no fallback — transparent error)
 async function getPopularSkills() {
-  try {
-    const response = await fetch('https://clawhub.ai/api/skills?q=&limit=20');
-    if (response.ok) {
-      const data = await response.json();
-      if (data.skills && data.skills.length > 0) {
-        return data.skills.map(s => ({ ...s, source: 'clawhub' }));
-      }
-    }
-  } catch {}
-  return POPULAR_SKILLS;
+  const response = await fetch('https://clawhub.ai/api/skills?q=&limit=20');
+  if (!response.ok) {
+    throw new Error(`ClawHub API returned HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  if (!data.skills || data.skills.length === 0) {
+    throw new Error('ClawHub API returned empty skill list');
+  }
+  return data.skills.map(s => ({ ...s, source: 'clawhub' }));
 }
 
 // Get skill prompt injection content (full SKILL.md content)