natureco-cli 2.23.28 → 2.23.30

package/src/commands/policy.js

@@ -0,0 +1,176 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { getConfig, saveConfig } = require('../utils/config');
+
+function policy(args) {
+  const [action, ...params] = (args || []);
+
+  if (!action || action === 'check') return checkPolicy();
+  if (action === 'set') return setPolicy(params[0], params.slice(1).join(' '));
+  if (action === 'list') return listPolicies();
+  if (action === 'remove') return removePolicy(params[0]);
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco policy [check|set|list|remove]\n'));
+  process.exit(1);
+}
+
+const POLICY_CHECKS = [
+  {
+    id: 'node-version',
+    name: 'Node.js Versiyonu',
+    check: () => {
+      const v = process.version.slice(1).split('.')[0];
+      return parseInt(v) >= 18
+        ? { status: 'pass', message: `Node.js ${process.version}` }
+        : { status: 'fail', message: `Node.js ${process.version} (18+ gerekli)`, fix: 'Node.js güncelleyin' };
+    }
+  },
+  {
+    id: 'config-exists',
+    name: 'Config Dosyası',
+    check: () => {
+      const configFile = path.join(os.homedir(), '.natureco', 'config.json');
+      if (!fs.existsSync(configFile)) {
+        return { status: 'fail', message: 'config.json bulunamadı', fix: 'natureco setup çalıştırın' };
+      }
+      try {
+        JSON.parse(fs.readFileSync(configFile, 'utf-8'));
+        return { status: 'pass', message: 'Config geçerli JSON' };
+      } catch {
+        return { status: 'fail', message: 'Config bozuk JSON', fix: '~/.natureco/config.json düzeltin' };
+      }
+    }
+  },
+  {
+    id: 'api-key',
+    name: 'API Key',
+    check: () => {
+      const config = getConfig();
+      if (config.providerApiKey || config.apiKey || process.env.GROQ_API_KEY) {
+        return { status: 'pass', message: 'API key mevcut' };
+      }
+      return { status: 'warn', message: 'API key eksik', fix: 'natureco login veya GROQ_API_KEY env' };
+    }
+  },
+  {
+    id: 'provider-url',
+    name: 'Provider URL',
+    check: () => {
+      const config = getConfig();
+      if (config.providerUrl) {
+        return { status: 'pass', message: config.providerUrl };
+      }
+      return { status: 'warn', message: 'Provider ayarlanmamış', fix: 'natureco setup' };
+    }
+  },
+  {
+    id: 'git-config',
+    name: 'Git Yapılandırması',
+    check: () => {
+      try {
+        const { execSync } = require('child_process');
+        const name = execSync('git config user.name', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        const email = execSync('git config user.email', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        if (name && email) return { status: 'pass', message: `${name} <${email}>` };
+        return { status: 'warn', message: 'Git user.name/email eksik', fix: 'git config --global user.name "Adınız"' };
+      } catch {
+        return { status: 'warn', message: 'Git repo değil', fix: 'git init' };
+      }
+    }
+  },
+  {
+    id: 'disk-space',
+    name: 'Disk Alanı',
+    check: () => {
+      try {
+        const drive = path.parse(os.homedir()).root.replace(':', '');
+        const { execSync } = require('child_process');
+        const output = execSync(`powershell -Command "Get-PSDrive -Name ${drive} | Select-Object -ExpandProperty Free"`, { encoding: 'utf-8' }).trim();
+        const free = parseInt(output);
+        if (isNaN(free)) return { status: 'pass', message: 'Kontrol edilemedi' };
+        const freeGB = free / 1e9;
+        if (freeGB < 0.5) return { status: 'fail', message: `Sadece ${freeGB.toFixed(1)}GB boş`, fix: 'Disk temizliği yapın' };
+        return { status: 'pass', message: `${freeGB.toFixed(1)}GB boş alan` };
+      } catch {
+        return { status: 'pass', message: 'Kontrol edilemedi' };
+      }
+    }
+  }
+];
+
+function checkPolicy() {
+  console.log(chalk.cyan.bold('\n  Workspace Uyumluluk Politikası\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  let passed = 0;
+  let failed = 0;
+  let warnings = 0;
+
+  for (const check of POLICY_CHECKS) {
+    const result = check.check();
+    if (result.status === 'pass') {
+      console.log(`  ${chalk.green('✓')} ${check.name}: ${chalk.white(result.message)}`);
+      passed++;
+    } else if (result.status === 'fail') {
+      console.log(`  ${chalk.red('✗')} ${check.name}: ${chalk.white(result.message)}`);
+      console.log(chalk.gray(`    Düzeltme: ${result.fix}`));
+      failed++;
+    } else {
+      console.log(`  ${chalk.yellow('⚠')} ${check.name}: ${chalk.white(result.message)}`);
+      if (result.fix) console.log(chalk.gray(`    Öneri: ${result.fix}`));
+      warnings++;
+    }
+  }
+
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(chalk.gray(`  Geçti: ${passed} | Uyarı: ${warnings} | Hata: ${failed}\n`));
+}
+
+function setPolicy(key, value) {
+  if (!key) {
+    console.log(chalk.red('\n  ❌ Politika adı gerekli\n'));
+    return;
+  }
+  const config = getConfig();
+  if (!config.policies) config.policies = {};
+  config.policies[key] = value;
+  saveConfig(config);
+  console.log(chalk.green(`\n  ✓ Politika ayarlandı: ${key} = ${value}\n`));
+}
+
+function listPolicies() {
+  const config = getConfig();
+  const policies = config.policies || {};
+
+  if (Object.keys(policies).length === 0) {
+    console.log(chalk.gray('\n  Tanımlı politika yok.\n'));
+    return;
+  }
+
+  console.log(chalk.cyan.bold('\n  Tanımlı Politikalar\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  for (const [key, value] of Object.entries(policies)) {
+    console.log(`  ${chalk.white(key)}: ${chalk.cyan(value)}`);
+  }
+  console.log('');
+}
+
+function removePolicy(key) {
+  if (!key) {
+    console.log(chalk.red('\n  ❌ Politika adı gerekli\n'));
+    return;
+  }
+  const config = getConfig();
+  if (config.policies?.[key]) {
+    delete config.policies[key];
+    saveConfig(config);
+    console.log(chalk.green(`\n  ✓ Politika silindi: ${key}\n`));
+  } else {
+    console.log(chalk.yellow(`\n  ⚠ Politika bulunamadı: ${key}\n`));
+  }
+}
+
+module.exports = policy;

package/src/commands/proxy.js

@@ -0,0 +1,155 @@
+const chalk = require('chalk');
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+
+let proxyInstance = null;
+let captured = [];
+let forwardUrl = null;
+
+function proxy(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'status') return statusProxy();
+  if (action === 'start') return startProxy(params);
+  if (action === 'stop') return stopProxy();
+  if (action === 'capture') return showCapture();
+  if (action === 'clear') return clearCapture();
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco proxy [status|start|stop|capture|clear]\n'));
+  process.exit(1);
+}
+
+function statusProxy() {
+  console.log(chalk.cyan('\n  🔍 Debug Proxy\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Status:')}  ${proxyInstance ? chalk.green('Running') : chalk.red('Stopped')}`);
+  if (proxyInstance) {
+    console.log(`  ${chalk.white('Port:')}    ${proxyInstance.port}`);
+    console.log(`  ${chalk.white('Forward:')} ${forwardUrl ? chalk.cyan(forwardUrl) : chalk.gray('(none)')}`);
+    console.log(`  ${chalk.white('Captured:')} ${captured.length} request(s)`);
+  }
+  console.log(chalk.gray('\n  Examples:'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy start'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy start 9090'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy start 8080 --forward http://localhost:3000'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy capture'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy clear'));
+  console.log(chalk.gray('  ') + chalk.cyan('natureco proxy stop'));
+  console.log();
+}
+
+function startProxy(params) {
+  if (proxyInstance) {
+    console.log(chalk.yellow('\n  ⚠️  Proxy already running\n'));
+    return;
+  }
+
+  const port = parseInt(params[0], 10) || 8080;
+  const fwdIdx = params.indexOf('--forward');
+  if (fwdIdx !== -1 && params[fwdIdx + 1]) {
+    forwardUrl = params[fwdIdx + 1];
+  }
+
+  captured = [];
+
+  const server = http.createServer((req, res) => {
+    const chunks = [];
+    req.on('data', chunk => chunks.push(chunk));
+    req.on('end', () => {
+      const body = Buffer.concat(chunks).toString();
+      const entry = {
+        id: captured.length + 1,
+        timestamp: new Date().toISOString(),
+        method: req.method,
+        url: req.url,
+        headers: req.headers,
+        body: body ? body.substring(0, 2000) : null
+      };
+      captured.push(entry);
+      if (captured.length > 200) captured.shift();
+
+      console.log(chalk.gray(`  [${entry.id}] ${chalk.cyan(req.method)} ${req.url}`));
+
+      if (forwardUrl) {
+        try {
+          const target = new URL(req.url, forwardUrl);
+          const proxyReq = http.request({
+            hostname: target.hostname,
+            port: target.port || 80,
+            path: target.pathname + target.search,
+            method: req.method,
+            headers: { ...req.headers, host: target.host }
+          }, proxyRes => {
+            let proxyBody = '';
+            proxyRes.on('data', c => proxyBody += c);
+            proxyRes.on('end', () => {
+              res.writeHead(proxyRes.statusCode, proxyRes.headers);
+              res.end(proxyBody);
+            });
+          });
+          proxyReq.on('error', () => {
+            res.writeHead(502);
+            res.end('Bad Gateway');
+          });
+          if (body) proxyReq.write(body);
+          proxyReq.end();
+        } catch {
+          res.writeHead(502);
+          res.end('Bad Gateway');
+        }
+      } else {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, id: entry.id, captured: captured.length }));
+      }
+    });
+  });
+
+  proxyInstance = server;
+  proxyInstance.port = port;
+  server.listen(port, () => {
+    console.log(chalk.green(`\n  🔍 Debug proxy on http://localhost:${port}\n`));
+    if (forwardUrl) console.log(chalk.gray(`  Forwarding to: ${forwardUrl}\n`));
+    console.log(chalk.gray('  Captured requests shown below. Press Ctrl+C to stop.\n'));
+  });
+}
+
+function stopProxy() {
+  if (!proxyInstance) {
+    console.log(chalk.yellow('\n  ⚠️  Proxy not running\n'));
+    return;
+  }
+  proxyInstance.close(() => {
+    console.log(chalk.gray('\n  🛑 Proxy stopped\n'));
+    proxyInstance = null;
+    forwardUrl = null;
+  });
+}
+
+function showCapture() {
+  if (captured.length === 0) {
+    console.log(chalk.gray('\n  No captured requests.\n'));
+    return;
+  }
+
+  console.log(chalk.cyan(`\n  📋 Captured Requests (${captured.length})\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(64)));
+
+  for (const entry of captured.slice(-20)) {
+    const time = entry.timestamp.slice(11, 19);
+    console.log(`  ${chalk.gray(`[${entry.id}]`)} ${chalk.cyan(entry.method)} ${chalk.white(entry.url)}  ${chalk.gray(time)}`);
+    if (entry.body) {
+      const preview = entry.body.length > 200 ? entry.body.substring(0, 200) + '…' : entry.body;
+      console.log(`    ${chalk.gray(preview)}`);
+    }
+  }
+  console.log();
+}
+
+function clearCapture() {
+  captured = [];
+  console.log(chalk.gray('\n  🗑️  Captured requests cleared\n'));
+}
+
+module.exports = proxy;

package/src/commands/qr.js

@@ -0,0 +1,28 @@
+const chalk = require('chalk');
+const crypto = require('crypto');
+
+function qr(args) {
+  const data = args.join(' ') || generatePairingData();
+
+  console.log(chalk.cyan('\n  📱 QR Pairing Code\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  const code = crypto.randomBytes(4).toString('hex').toUpperCase();
+  const expiresAt = new Date(Date.now() + 15 * 60 * 1000);
+
+  console.log(`  ${chalk.white('Pairing Code:')} ${chalk.bold.yellow(code)}`);
+  console.log(`  ${chalk.white('Expires:')}     ${chalk.gray(expiresAt.toLocaleString())}`);
+  console.log();
+  console.log(chalk.gray('  To pair a device, run on the device:'));
+  console.log(chalk.cyan('    natureco device-pair verify ') + chalk.yellow(code));
+  console.log();
+  console.log(chalk.gray('  Or scan with the NatureCo mobile app.'));
+  console.log();
+}
+
+function generatePairingData() {
+  const id = crypto.randomBytes(8).toString('hex');
+  return JSON.stringify({ id, timestamp: Date.now() });
+}
+
+module.exports = qr;

package/src/commands/sandbox.js

@@ -0,0 +1,125 @@
+const chalk = require('chalk');
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SANDBOX_DIR = path.join(os.tmpdir(), 'natureco-sandboxes');
+
+function sandbox(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'list') return listSandboxes();
+  if (action === 'create') return createSandbox(params[0]);
+  if (action === 'destroy') return destroySandbox(params[0]);
+  if (action === 'exec') return execSandbox(params[0], params.slice(1).join(' '));
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco sandbox [list|create|destroy|exec]\n'));
+  process.exit(1);
+}
+
+function getDirSandboxes() {
+  if (!fs.existsSync(SANDBOX_DIR)) return [];
+  return fs.readdirSync(SANDBOX_DIR).filter(name => {
+    const stat = fs.statSync(path.join(SANDBOX_DIR, name));
+    return stat.isDirectory();
+  });
+}
+
+function listSandboxes() {
+  console.log(chalk.cyan('\n  📦 Sandbox Containers\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  // Dir-based sandboxes
+  const dirSandboxes = getDirSandboxes();
+  if (dirSandboxes.length > 0) {
+    for (const name of dirSandboxes) {
+      const dir = path.join(SANDBOX_DIR, name);
+      const files = fs.readdirSync(dir).length;
+      const created = fs.statSync(dir).birthtime;
+      console.log(`  ${chalk.green('●')} ${chalk.white(name)}  ${chalk.gray(`(${files} file(s), ${created.toISOString().slice(0, 10)})`)}`);
+    }
+  }
+
+  // Docker sandboxes
+  try {
+    const dockerOut = execSync('docker ps --filter "name=natureco-sandbox" --format "{{.ID}}\t{{.Image}}\t{{.Status}}\t{{.Names}}" 2>nul', { encoding: 'utf8', timeout: 5000, stdio: 'pipe' }).trim();
+    if (dockerOut) {
+      for (const line of dockerOut.split('\n')) {
+        const [id, image, status, name] = line.split('\t');
+        console.log(`  ${chalk.blue('●')} ${chalk.white(name || id)}  ${chalk.gray(`${image} — ${status}`)}`);
+      }
+    }
+  } catch {}
+
+  if (dirSandboxes.length === 0) {
+    console.log(chalk.gray('  No sandboxes found.\n'));
+    console.log(chalk.gray('  Create one:') + chalk.cyan(' natureco sandbox create [name]\n'));
+    return;
+  }
+  console.log();
+}
+
+function createSandbox(name) {
+  const sandboxName = name || `sandbox-${Date.now()}`;
+  const dir = path.join(SANDBOX_DIR, sandboxName);
+
+  if (fs.existsSync(dir)) {
+    console.log(chalk.red(`\n  ❌ Sandbox '${sandboxName}' already exists\n`));
+    process.exit(1);
+  }
+
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, '.natureco-sandbox'), JSON.stringify({ created: new Date().toISOString(), name: sandboxName }));
+
+  console.log(chalk.green(`\n  ✅ Sandbox created: ${sandboxName}\n`));
+  console.log(chalk.gray(`  Directory: ${dir}\n`));
+  console.log(chalk.gray('  Usage:') + chalk.cyan(` natureco sandbox exec ${sandboxName} "node -e 'console.log(\\"hello\\")'"`) + '\n');
+}
+
+function destroySandbox(name) {
+  if (!name) {
+    console.log(chalk.red('\n  ❌ Sandbox name gerekli\n'));
+    process.exit(1);
+  }
+
+  const dir = path.join(SANDBOX_DIR, name);
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+    console.log(chalk.gray(`  🗑️  Dir sandbox destroyed: ${name}\n`));
+  }
+
+  try {
+    execSync(`docker rm -f ${name} 2>nul`, { stdio: 'pipe', timeout: 10000 });
+    console.log(chalk.gray(`  🗑️  Docker sandbox destroyed: ${name}\n`));
+  } catch {}
+}
+
+function execSandbox(name, command) {
+  if (!name || !command) {
+    console.log(chalk.red('\n  ❌ Sandbox name ve command gerekli\n'));
+    console.log(chalk.gray('  Kullanım: natureco sandbox exec <name> <command>\n'));
+    process.exit(1);
+  }
+
+  const dir = path.join(SANDBOX_DIR, name);
+  if (!fs.existsSync(dir)) {
+    console.log(chalk.red(`\n  ❌ Sandbox '${name}' not found\n`));
+    console.log(chalk.gray('  Create one:') + chalk.cyan(` natureco sandbox create ${name}`) + '\n');
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan(`\n  🏃 Executing in sandbox '${name}': ${command}\n`));
+
+  try {
+    const result = execSync(command, { cwd: dir, encoding: 'utf8', timeout: 30000, stdio: 'inherit' });
+    return result;
+  } catch (err) {
+    if (err.status !== undefined) process.exit(err.status);
+    console.log(chalk.red(`  ❌ ${err.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = sandbox;

package/src/commands/secrets.js

@@ -0,0 +1,118 @@
+const chalk = require('chalk');
+const { getConfig, saveConfig } = require('../utils/config');
+
+function secrets(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'list') return listSecrets();
+  if (action === 'set') return setSecret(params[0], params.slice(1).join(' '));
+  if (action === 'get') return getSecret(params[0]);
+  if (action === 'unset') return unsetSecret(params[0]);
+  if (action === 'audit') return auditSecrets();
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco secrets [list|set|get|unset|audit]\n'));
+  process.exit(1);
+}
+
+function listSecrets() {
+  const config = getConfig();
+  const secretKeys = Object.keys(config).filter(k =>
+    k.toLowerCase().includes('key') || k.toLowerCase().includes('token') || k.toLowerCase().includes('secret')
+  );
+
+  console.log(chalk.cyan('\n  🔐 Secrets\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  if (secretKeys.length === 0) {
+    console.log(chalk.gray('  No secrets stored.\n'));
+    return;
+  }
+
+  for (const key of secretKeys.sort()) {
+    const val = config[key];
+    const masked = val ? val.substring(0, 6) + '…' + val.slice(-4) : '(empty)';
+    console.log(`  ${chalk.white(key)}: ${chalk.gray(masked)}`);
+  }
+  console.log();
+}
+
+function setSecret(key, value) {
+  if (!key || !value) {
+    console.log(chalk.red('\n  ❌ key ve value gerekli\n'));
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  config[key] = value;
+  saveConfig(config);
+  console.log(chalk.green(`\n  ✅ Secret set: ${key}\n`));
+}
+
+function getSecret(key) {
+  if (!key) {
+    console.log(chalk.red('\n  ❌ key gerekli\n'));
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  const value = config[key];
+
+  if (!value) {
+    console.log(chalk.yellow(`\n  ⚠️  Secret not found: ${key}\n`));
+    return;
+  }
+
+  console.log(chalk.cyan(`\n  ${key}: ${chalk.white(value)}\n`));
+}
+
+function unsetSecret(key) {
+  if (!key) {
+    console.log(chalk.red('\n  ❌ key gerekli\n'));
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  delete config[key];
+  saveConfig(config);
+  console.log(chalk.gray(`\n  🗑️  Secret removed: ${key}\n`));
+}
+
+function auditSecrets() {
+  const config = getConfig();
+  const secrets = Object.keys(config).filter(k =>
+    k.toLowerCase().includes('key') || k.toLowerCase().includes('token') || k.toLowerCase().includes('secret')
+  );
+
+  const envKeys = ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'GROQ_API_KEY', 'TAVILY_API_KEY',
+    'ELEVENLABS_API_KEY', 'DEEPGRAM_API_KEY', 'FAL_KEY', 'TOGETHER_API_KEY',
+    'PUSHOVER_TOKEN', 'PUSHOVER_USER', 'NTFY_TOPIC', 'NTFY_SERVER',
+    'TWILIO_SID', 'TWILIO_TOKEN', 'TWILIO_FROM', 'SUNO_API_KEY', 'UDIO_API_KEY',
+    'VYDRA_API_KEY', 'SLACK_BOT_TOKEN', 'DISCORD_BOT_TOKEN', 'TELEGRAM_BOT_TOKEN',
+    'WHATSAPP_API_KEY'
+  ];
+
+  console.log(chalk.cyan('\n  🔐 Secrets Audit\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  console.log(chalk.white('\n  Config Secrets:'));
+  for (const key of secrets.sort()) {
+    const val = config[key];
+    const status = val ? chalk.green('set') : chalk.red('empty');
+    console.log(`    ${chalk.gray('●')} ${key}: ${status}`);
+  }
+
+  console.log(chalk.white('\n  Environment Variables:'));
+  let found = 0;
+  for (const envKey of envKeys) {
+    if (process.env[envKey]) {
+      console.log(`    ${chalk.green('●')} ${envKey}: ${chalk.green('set')}`);
+      found++;
+    }
+  }
+  if (found === 0) console.log(chalk.gray('    (none set in environment)'));
+
+  console.log(chalk.gray(`\n  Total: ${secrets.length} config + ${found} env\n`));
+}
+
+module.exports = secrets;