natureco-cli 2.23.29 → 2.23.30

package/src/commands/memory-cmd.js

@@ -16,9 +16,17 @@ async function memoryCmd(args) {
   if (action === 'show') return showMemory(params[0]);
   if (action === 'clear') return clearMemoryCmd(params[0]);
   if (action === 'index') return indexMemory();
+  if (action === 'export') return exportMemoryCmd(params[0], params[1]);
+  if (action === 'import') return importMemoryCmd(params[0], params[1]);
+  if (action === 'semantic') return semanticSearchCmd(params.join(' '));
+  // Wiki pages
+  if (action === 'wiki') return wikiCmd(params[0], params.slice(1));
+  if (action === 'wiki-create') return wikiCreateCmd(params[0], params.slice(1).join(' '));
+  if (action === 'wiki-list') return wikiListCmd();
+  if (action === 'wiki-search') return wikiSearchCmd(params.join(' '));
 
   console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
-  console.log(chalk.gray('  Kullanım: natureco memory [status|list|search|show|clear|index]\n'));
+  console.log(chalk.gray('  Kullanım: natureco memory [status|list|search|show|clear|index|export|import|semantic|wiki|wiki-create|wiki-list|wiki-search]\n'));
   process.exit(1);
 }
 
@@ -202,4 +210,129 @@ function indexMemory() {
   console.log(chalk.green(`\n  ✓ ${indexed} hafıza dosyası yeniden indexlendi\n`));
 }
 
+// ── Export Memory ──────────────────────────────────────────────────────────────
+function exportMemoryCmd(botId, outputFile) {
+  const id = botId || 'universal-provider';
+  const mem = exportMemory(id);
+  const filePath = outputFile || path.join(process.cwd(), `memory-${id}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(mem, null, 2));
+  console.log(chalk.green(`\n  ✓ Hafıza dışa aktarıldı: ${filePath}\n`));
+}
+
+// ── Import Memory ──────────────────────────────────────────────────────────────
+function importMemoryCmd(botId, sourceFile) {
+  if (!sourceFile) {
+    console.log(chalk.red('\n  ❌ Kaynak dosya gerekli\n'));
+    console.log(chalk.gray('  Kullanım: natureco memory import <botId> <dosya.json>\n'));
+    return;
+  }
+  const resolvedPath = path.resolve(sourceFile.replace(/^~/, os.homedir()));
+  if (!fs.existsSync(resolvedPath)) {
+    console.log(chalk.red(`\n  ❌ Dosya bulunamadı: ${resolvedPath}\n`));
+    return;
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(resolvedPath, 'utf-8'));
+    importMemory(botId || 'universal-provider', data);
+    console.log(chalk.green(`\n  ✓ Hafıza içe aktarıldı: ${botId || 'universal-provider'}\n`));
+  } catch (err) {
+    console.log(chalk.red(`\n  ❌ Hata: ${err.message}\n`));
+  }
+}
+
+// ── Semantic Search ────────────────────────────────────────────────────────────
+function semanticSearchCmd(query) {
+  if (!query) {
+    console.log(chalk.red('\n  ❌ Arama sorgusu gerekli\n'));
+    return;
+  }
+  const results = semanticSearchMemory(query, 10);
+  console.log(chalk.cyan.bold(`\n  Semantic: "${query}" → ${results.length} sonuç\n`));
+  if (results.length === 0) {
+    console.log(chalk.gray('  Sonuç bulunamadı.\n'));
+    return;
+  }
+  results.forEach((r, i) => {
+    const pct = Math.round(r.score * 100);
+    const bar = chalk.green('█'.repeat(Math.floor(pct / 10))) + chalk.gray('░'.repeat(10 - Math.floor(pct / 10)));
+    console.log(`  ${chalk.white(`${i + 1}.`)} ${bar} ${chalk.white(r.value.slice(0, 70))}`);
+    console.log(chalk.gray(`     [${r.bot}]  alaka: %${pct}`));
+  });
+  console.log('');
+}
+
+// ── Wiki Commands ──────────────────────────────────────────────────────────────
+function wikiCmd(action, params) {
+  if (!action || action === 'list') return wikiListCmd();
+  if (action === 'show') {
+    const slug = params?.[0];
+    if (!slug) { console.log(chalk.red('\n  ❌ Sayfa adı gerekli\n')); return; }
+    const page = getWikiPage(slug);
+    if (!page) { console.log(chalk.yellow(`\n  ⚠ Sayfa bulunamadı: ${slug}\n`)); return; }
+    console.log(chalk.cyan.bold(`\n  Wiki: ${page.slug}\n`));
+    console.log(chalk.white(page.content));
+    console.log(chalk.gray(`\n  Son güncelleme: ${page.updatedAt}\n`));
+    return;
+  }
+  if (action === 'create' || action === 'edit') {
+    const slug = params?.[0];
+    const content = params?.slice(1).join(' ');
+    if (!slug || !content) {
+      console.log(chalk.red('\n  ❌ Kullanım: natureco memory wiki create <slug> <içerik>\n'));
+      return;
+    }
+    saveWikiPage(slug, content);
+    console.log(chalk.green(`\n  ✓ Wiki sayfası kaydedildi: ${slug}\n`));
+    return;
+  }
+  if (action === 'search') {
+    const query = params?.join(' ');
+    if (!query) { console.log(chalk.red('\n  ❌ Arama sorgusu gerekli\n')); return; }
+    const results = searchWikiPages(query);
+    console.log(chalk.cyan.bold(`\n  Wiki: "${query}" → ${results.length} sonuç\n`));
+    if (results.length === 0) { console.log(chalk.gray('  Sonuç bulunamadı.\n')); return; }
+    results.forEach(p => {
+      console.log(`  ${chalk.white(p.slug)} ${chalk.gray('—')} ${chalk.gray((p.content || '').slice(0, 60))}`);
+    });
+    console.log('');
+    return;
+  }
+  console.log(chalk.red(`\n  ❌ Bilinmeyen wiki aksiyonu: ${action}\n`));
+}
+
+function wikiCreateCmd(slug, content) {
+  if (!slug || !content) {
+    console.log(chalk.red('\n  ❌ Kullanım: natureco memory wiki-create <slug> <içerik>\n'));
+    return;
+  }
+  saveWikiPage(slug, content);
+  console.log(chalk.green(`\n  ✓ Wiki sayfası oluşturuldu: ${slug}\n`));
+}
+
+function wikiListCmd() {
+  const pages = listWikiPages();
+  console.log(chalk.cyan.bold(`\n  Wiki Sayfaları (${pages.length})\n`));
+  if (pages.length === 0) {
+    console.log(chalk.gray('  Henüz sayfa yok.\n'));
+    console.log(chalk.gray('  Oluşturmak: ') + chalk.cyan('natureco memory wiki create <slug> <içerik>\n'));
+    return;
+  }
+  pages.forEach(p => {
+    const preview = (p.content || '').slice(0, 60).replace(/\n/g, ' ');
+    console.log(`  ${chalk.white(p.slug)} ${chalk.gray('—')} ${chalk.gray(preview)}`);
+    console.log(chalk.gray(`    ${p.updatedAt}\n`));
+  });
+}
+
+function wikiSearchCmd(query) {
+  if (!query) { console.log(chalk.red('\n  ❌ Arama sorgusu gerekli\n')); return; }
+  const results = searchWikiPages(query);
+  console.log(chalk.cyan.bold(`\n  Wiki Ara: "${query}" → ${results.length} sonuç\n`));
+  if (results.length === 0) { console.log(chalk.gray('  Sonuç bulunamadı.\n')); return; }
+  results.forEach(p => {
+    console.log(`  ${chalk.white(p.slug)}`);
+    console.log(chalk.gray(`    ${(p.content || '').slice(0, 80)}\n`));
+  });
+}
+
 module.exports = memoryCmd;

package/src/commands/message.js

@@ -33,8 +33,8 @@ async function message(args) {
     process.exit(1);
   }
   
-  if (!['whatsapp', 'telegram', 'signal', 'irc', 'sms'].includes(channel)) {
-    console.log(chalk.red('\n❌ Geçersiz kanal. Kullanılabilir: whatsapp, telegram, signal, irc, sms\n'));
+  if (!['whatsapp', 'telegram', 'signal', 'irc', 'sms', 'mattermost'].includes(channel)) {
+    console.log(chalk.red('\n❌ Geçersiz kanal. Kullanılabilir: whatsapp, telegram, signal, irc, sms, mattermost\n'));
     process.exit(1);
   }
   
@@ -87,12 +87,18 @@ async function message(args) {
     process.exit(1);
   }
   
+  if (channel === 'mattermost' && (!config.mattermostBotId || !config.mattermostToken)) {
+    console.log(chalk.red('\n❌ Mattermost bağlı değil\n'));
+    console.log(chalk.yellow('Önce Mattermost\'u bağlayın:'), chalk.cyan('natureco mattermost connect\n'));
+    process.exit(1);
+  }
+  
   // Send message via HTTP endpoint
   await sendMessageViaHttp(channel, target, messageText);
 }
 
 async function sendMessageViaHttp(channel, target, messageText) {
-  const channelNames = { whatsapp: 'WhatsApp', telegram: 'Telegram', signal: 'Signal', irc: 'IRC', sms: 'SMS' };
+  const channelNames = { whatsapp: 'WhatsApp', telegram: 'Telegram', signal: 'Signal', irc: 'IRC', sms: 'SMS', mattermost: 'Mattermost' };
   console.log(chalk.yellow(`\n⏳ ${channelNames[channel] || channel} mesajı gönderiliyor...\n`));
   
   try {

package/src/commands/migrate.js

@@ -35,9 +35,17 @@ function addUniqueFact(facts, newFact) {
 async function migrate(options) {
   const from = options.from || 'openclaw';
   
+  if (from === 'claude-code' || from === 'claude') {
+    return migrateClaudeCode();
+  }
+  if (from === 'hermes') {
+    return migrateHermes();
+  }
   if (from !== 'openclaw') {
-    console.log(chalk.red('\n❌ Sadece OpenClaw migration destekleniyor.\n'));
-    console.log(chalk.gray('Kullanım: natureco migrate --from openclaw\n'));
+    console.log(chalk.red('\n❌ Desteklenen kaynaklar: openclaw, claude-code, hermes\n'));
+    console.log(chalk.gray('Kullanım: natureco migrate --from openclaw'));
+    console.log(chalk.gray('         natureco migrate --from claude-code'));
+    console.log(chalk.gray('         natureco migrate --from hermes\n'));
     return;
   }
   
@@ -623,4 +631,207 @@ function copyDirRecursive(src, dest) {
   }
 }
 
+// ── Claude Code Migration ──────────────────────────────────────────────────────
+async function migrateClaudeCode() {
+  console.log(chalk.yellow('\n⏳ Claude Code → NatureCo migration başlıyor...\n'));
+
+  const claudeDir = path.join(os.homedir(), '.claude');
+  const claudeSettings = path.join(claudeDir, 'settings.json');
+  const claudeProjects = path.join(os.homedir(), '.claude', 'projects');
+
+  if (!fs.existsSync(claudeSettings)) {
+    console.log(chalk.yellow('⚠ Claude Code settings bulunamadı: ~/.claude/settings.json\n'));
+  } else {
+    try {
+      const settings = JSON.parse(fs.readFileSync(claudeSettings, 'utf-8'));
+      console.log(chalk.gray('  Claude Code ayarları bulundu.\n'));
+
+      // Migrate allowed tools
+      if (settings.allowList?.length > 0) {
+        const config = getConfig();
+        if (!config.policies) config.policies = {};
+        config.policies.claudeAllowedTools = settings.allowList;
+        setConfigValue('policies', config.policies);
+        console.log(chalk.green(`  ✅ ${settings.allowList.length} izinli araç migrate edildi`));
+      }
+
+      // Migrate permissions
+      if (settings.permissions) {
+        const config = getConfig();
+        config.claudePermissions = settings.permissions;
+        setConfigValue('claudePermissions', settings.permissions);
+        console.log(chalk.green('  ✅ Claude izinleri migrate edildi'));
+      }
+    } catch (err) {
+      console.log(chalk.red(`  ❌ Claude settings okuma hatası: ${err.message}`));
+    }
+  }
+
+  // Migrate Claude projects
+  if (fs.existsSync(claudeProjects)) {
+    try {
+      const projects = fs.readdirSync(claudeProjects).filter(f => {
+        const p = path.join(claudeProjects, f);
+        return fs.statSync(p).isDirectory() && !f.startsWith('.');
+      });
+
+      if (projects.length > 0) {
+        console.log(chalk.gray(`\n  Claude projeleri bulundu: ${projects.length}\n`));
+        const projectsDir = path.join(os.homedir(), '.natureco', 'claude-projects');
+        fs.mkdirSync(projectsDir, { recursive: true });
+
+        for (const project of projects) {
+          const src = path.join(claudeProjects, project);
+          const dst = path.join(projectsDir, project);
+          if (!fs.existsSync(dst)) {
+            fs.cpSync(src, dst, { recursive: true });
+            console.log(chalk.green(`  ✅ Proje kopyalandı: ${project}`));
+          } else {
+            console.log(chalk.yellow(`  ⚠ Proje zaten var, atlandı: ${project}`));
+          }
+        }
+      }
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Proje migrasyonu atlandı: ${err.message}`));
+    }
+  }
+
+  // Migrate MEMORY.md if exists
+  const memoryFile = path.join(claudeDir, '..', 'workspace', 'MEMORY.md');
+  if (fs.existsSync(memoryFile)) {
+    try {
+      const content = fs.readFileSync(memoryFile, 'utf-8');
+      const memory = {
+        name: '',
+        nickname: '',
+        botName: '',
+        facts: [{ value: 'Migrated from Claude Code', score: 5, updatedAt: new Date().toISOString() }],
+        preferences: []
+      };
+
+      const lines = content.split('\n');
+      for (const line of lines) {
+        if (line.toLowerCase().includes('name:')) {
+          memory.name = line.split(':')[1]?.trim() || '';
+        }
+        if (line.toLowerCase().includes('preference:') || line.toLowerCase().includes('favorite:')) {
+          memory.preferences.push({ value: line.split(':')[1]?.trim() || '', score: 5, updatedAt: new Date().toISOString() });
+        }
+      }
+
+      const memoryDir = path.join(os.homedir(), '.natureco', 'memory');
+      fs.mkdirSync(memoryDir, { recursive: true });
+      fs.writeFileSync(path.join(memoryDir, 'universal-provider.json'), JSON.stringify(memory, null, 2));
+      console.log(chalk.green('  ✅ Claude MEMORY.md migrate edildi'));
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Memory migrasyonu atlandı: ${err.message}`));
+    }
+  }
+
+  console.log(chalk.green('\n✅ Claude Code migration tamamlandı!\n'));
+}
+
+// ── Hermes Migration ──────────────────────────────────────────────────────────
+async function migrateHermes() {
+  console.log(chalk.yellow('\n⏳ Hermes → NatureCo migration başlıyor...\n'));
+
+  const hermesDir = path.join(os.homedir(), '.hermes');
+  const hermesConfig = path.join(hermesDir, 'config.json');
+  const hermesSessions = path.join(hermesDir, 'sessions');
+
+  if (!fs.existsSync(hermesDir)) {
+    console.log(chalk.yellow('⚠ Hermes dizini bulunamadı: ~/.hermes\n'));
+    return;
+  }
+
+  let migrated = { config: false, sessions: 0, memory: false };
+
+  // Migrate config
+  if (fs.existsSync(hermesConfig)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(hermesConfig, 'utf-8'));
+
+      const ncConfig = getConfig();
+      if (config.provider) ncConfig.providerUrl = config.provider;
+      if (config.model) ncConfig.providerModel = config.model;
+      if (config.apiKey) ncConfig.providerApiKey = config.apiKey;
+      if (config.systemPrompt) ncConfig.systemPrompt = config.systemPrompt;
+      if (config.temperature !== undefined) ncConfig.temperature = config.temperature;
+
+      setConfigValue('providerUrl', ncConfig.providerUrl);
+      setConfigValue('providerModel', ncConfig.providerModel);
+      if (config.apiKey) setConfigValue('providerApiKey', ncConfig.providerApiKey);
+      if (config.systemPrompt) setConfigValue('systemPrompt', ncConfig.systemPrompt);
+      if (config.temperature !== undefined) setConfigValue('temperature', ncConfig.temperature);
+
+      migrated.config = true;
+      console.log(chalk.green('  ✅ Hermes config migrate edildi'));
+    } catch (err) {
+      console.log(chalk.red(`  ❌ Config okuma hatası: ${err.message}`));
+    }
+  }
+
+  // Migrate sessions
+  if (fs.existsSync(hermesSessions)) {
+    try {
+      const sessions = fs.readdirSync(hermesSessions).filter(f => f.endsWith('.json'));
+      const ncSessionsDir = path.join(os.homedir(), '.natureco', 'sessions');
+      fs.mkdirSync(ncSessionsDir, { recursive: true });
+
+      for (const session of sessions) {
+        const src = path.join(hermesSessions, session);
+        const dst = path.join(ncSessionsDir, `hermes-${session}`);
+        if (!fs.existsSync(dst)) {
+          fs.copyFileSync(src, dst);
+          migrated.sessions++;
+        }
+      }
+
+      if (migrated.sessions > 0) {
+        console.log(chalk.green(`  ✅ ${migrated.sessions} Hermes oturumu migrate edildi`));
+      }
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Session migrasyonu atlandı: ${err.message}`));
+    }
+  }
+
+  // Migrate memory
+  const hermesMemory = path.join(hermesDir, 'memory.json');
+  if (fs.existsSync(hermesMemory)) {
+    try {
+      const memData = JSON.parse(fs.readFileSync(hermesMemory, 'utf-8'));
+      const ncMemoryDir = path.join(os.homedir(), '.natureco', 'memory');
+      fs.mkdirSync(ncMemoryDir, { recursive: true });
+
+      const ncMem = {
+        name: memData.userName || '',
+        nickname: '',
+        botName: 'Hermes',
+        facts: [],
+        preferences: []
+      };
+
+      if (memData.userInfo) {
+        ncMem.facts.push({ value: memData.userInfo, score: 6, updatedAt: new Date().toISOString() });
+      }
+      if (memData.context) {
+        ncMem.facts.push({ value: memData.context, score: 5, updatedAt: new Date().toISOString() });
+      }
+
+      fs.writeFileSync(path.join(ncMemoryDir, 'hermes-migrated.json'), JSON.stringify(ncMem, null, 2));
+      migrated.memory = true;
+      console.log(chalk.green('  ✅ Hermes hafızası migrate edildi'));
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Memory migrasyonu atlandı: ${err.message}`));
+    }
+  }
+
+  if (!migrated.config && migrated.sessions === 0 && !migrated.memory) {
+    console.log(chalk.yellow('  ⚠ Hiçbir veri migrate edilemedi.\n'));
+    return;
+  }
+
+  console.log(chalk.green('\n✅ Hermes migration tamamlandı!\n'));
+}
+
 module.exports = migrate;

package/src/commands/node.js

@@ -0,0 +1,98 @@
+const chalk = require('chalk');
+const os = require('os');
+const http = require('http');
+
+let nodeServer = null;
+
+function nodeCmd(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'status') return statusNode();
+  if (action === 'start') return startNode(params[0]);
+  if (action === 'stop') return stopNode();
+  if (action === 'info') return infoNode();
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco node [status|start|stop|info]\n'));
+  process.exit(1);
+}
+
+function statusNode() {
+  console.log(chalk.cyan('\n  🖥️  Node Host\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Status:')}     ${nodeServer ? chalk.green('Running on port ' + nodeServer.port) : chalk.gray('idle')}`);
+  console.log(`  ${chalk.white('Host:')}       ${os.hostname()}`);
+  console.log(`  ${chalk.white('Platform:')}   ${process.platform}`);
+  console.log(`  ${chalk.white('Memory:')}     ${Math.round(os.freemem() / 1024 / 1024)}MB free`);
+  console.log(`  ${chalk.white('CPU:')}        ${os.cpus()[0]?.model || 'unknown'}`);
+  console.log(chalk.gray('\n  Start: ') + chalk.cyan('natureco node start [port]'));
+  console.log(chalk.gray('  Info:  ') + chalk.cyan('natureco node info'));
+  console.log();
+}
+
+function startNode(portStr) {
+  if (nodeServer) {
+    console.log(chalk.yellow('\n  ⚠️  Node host already running\n'));
+    return;
+  }
+
+  const port = parseInt(portStr, 10) || 0;
+  const server = http.createServer((req, res) => {
+    if (req.url === '/health' || req.url === '/') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        status: 'ok',
+        hostname: os.hostname(),
+        platform: process.platform,
+        node: process.version,
+        uptime: Math.floor(process.uptime()),
+        memory: { free: os.freemem(), total: os.totalmem() },
+        cpus: os.cpus().length,
+        loadavg: os.loadavg()
+      }));
+    } else {
+      res.writeHead(404);
+      res.end('Not Found');
+    }
+  });
+
+  server.listen(port, () => {
+    nodeServer = server;
+    nodeServer.port = server.address().port;
+    console.log(chalk.green(`\n  ✅ Node host running on http://localhost:${nodeServer.port}\n`));
+    console.log(chalk.gray(`  Health endpoint: http://localhost:${nodeServer.port}/health\n`));
+    console.log(chalk.gray('  Press Ctrl+C to stop.\n'));
+  });
+}
+
+function stopNode() {
+  if (!nodeServer) {
+    console.log(chalk.yellow('\n  ⚠️  Node host not running\n'));
+    return;
+  }
+  nodeServer.close(() => {
+    console.log(chalk.gray('\n  🛑 Node host stopped\n'));
+    nodeServer = null;
+  });
+}
+
+function infoNode() {
+  console.log(chalk.cyan('\n  🖥️  Node Info\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Node:')}       ${process.version}`);
+  console.log(`  ${chalk.white('Platform:')}   ${process.platform} ${os.release()}`);
+  console.log(`  ${chalk.white('Arch:')}       ${process.arch}`);
+  console.log(`  ${chalk.white('Hostname:')}   ${os.hostname()}`);
+  console.log(`  ${chalk.white('CPUs:')}       ${os.cpus().length}`);
+  for (let i = 0; i < Math.min(os.cpus().length, 4); i++) {
+    console.log(`    ${chalk.gray(`${i}: ${os.cpus()[i].model}`)}`);
+  }
+  if (os.cpus().length > 4) console.log(`    ${chalk.gray(`… and ${os.cpus().length - 4} more`)}`);
+  console.log(`  ${chalk.white('Memory:')}     ${Math.round(os.totalmem() / 1024 / 1024 / 1024)}GB total, ${Math.round(os.freemem() / 1024 / 1024)}MB free`);
+  console.log(`  ${chalk.white('Load:')}       ${os.loadavg().map(l => l.toFixed(2)).join(', ')}`);
+  console.log(`  ${chalk.white('Uptime:')}     ${Math.floor(os.uptime() / 3600)}h ${Math.floor((os.uptime() % 3600) / 60)}m`);
+  console.log(`  ${chalk.white('Interfaces:')} ${Object.keys(os.networkInterfaces()).filter(k => k !== 'lo').join(', ') || 'none'}`);
+  console.log();
+}
+
+module.exports = nodeCmd;

package/src/commands/nodes.js

@@ -0,0 +1,106 @@
+const chalk = require('chalk');
+const { getConfig, saveConfig } = require('../utils/config');
+const crypto = require('crypto');
+
+function nodes(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'list') return listNodes();
+  if (action === 'pair') return pairNode(params[0]);
+  if (action === 'approve') return approveNode(params[0]);
+  if (action === 'reject') return rejectNode(params[0]);
+  if (action === 'remove') return removeNode(params[0]);
+  if (action === 'rename') return renameNode(params[0], params.slice(1).join(' '));
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco nodes [list|pair|approve|reject|remove|rename]\n'));
+  process.exit(1);
+}
+
+function listNodes() {
+  const config = getConfig();
+  const nodes = config.pairedNodes || [];
+
+  console.log(chalk.cyan('\n  🖥️  Paired Nodes\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  if (nodes.length === 0) {
+    console.log(chalk.gray('  No paired nodes.\n'));
+    return;
+  }
+
+  for (const n of nodes) {
+    console.log(`  ${chalk.green('●')} ${chalk.white(n.name || n.id)}`);
+    console.log(`    ${chalk.gray('ID:')}   ${n.id}`);
+    console.log(`    ${chalk.gray('URL:')}  ${n.url || 'local'}`);
+    console.log(`    ${chalk.gray('Key:')}  ${n.key ? n.key.substring(0, 8) + '…' : 'none'}`);
+  }
+  console.log();
+}
+
+function pairNode(url) {
+  if (!url) {
+    console.log(chalk.red('\n  ❌ Node URL gerekli\n'));
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  if (!config.pairedNodes) config.pairedNodes = [];
+
+  const id = `node_${crypto.randomBytes(8).toString('hex')}`;
+  const key = crypto.randomBytes(16).toString('hex');
+
+  config.pairedNodes.push({ id, url, key, name: url, pairedAt: new Date().toISOString() });
+  saveConfig(config);
+
+  console.log(chalk.green(`\n  ✅ Node paired: ${url}\n`));
+}
+
+function approveNode(id) {
+  console.log(chalk.green(`\n  ✅ Node approved: ${id}\n`));
+}
+
+function rejectNode(id) {
+  console.log(chalk.gray(`\n  ❌ Node rejected: ${id}\n`));
+}
+
+function removeNode(id) {
+  if (!id) {
+    console.log(chalk.red('\n  ❌ Node ID gerekli\n'));
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  const nodes = config.pairedNodes || [];
+  const idx = nodes.findIndex(n => n.id === id);
+
+  if (idx === -1) {
+    console.log(chalk.red(`\n  ❌ Node bulunamadı: ${id}\n`));
+    process.exit(1);
+  }
+
+  nodes.splice(idx, 1);
+  config.pairedNodes = nodes;
+  saveConfig(config);
+  console.log(chalk.gray(`\n  🗑️  Node removed: ${id}\n`));
+}
+
+function renameNode(id, name) {
+  if (!id || !name) {
+    console.log(chalk.red('\n  ❌ Node ID ve name gerekli\n'));
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  const node = (config.pairedNodes || []).find(n => n.id === id);
+  if (!node) {
+    console.log(chalk.red(`\n  ❌ Node bulunamadı: ${id}\n`));
+    process.exit(1);
+  }
+
+  node.name = name;
+  saveConfig(config);
+  console.log(chalk.green(`\n  ✅ Node renamed: ${name}\n`));
+}
+
+module.exports = nodes;