natureco-cli 2.23.29 → 2.23.31

package/src/commands/agents.js

@@ -1,8 +1,39 @@
 const chalk = require('chalk');
+const F = require('../utils/format');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 const inquirer = require('../utils/inquirer-wrapper');
 const { getConfig, saveConfig } = require('../utils/config');
 const { getBots } = require('../utils/api');
 
+const BINDINGS_FILE = path.join(os.homedir(), '.natureco', 'agent-bindings.json');
+const IDENTITIES_FILE = path.join(os.homedir(), '.natureco', 'agent-identities.json');
+
+function loadBindings() {
+  try {
+    if (fs.existsSync(BINDINGS_FILE)) return JSON.parse(fs.readFileSync(BINDINGS_FILE, 'utf8'));
+  } catch {}
+  return {};
+}
+
+function saveBindings(data) {
+  fs.mkdirSync(path.dirname(BINDINGS_FILE), { recursive: true });
+  fs.writeFileSync(BINDINGS_FILE, JSON.stringify(data, null, 2));
+}
+
+function loadIdentities() {
+  try {
+    if (fs.existsSync(IDENTITIES_FILE)) return JSON.parse(fs.readFileSync(IDENTITIES_FILE, 'utf8'));
+  } catch {}
+  return {};
+}
+
+function saveIdentities(data) {
+  fs.mkdirSync(path.dirname(IDENTITIES_FILE), { recursive: true });
+  fs.writeFileSync(IDENTITIES_FILE, JSON.stringify(data, null, 2));
+}
+
 async function agents(args) {
   const [action, ...params] = (args || []);
 
@@ -10,9 +41,13 @@ async function agents(args) {
   if (action === 'set') return setActiveAgent(params[0]);
   if (action === 'info') return agentInfo(params[0]);
   if (action === 'add') return addAgent();
+  if (action === 'bindings') return listBindings();
+  if (action === 'bind') return bindAgent(params[0], params[1]);
+  if (action === 'unbind') return unbindAgent(params[0], params[1]);
+  if (action === 'set-identity') return setIdentity(params[0], params.slice(1).join(' '));
 
   console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
-  console.log(chalk.gray('  Kullanım: natureco agents [list|set|info|add]\n'));
+  console.log(chalk.gray('  Kullanım: natureco agents [list|set|info|add|bindings|bind|unbind|set-identity]\n'));
   process.exit(1);
 }
 
@@ -20,32 +55,28 @@ async function listAgents() {
   const config = getConfig();
   const apiKey = config.providerApiKey || config.apiKey || '';
 
-  console.log(chalk.gray('\n  Agentlar yükleniyor...\n'));
+  F.info('Agentlar yükleniyor...');
 
   let botList = { bots: [] };
   try {
     botList = await getBots(apiKey);
   } catch {}
 
-  console.log(chalk.gray('  ' + '─'.repeat(48)));
-  console.log(chalk.cyan.bold('\n  Agentlar (Botlar)\n'));
+  F.header('Agents');
 
   if (!botList.bots?.length) {
-    console.log(chalk.gray('  Agent bulunamadı.'));
-    console.log(chalk.gray('  Oluşturmak için: ') + chalk.cyan('developers.natureco.me\n'));
+    F.list(['Agent bulunamadı.', 'Oluşturmak için: developers.natureco.me']);
     return;
   }
 
-  botList.bots.forEach((bot, i) => {
-    const active = config.botName === bot.name ? chalk.green(' ← aktif') : '';
-    console.log(chalk.white(`  ${i + 1}. ${bot.name}`) + active);
-    console.log(chalk.gray(`     ID      : ${bot.id}`));
-    console.log(chalk.gray(`     Provider: ${bot.ai_provider || 'groq'}`));
-    if (bot.model) console.log(chalk.gray(`     Model   : ${bot.model}`));
-    console.log('');
-  });
+  const rows = botList.bots.map(bot => [
+    bot.name + (config.botName === bot.name ? ' ← aktif' : ''),
+    bot.id,
+    bot.ai_provider || 'groq',
+    bot.model || '—'
+  ]);
+  F.table(['Name', 'ID', 'Provider', 'Model'], rows);
 
-  console.log(chalk.gray('  ' + '─'.repeat(48)));
   console.log(chalk.gray('  Değiştirmek için: ') + chalk.cyan('natureco agents set <bot-adı>\n'));
 }
 
@@ -91,7 +122,7 @@ async function agentInfo(botName) {
   const name = botName || config.botName;
 
   if (!name) {
-    console.log(chalk.gray('\n  Agent adı belirtin: natureco agents info <bot-adı>\n'));
+    F.error('Agent adı belirtin: natureco agents info <bot-adı>');
     return;
   }
 
@@ -102,33 +133,27 @@ async function agentInfo(botName) {
 
   const bot = botList.bots?.find(b => b.name === name || b.id === name);
 
-  console.log('');
-  console.log(chalk.gray('  ' + '─'.repeat(48)));
-  console.log(chalk.cyan.bold(`\n  Agent: ${name}\n`));
+  F.header('Agent: ' + name);
 
   if (bot) {
-    console.log(chalk.gray('  ID      : ') + chalk.white(bot.id));
-    console.log(chalk.gray('  Provider: ') + chalk.white(bot.ai_provider || 'groq'));
-    if (bot.model) console.log(chalk.gray('  Model   : ') + chalk.white(bot.model));
+    F.kv('ID', bot.id);
+    F.kv('Provider', bot.ai_provider || 'groq');
+    if (bot.model) F.kv('Model', bot.model);
     if (bot.system_prompt) {
-      console.log(chalk.gray('  Prompt  : ') + chalk.white(bot.system_prompt.slice(0, 80) + (bot.system_prompt.length > 80 ? '...' : '')));
+      F.kv('Prompt', bot.system_prompt.slice(0, 80) + (bot.system_prompt.length > 80 ? '...' : ''));
     }
   } else {
-    console.log(chalk.gray('  (Detay alınamadı)'));
+    F.meta('(Detay alınamadı)');
   }
 
-  // Hafıza bilgisi
   try {
     const { loadMemory } = require('../utils/memory');
     const mem = loadMemory(bot?.id || 'universal-provider');
     if (mem.name || mem.facts?.length) {
-      console.log('');
-      if (mem.name) console.log(chalk.gray('  Kullanıcı: ') + chalk.white(mem.name));
-      console.log(chalk.gray('  Hafıza   : ') + chalk.white(`${(mem.facts || []).length} bilgi`));
+      if (mem.name) F.kv('Kullanıcı', mem.name);
+      F.kv('Hafıza', (mem.facts || []).length + ' bilgi');
     }
   } catch {}
-
-  console.log('');
 }
 
 async function addAgent() {
@@ -138,4 +163,63 @@ async function addAgent() {
   console.log(chalk.gray('  Oluşturduktan sonra: ') + chalk.cyan('natureco agents list\n'));
 }
 
+// ── Bindings ──────────────────────────────────────────────────────────────────
+
+function listBindings() {
+  const bindings = loadBindings();
+  const keys = Object.keys(bindings);
+
+  F.section('Bindings (' + keys.length + ')');
+
+  if (keys.length === 0) {
+    F.meta('Henüz binding yok.');
+    return;
+  }
+
+  const items = [];
+  keys.forEach(agentId => {
+    bindings[agentId].forEach(ch => items.push(agentId + ' → ' + ch));
+  });
+  F.list(items);
+}
+
+function bindAgent(agentId, channel) {
+  if (!agentId || !channel) {
+    F.error('Kullanım: natureco agents bind <agentId> <channel>');
+    return;
+  }
+  const bindings = loadBindings();
+  if (!bindings[agentId]) bindings[agentId] = [];
+  if (!bindings[agentId].includes(channel)) bindings[agentId].push(channel);
+  saveBindings(bindings);
+  F.success('Agent ' + agentId + ' → ' + channel + ' bağlandı');
+}
+
+function unbindAgent(agentId, channel) {
+  if (!agentId || !channel) {
+    F.error('Kullanım: natureco agents unbind <agentId> <channel>');
+    return;
+  }
+  const bindings = loadBindings();
+  if (!bindings[agentId]) {
+    F.warning('Agent ' + agentId + ' için binding bulunamadı');
+    return;
+  }
+  bindings[agentId] = bindings[agentId].filter(ch => ch !== channel);
+  if (bindings[agentId].length === 0) delete bindings[agentId];
+  saveBindings(bindings);
+  F.success('Agent ' + agentId + ' → ' + channel + ' bağlantısı kaldırıldı');
+}
+
+function setIdentity(agentId, identity) {
+  if (!agentId) {
+    F.error('Kullanım: natureco agents set-identity <agentId> <identity>');
+    return;
+  }
+  const identities = loadIdentities();
+  identities[agentId] = identity || 'default';
+  saveIdentities(identities);
+  F.success('Agent ' + agentId + ' identity: ' + (identity || 'default'));
+}
+
 module.exports = agents;

package/src/commands/approvals.js

@@ -0,0 +1,214 @@
+const chalk = require('chalk');
+const F = require('../utils/format');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { getConfig, saveConfig } = require('../utils/config');
+
+const APPROVALS_FILE = path.join(os.homedir(), '.natureco', 'approvals.json');
+const ALLOWLIST_FILE = path.join(os.homedir(), '.natureco', 'approval-allowlist.json');
+
+function loadQueue() {
+  if (!fs.existsSync(APPROVALS_FILE)) return [];
+  try { return JSON.parse(fs.readFileSync(APPROVALS_FILE, 'utf-8')); }
+  catch { return []; }
+}
+
+function saveQueue(items) {
+  const dir = path.dirname(APPROVALS_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(APPROVALS_FILE, JSON.stringify(items, null, 2), 'utf-8');
+}
+
+function genId() { return Date.now().toString(36) + Math.random().toString(36).slice(2, 6); }
+
+function loadAllowlist() {
+  if (!fs.existsSync(ALLOWLIST_FILE)) return [];
+  try { return JSON.parse(fs.readFileSync(ALLOWLIST_FILE, 'utf-8')); }
+  catch { return []; }
+}
+
+function saveAllowlist(patterns) {
+  const dir = path.dirname(ALLOWLIST_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(ALLOWLIST_FILE, JSON.stringify(patterns, null, 2), 'utf-8');
+}
+
+function approvals(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'list') return listApprovals();
+  if (action === 'pending') return listPending();
+  if (action === 'approve') return approveReq(params[0]);
+  if (action === 'reject') return rejectReq(params[0]);
+  if (action === 'set-policy') return setPolicy(params[0]);
+  if (action === 'add') return addReq(params.join(' '));
+  if (action === 'get') return getReq(params[0]);
+  if (action === 'set') return setPolicy(params[0]);
+  if (action === 'allowlist' && params[0] === 'add') return allowlistAdd(params.slice(1).join(' '));
+  if (action === 'allowlist' && params[0] === 'remove') return allowlistRemove(params.slice(1).join(' '));
+  if (action === 'allowlist') return listAllowlist();
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco approvals [list|pending|approve|reject|set-policy|set|add|get|allowlist]\n'));
+  process.exit(1);
+}
+
+function listApprovals() {
+  const config = getConfig();
+  const policy = config.execApprovalPolicy || 'auto';
+  const queue = loadQueue();
+
+  F.header('Approvals');
+  F.kv('Policy', policy);
+  F.kv('Queue', `${queue.filter(r => r.status === 'pending').length} pending`);
+
+  const rows = queue.map(r => [
+    r.id,
+    r.source || 'cli',
+    r.text,
+    r.status,
+  ]);
+  F.table(['ID', 'Requester', 'Command', 'Status'], rows);
+}
+
+function listPending() {
+  const queue = loadQueue().filter(r => r.status === 'pending');
+  if (queue.length === 0) {
+    F.info('No pending approvals.');
+    return;
+  }
+
+  const rows = queue.map(r => [
+    r.id,
+    r.source || 'cli',
+    r.text,
+    r.status,
+  ]);
+  F.table(['ID', 'Requester', 'Command', 'Status'], rows);
+}
+
+function addReq(text) {
+  if (!text) {
+    console.log(chalk.red('\n  ❌ Request text gerekli\n'));
+    process.exit(1);
+  }
+  const queue = loadQueue();
+  const r = { id: genId(), text, status: 'pending', source: 'cli', createdAt: new Date().toISOString(), resolvedAt: null };
+  queue.push(r);
+  saveQueue(queue);
+  console.log(chalk.yellow(`\n  ⏳ Onay beklemede: ${r.id}\n`));
+  console.log(`  ${chalk.white(text)}`);
+  console.log(chalk.gray(`  Onaylamak için: natureco approvals approve ${r.id}`));
+  console.log();
+}
+
+function approveReq(id) {
+  const queue = loadQueue();
+  if (id) {
+    const r = queue.find(x => x.id === id);
+    if (!r) { console.log(chalk.red(`\n  ❌ Request bulunamadı: ${id}\n`)); process.exit(1); }
+    if (r.status !== 'pending') { console.log(chalk.yellow(`\n  ⚠️  "${id}" zaten ${r.status}\n`)); return; }
+    r.status = 'approved';
+    r.resolvedAt = new Date().toISOString();
+    saveQueue(queue);
+    F.success(`Approved: ${r.text}`);
+    return;
+  }
+  const pending = queue.filter(r => r.status === 'pending');
+  if (pending.length === 0) { console.log(chalk.gray('\n  Bekleyen onay yok\n')); return; }
+  for (const r of pending) { r.status = 'approved'; r.resolvedAt = new Date().toISOString(); }
+  saveQueue(queue);
+  F.success(`${pending.length} requests approved`);
+}
+
+function rejectReq(id) {
+  const queue = loadQueue();
+  if (id) {
+    const r = queue.find(x => x.id === id);
+    if (!r) { console.log(chalk.red(`\n  ❌ Request bulunamadı: ${id}\n`)); process.exit(1); }
+    if (r.status !== 'pending') { console.log(chalk.yellow(`\n  ⚠️  "${id}" zaten ${r.status}\n`)); return; }
+    r.status = 'rejected';
+    r.resolvedAt = new Date().toISOString();
+    saveQueue(queue);
+    F.error(`Rejected: ${r.text}`);
+    return;
+  }
+  const pending = queue.filter(r => r.status === 'pending');
+  if (pending.length === 0) { console.log(chalk.gray('\n  Bekleyen onay yok\n')); return; }
+  for (const r of pending) { r.status = 'rejected'; r.resolvedAt = new Date().toISOString(); }
+  saveQueue(queue);
+  F.error(`${pending.length} requests rejected`);
+}
+
+function setPolicy(policy) {
+  if (!policy || !['auto', 'always-ask', 'trusted'].includes(policy)) {
+    console.log(chalk.red('\n  ❌ Policy must be: auto, always-ask, or trusted\n'));
+    process.exit(1);
+  }
+  const config = getConfig();
+  config.execApprovalPolicy = policy;
+  saveConfig(config);
+  console.log(chalk.green(`\n  ✅ Approval policy: ${policy}\n`));
+}
+
+function getReq(id) {
+  if (!id) {
+    console.log(chalk.red('\n  ❌ Request ID gerekli\n'));
+    process.exit(1);
+  }
+  const queue = loadQueue();
+  const r = queue.find(x => x.id === id);
+  if (!r) {
+    console.log(chalk.red(`\n  ❌ Request bulunamadı: ${id}\n`));
+    process.exit(1);
+  }
+  F.kv('ID', r.id);
+  F.kv('Text', r.text);
+  F.kv('Status', r.status);
+  F.kv('Source', r.source || 'cli');
+  F.kv('Created', r.createdAt ? new Date(r.createdAt).toLocaleString() : '-');
+  F.kv('Resolved', r.resolvedAt ? new Date(r.resolvedAt).toLocaleString() : '-');
+}
+
+function listAllowlist() {
+  const patterns = loadAllowlist();
+  if (patterns.length === 0) {
+    F.info('No patterns in allowlist.');
+    return;
+  }
+  F.list(patterns);
+}
+
+function allowlistAdd(pattern) {
+  if (!pattern) {
+    console.log(chalk.red('\n  ❌ Pattern gerekli\n'));
+    process.exit(1);
+  }
+  const patterns = loadAllowlist();
+  if (patterns.includes(pattern)) {
+    F.warning(`Pattern already in allowlist: ${pattern}`);
+    return;
+  }
+  patterns.push(pattern);
+  saveAllowlist(patterns);
+  F.success(`Added to allowlist: ${pattern}`);
+}
+
+function allowlistRemove(pattern) {
+  if (!pattern) {
+    console.log(chalk.red('\n  ❌ Pattern gerekli\n'));
+    process.exit(1);
+  }
+  let patterns = loadAllowlist();
+  const initial = patterns.length;
+  patterns = patterns.filter(p => p !== pattern);
+  if (patterns.length === initial) {
+    F.warning(`Pattern not found in allowlist: ${pattern}`);
+    return;
+  }
+  saveAllowlist(patterns);
+  F.success(`Removed from allowlist: ${pattern}`);
+}
+
+module.exports = approvals;

package/src/commands/backup.js

@@ -0,0 +1,124 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const NATURECO_DIR = path.join(os.homedir(), '.natureco');
+
+function backup(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'create') return createBackup();
+  if (action === 'list') return listBackups();
+  if (action === 'restore') return restoreBackup(params.join(' '));
+  if (action === 'verify') return verifyBackup(params.join(' '));
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco backup [create|list|restore|verify]\n'));
+  process.exit(1);
+}
+
+function createBackup() {
+  const backupDir = path.join(os.homedir(), '.natureco-backups');
+  if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupFile = path.join(backupDir, `natureco-backup-${timestamp}.tar.gz`);
+
+  console.log(chalk.cyan('\n  💾 Creating backup...\n'));
+
+  if (fs.existsSync(NATURECO_DIR)) {
+    try {
+      execSync(`tar -czf "${backupFile}" -C "${path.dirname(NATURECO_DIR)}" "${path.basename(NATURECO_DIR)}"`, {
+        stdio: 'pipe',
+        encoding: 'utf8',
+        timeout: 30000
+      });
+      const size = fs.statSync(backupFile).size;
+      console.log(chalk.green(`  ✅ Backup created: ${backupFile}`));
+      console.log(chalk.gray(`  Size: ${(size / 1024).toFixed(1)} KB`));
+    } catch (err) {
+      console.log(chalk.yellow('  ⚠️  tar backup failed, trying copy...'));
+      const fallbackFile = backupFile.replace('.tar.gz', '.json');
+      const config = require('../utils/config').getConfig();
+      fs.writeFileSync(fallbackFile, JSON.stringify(config, null, 2));
+      console.log(chalk.green(`  ✅ Config backup: ${fallbackFile}`));
+    }
+  } else {
+    console.log(chalk.yellow('  ⚠️  No NatureCo directory found\n'));
+  }
+  console.log();
+}
+
+function listBackups() {
+  const backupDir = path.join(os.homedir(), '.natureco-backups');
+  console.log(chalk.cyan('\n  📋 Backups\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  if (!fs.existsSync(backupDir)) {
+    console.log(chalk.gray('  No backups found.\n'));
+    console.log(chalk.gray('  Create one: ') + chalk.cyan('natureco backup create\n'));
+    return;
+  }
+
+  const files = fs.readdirSync(backupDir).filter(f => f.startsWith('natureco-backup'));
+  if (files.length === 0) {
+    console.log(chalk.gray('  No backups found.\n'));
+    return;
+  }
+
+  for (const f of files.sort().reverse()) {
+    const stat = fs.statSync(path.join(backupDir, f));
+    const size = (stat.size / 1024).toFixed(1);
+    const date = stat.birthtime.toLocaleString();
+    console.log(`  ${chalk.cyan('●')} ${chalk.white(f)} ${chalk.gray(`(${size} KB, ${date})`)}`);
+  }
+  console.log();
+}
+
+function restoreBackup(file) {
+  if (!file) {
+    console.log(chalk.red('\n  ❌ Backup file gerekli\n'));
+    console.log(chalk.cyan('    natureco backup list'));
+    console.log(chalk.cyan('    natureco backup restore <filename>\n'));
+    process.exit(1);
+  }
+
+  const backupDir = path.join(os.homedir(), '.natureco-backups');
+  const backupFile = path.join(backupDir, file);
+
+  if (!fs.existsSync(backupFile)) {
+    console.log(chalk.red(`\n  ❌ Backup bulunamadı: ${backupFile}\n`));
+    process.exit(1);
+  }
+
+  console.log(chalk.yellow(`\n  ⚠️  Restoring ${file}...\n`));
+  try {
+    execSync(`tar -xzf "${backupFile}" -C "${os.homedir()}"`, { stdio: 'pipe', timeout: 15000 });
+    console.log(chalk.green('  ✅ Restore complete\n'));
+  } catch {
+    console.log(chalk.red('  ❌ Restore failed\n'));
+    process.exit(1);
+  }
+}
+
+function verifyBackup(file) {
+  if (!file) {
+    console.log(chalk.red('\n  ❌ Backup file gerekli\n'));
+    process.exit(1);
+  }
+
+  const backupDir = path.join(os.homedir(), '.natureco-backups');
+  const backupFile = path.join(backupDir, file);
+
+  if (!fs.existsSync(backupFile)) {
+    console.log(chalk.red(`\n  ❌ Backup bulunamadı: ${backupFile}\n`));
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(backupFile);
+  console.log(chalk.green(`\n  ✅ Backup verified: ${file} (${(stat.size / 1024).toFixed(1)} KB)\n`));
+}
+
+module.exports = backup;