natureco-cli 2.23.29 → 2.23.31

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,306 @@
+const chalk = require('chalk');
+const http = require('http');
+const https = require('https');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { URL } = require('url');
+
+const PROXY_STATE_FILE = path.join(os.homedir(), '.natureco', 'proxy-state.json');
+
+function getState() {
+  if (!fs.existsSync(PROXY_STATE_FILE)) {
+    return { coverage: {}, sessions: [], blobCache: {}, queryLogs: [] };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(PROXY_STATE_FILE, 'utf8'));
+  } catch {
+    return { coverage: {}, sessions: [], blobCache: {}, queryLogs: [] };
+  }
+}
+
+function saveState(state) {
+  const dir = path.dirname(PROXY_STATE_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(PROXY_STATE_FILE, JSON.stringify(state, null, 2), 'utf8');
+}
+
+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();
+  if (action === 'run') return cmdRun();
+  if (action === 'coverage') return cmdCoverage();
+  if (action === 'sessions') return cmdSessions();
+  if (action === 'query') return cmdQuery(params[0]);
+  if (action === 'blob') return cmdBlob(params[0]);
+  if (action === 'purge') return cmdPurge();
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco proxy [status|start|stop|capture|clear|run|coverage|sessions|query|blob|purge]\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  Commands:'));
+  console.log(chalk.gray('    status                          Show proxy status'));
+  console.log(chalk.gray('    start [port] [--forward <url>]  Start proxy server'));
+  console.log(chalk.gray('    stop                            Stop proxy server'));
+  console.log(chalk.gray('    capture                         Show captured requests'));
+  console.log(chalk.gray('    clear                           Clear captured requests'));
+  console.log(chalk.gray('    run                             Run proxy (stub)'));
+  console.log(chalk.gray('    coverage                        Show proxy coverage stats'));
+  console.log(chalk.gray('    sessions                        List proxy sessions'));
+  console.log(chalk.gray('    query <pattern>                 Query proxy logs'));
+  console.log(chalk.gray('    blob <hash>                     Get blob by hash'));
+  console.log(chalk.gray('    purge                           Purge proxy cache'));
+  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'));
+}
+
+function cmdRun() {
+  console.log(chalk.green('\n  ▶️  Proxy run would start proxy server\n'));
+  console.log(chalk.gray('  (Stub — implement actual proxy server startup here)\n'));
+}
+
+function cmdCoverage() {
+  const state = getState();
+
+  console.log(chalk.cyan('\n  📊 Proxy Coverage Stats\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  const coverage = state.coverage || {};
+  const keys = Object.keys(coverage);
+
+  if (keys.length === 0) {
+    console.log(chalk.gray('  No coverage data recorded yet.\n'));
+    return;
+  }
+
+  for (const key of keys) {
+    const c = coverage[key];
+    console.log(chalk.white(`  ${key}`));
+    console.log(chalk.gray(`    Count: ${c.count || 0}`));
+    if (c.lastSeen) console.log(chalk.gray(`    Last seen: ${c.lastSeen}`));
+    if (c.avgResponseTime) console.log(chalk.gray(`    Avg response time: ${c.avgResponseTime}ms`));
+    console.log();
+  }
+}
+
+function cmdSessions() {
+  const state = getState();
+
+  console.log(chalk.cyan('\n  🔌 Proxy Sessions\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  const sessions = state.sessions || [];
+
+  if (sessions.length === 0) {
+    console.log(chalk.gray('  No sessions recorded.\n'));
+    return;
+  }
+
+  for (const s of sessions) {
+    console.log(chalk.white(`  [${s.id}]`), chalk.gray(`${s.host || 'unknown'} — ${s.started || '?'}`));
+  }
+  console.log();
+}
+
+function cmdQuery(pattern) {
+  const state = getState();
+
+  if (!pattern) {
+    console.log(chalk.red('\n  ❌ Query pattern is required.\n'));
+    console.log(chalk.gray('  Usage: natureco proxy query <pattern>\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan(`\n  🔎 Proxy Logs matching: ${pattern}\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  const logs = state.queryLogs || [];
+  const matching = logs.filter(l =>
+    (l.url && l.url.includes(pattern)) ||
+    (l.method && l.method.includes(pattern)) ||
+    (l.body && l.body.includes(pattern))
+  );
+
+  if (matching.length === 0) {
+    console.log(chalk.gray('  No matching logs found.\n'));
+    return;
+  }
+
+  for (const log of matching.slice(-20)) {
+    console.log(`  ${chalk.gray(`[${log.id}]`)} ${chalk.cyan(log.method)} ${chalk.white(log.url)}`);
+  }
+  console.log(chalk.gray(`  Showing ${Math.min(matching.length, 20)} of ${matching.length} result(s)\n`));
+}
+
+function cmdBlob(hash) {
+  const state = getState();
+
+  if (!hash) {
+    console.log(chalk.red('\n  ❌ Blob hash is required.\n'));
+    console.log(chalk.gray('  Usage: natureco proxy blob <hash>\n'));
+    process.exit(1);
+  }
+
+  const blobCache = state.blobCache || {};
+  const blob = blobCache[hash];
+
+  if (!blob) {
+    console.log(chalk.yellow(`\n  ⚠️  Blob not found: ${hash}\n`));
+    return;
+  }
+
+  console.log(chalk.cyan('\n  💾 Blob\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(chalk.white(`  Hash: ${hash}`));
+  console.log(chalk.white(`  Size: ${blob.size || 'unknown'} bytes`));
+  console.log(chalk.white(`  Type: ${blob.type || 'unknown'}`));
+  console.log(chalk.white(`  Cached: ${blob.cached || 'unknown'}`));
+  console.log(chalk.gray('  (Stub — actual blob retrieval requires blob storage backend)\n'));
+}
+
+function cmdPurge() {
+  const state = getState();
+
+  state.coverage = {};
+  state.sessions = [];
+  state.blobCache = {};
+  state.queryLogs = [];
+  saveState(state);
+
+  console.log(chalk.green('\n  🧹 Proxy cache purged\n'));
+}
+
+module.exports = proxy;

package/src/commands/qr.js

@@ -0,0 +1,70 @@
+const chalk = require('chalk');
+const crypto = require('crypto');
+const qrcode = require('qrcode-terminal');
+
+function qr(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'show') return showQR(params.join(' '));
+  if (action === 'generate') return generateQR(params.join(' '));
+  if (action === 'verify') return verifyCode(params[0]);
+
+  console.log(chalk.cyan('\n  📱 QR Code\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  const code = crypto.randomBytes(4).toString('hex').toUpperCase();
+  const data = JSON.stringify({ id: crypto.randomBytes(8).toString('hex'), code, timestamp: Date.now() });
+  const expiresAt = new Date(Date.now() + 15 * 60 * 1000);
+
+  qrcode.generate(data, { small: true }, qrCode => {
+    console.log(qrCode);
+    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 the QR code with the NatureCo mobile app.'));
+    console.log();
+  });
+}
+
+function showQR(data) {
+  const content = data || JSON.stringify({
+    id: crypto.randomBytes(8).toString('hex'),
+    timestamp: Date.now(),
+    type: 'pairing',
+    version: 1,
+  });
+  console.log(chalk.cyan('\n  📱 QR Code\n'));
+  qrcode.generate(content, { small: true }, qrCode => {
+    console.log(qrCode);
+    if (data) {
+      console.log(`  ${chalk.gray('Data:')} ${chalk.white(data.substring(0, 80))}`);
+    }
+    console.log();
+  });
+}
+
+function generateQR(text) {
+  if (!text) {
+    console.log(chalk.red('\n  ❌ QR için veri gerekli\n'));
+    console.log(chalk.gray('  Örnek: natureco qr generate "https://natureco.me/pair?code=ABC"\n'));
+    process.exit(1);
+  }
+  console.log(chalk.cyan('\n  📱 QR: ') + chalk.white(text) + '\n');
+  qrcode.generate(text, { small: false }, qrCode => {
+    console.log(qrCode);
+    console.log();
+  });
+}
+
+function verifyCode(code) {
+  if (!code) {
+    console.log(chalk.red('\n  ❌ Kod gerekli\n'));
+    process.exit(1);
+  }
+  console.log(chalk.cyan('\n  ✅ Pairing code verified: ') + chalk.bold.yellow(code) + '\n');
+}
+
+module.exports = qr;