natureco-cli 2.23.28 → 2.23.30

package/src/commands/admin-rpc.js

@@ -0,0 +1,219 @@
+const chalk = require('chalk');
+const http = require('http');
+const { getConfig } = require('../utils/config');
+
+const ALLOWED_METHODS = [
+  'health', 'status',
+  'config.get', 'config.set',
+  'channels.status', 'channels.start', 'channels.stop',
+  'agents.list',
+  'logs.tail',
+  'cron.list', 'cron.status',
+  'tasks.list',
+  'plugins.list'
+];
+
+let serverInstance = null;
+
+function adminRpc(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'status') return statusAdmin();
+  if (action === 'start') return startAdmin(params[0]);
+  if (action === 'stop') return stopAdmin();
+  if (action === 'call') return callMethod(params[0], params.slice(1).join(' '));
+  if (action === 'methods') return listMethods();
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco admin-rpc [status|start|stop|call|methods]\n'));
+  process.exit(1);
+}
+
+function statusAdmin() {
+  const running = serverInstance !== null;
+  console.log(chalk.cyan('\n  🖥️  Admin HTTP RPC\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Server:')}       ${running ? chalk.green(`http://localhost:${serverInstance?.port || 3847}`) : chalk.red('Durduruldu')}`);
+  console.log(`  ${chalk.white('Methods:')}       ${ALLOWED_METHODS.length}`);
+  console.log(chalk.gray('\n  Commands:'));
+  console.log(chalk.cyan('    start [port]') + chalk.gray('  Start RPC server (default: 3847)'));
+  console.log(chalk.cyan('    stop') + chalk.gray('           Stop RPC server'));
+  console.log(chalk.cyan('    call <method>') + chalk.gray('  Call RPC method'));
+  console.log(chalk.cyan('    methods') + chalk.gray('       List methods'));
+  console.log();
+}
+
+function listMethods() {
+  console.log(chalk.cyan('\n  📋 Admin RPC Methods\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  for (const m of ALLOWED_METHODS) {
+    console.log(`  ${chalk.white(m)}`);
+  }
+  console.log();
+}
+
+async function callMethod(method, jsonParams) {
+  if (!method) {
+    console.log(chalk.red('\n  ❌ Method adı gerekli\n'));
+    console.log(chalk.cyan('    natureco admin-rpc call health\n'));
+    process.exit(1);
+  }
+
+  if (!ALLOWED_METHODS.includes(method)) {
+    console.log(chalk.red(`\n  ❌ Desteklenmeyen method: ${method}\n`));
+    process.exit(1);
+  }
+
+  let params = {};
+  if (jsonParams) {
+    try { params = JSON.parse(jsonParams); }
+    catch { console.log(chalk.red('\n  ❌ Geçersiz JSON\n')); process.exit(1); }
+  }
+
+  console.log(chalk.cyan(`\n  📡 Calling: ${method}\n`));
+
+  if (method === 'health') {
+    console.log(chalk.green('  ✅ System healthy'));
+    console.log(chalk.gray(`  Node: ${process.version}`));
+    console.log(chalk.gray(`  Platform: ${process.platform}`));
+    console.log(chalk.gray(`  Memory: ${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB\n`));
+    return;
+  }
+
+  if (method === 'status') {
+    const config = getConfig();
+    console.log(chalk.green('  ✅ Status\n'));
+    console.log(chalk.gray(`  Gateway: ${config.gatewayUrl || 'not configured'}`));
+    console.log(chalk.gray(`  Provider: ${config.provider || 'not set'}`));
+    console.log(chalk.gray(`  Model: ${config.model || 'not set'}\n`));
+    return;
+  }
+
+  if (method === 'plugins.list') {
+    const { loadTools } = require('../utils/tool-runner');
+    const tools = loadTools();
+    console.log(chalk.green(`  📦 ${Object.keys(tools).length} tools loaded\n`));
+    for (const [name, t] of Object.entries(tools)) {
+      console.log(`  ${chalk.white('●')} ${name} ${chalk.gray('- ' + (t.description || '').substring(0, 60))}`);
+    }
+    console.log();
+    return;
+  }
+
+  if (method === 'config.get') {
+    const config = getConfig();
+    const key = params.key;
+    if (key) {
+      const value = key.split('.').reduce((o, k) => o?.[k], config);
+      console.log(chalk.white(`  ${key}: `) + chalk.cyan(JSON.stringify(value)));
+    } else {
+      console.log(chalk.cyan(JSON.stringify(config, null, 2)));
+    }
+    console.log();
+    return;
+  }
+
+  if (method === 'logs.tail') {
+    const lines = params.lines || 20;
+    const { execSync } = require('child_process');
+    try {
+      const logPath = require('path').join(require('os').homedir(), '.natureco', 'logs', 'gateway.log');
+      const output = execSync(`tail -${lines} "${logPath}"`, { encoding: 'utf8', maxBuffer: 1024 * 1024 });
+      console.log(output);
+    } catch {
+      console.log(chalk.yellow('  ⚠️  Log bulunamadı\n'));
+    }
+    return;
+  }
+
+  console.log(chalk.yellow(`  ⚠️  Method "${method}" henüz implemente edilmedi\n`));
+}
+
+function startAdmin(portStr) {
+  if (serverInstance) {
+    console.log(chalk.yellow('\n  ⚠️  Server zaten çalışıyor\n'));
+    return;
+  }
+
+  const port = parseInt(portStr, 10) || 3847;
+
+  const server = http.createServer((req, res) => {
+    if (req.method !== 'POST') {
+      res.writeHead(405, { 'Allow': 'POST', 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: false, error: 'Method not allowed' }));
+      return;
+    }
+
+    let body = '';
+    req.on('data', chunk => { body += chunk; });
+    req.on('end', async () => {
+      try {
+        const rpc = JSON.parse(body);
+        if (!rpc.method || typeof rpc.method !== 'string') {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: 'method required' }));
+          return;
+        }
+
+        if (!ALLOWED_METHODS.includes(rpc.method)) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: `Method not allowed: ${rpc.method}` }));
+          return;
+        }
+
+        const config = getConfig();
+        let payload;
+
+        if (rpc.method === 'health') {
+          payload = { status: 'ok', node: process.version, uptime: process.uptime() };
+        } else if (rpc.method === 'status') {
+          payload = { gateway: config.gatewayUrl, provider: config.provider, model: config.model };
+        } else if (rpc.method === 'config.get') {
+          const key = rpc.params?.key;
+          payload = key ? { [key]: key.split('.').reduce((o, k) => o?.[k], config) } : config;
+        } else if (rpc.method === 'plugins.list') {
+          const { loadTools } = require('../utils/tool-runner');
+          payload = { tools: Object.keys(loadTools()) };
+        } else {
+          payload = { message: `Method "${rpc.method}" called`, params: rpc.params };
+        }
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, id: rpc.id || 'rpc-1', payload }));
+      } catch (err) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Invalid JSON' }));
+      }
+    });
+  });
+
+  serverInstance = server;
+  serverInstance.port = port;
+
+  server.listen(port, () => {
+    console.log(chalk.green(`\n  ✅ Admin RPC server started on http://localhost:${port}\n`));
+    console.log(chalk.gray('  POST requests with JSON body:'));
+    console.log(chalk.white('    { "method": "health", "id": "req-1" }'));
+    console.log(chalk.white('    { "method": "config.get", "params": { "key": "provider" } }'));
+    console.log(chalk.gray('\n  Press Ctrl+C to stop\n'));
+  });
+
+  server.on('error', (err) => {
+    console.log(chalk.red(`\n  ❌ Server error: ${err.message}\n`));
+    serverInstance = null;
+  });
+}
+
+function stopAdmin() {
+  if (!serverInstance) {
+    console.log(chalk.yellow('\n  ⚠️  Server çalışmıyor\n'));
+    return;
+  }
+
+  serverInstance.close(() => {
+    console.log(chalk.gray('\n  🛑 Admin RPC server durduruldu\n'));
+    serverInstance = null;
+  });
+}
+
+module.exports = adminRpc;

package/src/commands/agent.js

@@ -0,0 +1,89 @@
+const chalk = require('chalk');
+
+async function agent(args) {
+  const opts = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--to' || args[i] === '-t') opts.to = args[++i];
+    else if (args[i] === '--message' || args[i] === '-m') opts.message = args[++i];
+    else if (args[i] === '--channel' || args[i] === '-c') opts.channel = args[++i];
+    else if (args[i] === '--deliver') opts.deliver = true;
+    else if (args[i] === '--model') opts.model = args[++i];
+    else if (args[i] === '--provider') opts.provider = args[++i];
+    else if (!opts.action) opts.action = args[i];
+  }
+
+  if (!opts.action || opts.action === 'help') return showHelp();
+  if (opts.action === 'run') return runAgent(opts);
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${opts.action}\n`));
+  process.exit(1);
+}
+
+async function runAgent(opts) {
+  const { getConfig } = require('../utils/config');
+  const config = getConfig();
+
+  const provider = opts.provider || config.provider || 'openai';
+  const model = opts.model || config.model || 'gpt-4o';
+  const message = opts.message || 'Hello';
+
+  console.log(chalk.cyan(`\n  🤖 Agent Turn\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Message:')}  ${message}`);
+  if (opts.to) console.log(`  ${chalk.white('To:')}       ${opts.to}`);
+  if (opts.channel) console.log(`  ${chalk.white('Channel:')}  ${opts.channel}`);
+  console.log(`  ${chalk.white('Provider:')} ${provider}`);
+  console.log(`  ${chalk.white('Model:')}    ${model}`);
+  console.log(chalk.gray('\n  Running...\n'));
+
+  try {
+    const apiKey = config[`${provider}ApiKey`] || process.env[`${provider.toUpperCase()}_API_KEY`];
+    if (!apiKey) {
+      console.log(chalk.red(`  ❌ ${provider} API key gerekli\n`));
+      process.exit(1);
+    }
+
+    const baseUrl = provider === 'openai' ? 'https://api.openai.com/v1' : `https://api.${provider}.com/v1`;
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+      body: JSON.stringify({ model, messages: [{ role: 'user', content: message }], max_tokens: 2048 })
+    });
+
+    if (!response.ok) throw new Error(`API error ${response.status}`);
+
+    const data = await response.json();
+    const reply = data.choices?.[0]?.message?.content || 'No response';
+
+    console.log(chalk.white('  Response:'));
+    console.log(chalk.gray(`  ${reply.substring(0, 500)}`));
+
+    if (opts.deliver && opts.channel) {
+      console.log(chalk.gray(`\n  📨 Delivering via ${opts.channel}...`));
+    }
+
+    console.log();
+  } catch (err) {
+    console.log(chalk.red(`  ❌ ${err.message}\n`));
+    process.exit(1);
+  }
+}
+
+function showHelp() {
+  console.log(chalk.cyan('\n  🤖 Agent\n'));
+  console.log(chalk.gray('  Run one agent turn via the Gateway'));
+  console.log(chalk.gray('\n  Usage: natureco agent [options]'));
+  console.log(chalk.gray('\n  Options:'));
+  console.log(chalk.cyan('    run') + chalk.gray('                    Run an agent turn'));
+  console.log(chalk.cyan('    --message, -m <text>') + chalk.gray('  Message to send'));
+  console.log(chalk.cyan('    --to, -t <target>') + chalk.gray('     Target channel/contact'));
+  console.log(chalk.cyan('    --channel, -c <name>') + chalk.gray('  Channel to use'));
+  console.log(chalk.cyan('    --deliver') + chalk.gray('             Deliver reply via channel'));
+  console.log(chalk.cyan('    --model <model>') + chalk.gray('       Model override'));
+  console.log(chalk.cyan('    --provider <name>') + chalk.gray('    Provider override'));
+  console.log(chalk.gray('\n  Examples:'));
+  console.log(chalk.gray('    natureco agent run --message "Summarize this"'));
+  console.log(chalk.gray('    natureco agent run --to +1234 --message "Hi" --deliver\n'));
+}
+
+module.exports = agent;

package/src/commands/approvals.js

@@ -0,0 +1,53 @@
+const chalk = require('chalk');
+const { getConfig, saveConfig } = require('../utils/config');
+
+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]);
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco approvals [list|pending|approve|reject|set-policy]\n'));
+  process.exit(1);
+}
+
+function listApprovals() {
+  const config = getConfig();
+  const policy = config.execApprovalPolicy || 'auto';
+  console.log(chalk.cyan('\n  📋 Exec Approvals\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Policy:')} ${chalk.cyan(policy)}`);
+  console.log(chalk.gray('\n  Pending: use') + chalk.cyan(' natureco approvals pending'));
+  console.log();
+}
+
+function listPending() {
+  console.log(chalk.cyan('\n  ⏳ Pending Approvals\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(chalk.gray('  No pending approvals.\n'));
+}
+
+function approveReq(id) {
+  console.log(chalk.green(`\n  ✅ Approved: ${id || 'all pending'}\n`));
+}
+
+function rejectReq(id) {
+  console.log(chalk.gray(`\n  ❌ Rejected: ${id || 'all pending'}\n`));
+}
+
+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`));
+}
+
+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;

package/src/commands/bonjour.js

@@ -0,0 +1,167 @@
+const chalk = require('chalk');
+const { getConfig, saveConfig } = require('../utils/config');
+const dns = require('dns');
+const os = require('os');
+
+function discoverGateway() {
+  return new Promise((resolve) => {
+    const interfaces = os.networkInterfaces();
+    let gateway = null;
+
+    for (const [name, addrs] of Object.entries(interfaces)) {
+      if (!addrs) continue;
+      for (const addr of addrs) {
+        if (addr.family === 'IPv4' && !addr.internal) {
+          // Try common gateway addresses
+          const parts = addr.address.split('.');
+          for (const gw of [
+            `${parts[0]}.${parts[1]}.${parts[2]}.1`,
+            `${parts[0]}.${parts[1]}.${parts[2]}.254`
+          ]) {
+            const sock = new (require('net').Socket)();
+            sock.setTimeout(500);
+            sock.on('connect', () => { sock.destroy(); if (!gateway) gateway = gw; });
+            sock.on('error', () => {});
+            sock.on('timeout', () => sock.destroy());
+            sock.connect(80, gw);
+          }
+        }
+      }
+    }
+
+    setTimeout(() => resolve(gateway), 1000);
+  });
+}
+
+async function bonjour(args) {
+  const [action, ...params] = (args || []);
+
+  if (!action || action === 'scan') return scanNetwork();
+  if (action === 'discover') return discoverServices();
+  if (action === 'status') return statusBonjour();
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco bonjour [scan|discover|status]\n'));
+  process.exit(1);
+}
+
+async function scanNetwork() {
+  console.log(chalk.cyan('\n  Ağ taranıyor...\n'));
+
+  const interfaces = os.networkInterfaces();
+  const found = [];
+
+  for (const [name, addrs] of Object.entries(interfaces)) {
+    if (!addrs) continue;
+    for (const addr of addrs) {
+      if (addr.family === 'IPv4' && !addr.internal) {
+        found.push({
+          interface: name,
+          address: addr.address,
+          netmask: addr.netmask,
+          mac: addr.mac
+        });
+      }
+    }
+  }
+
+  if (found.length === 0) {
+    console.log(chalk.gray('  Ağ arayüzü bulunamadı.\n'));
+    return;
+  }
+
+  const gateway = await discoverGateway();
+
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(chalk.cyan.bold('\n  Ağ Arayüzleri\n'));
+
+  found.forEach(f => {
+    console.log(chalk.white(`  ${f.interface}`));
+    console.log(chalk.gray(`    IP: ${f.address}`));
+    console.log(chalk.gray(`    MAC: ${f.mac}`));
+  });
+
+  if (gateway) {
+    console.log(chalk.gray('\n  Varsayılan ağ geçidi: ') + chalk.cyan(gateway));
+  }
+
+  console.log(chalk.gray('\n  Service discovery için: ') + chalk.cyan('natureco bonjour discover\n'));
+}
+
+async function discoverServices() {
+  console.log(chalk.cyan('\n  Servis keşfi başlatılıyor...\n'));
+
+  // Try common ports
+  const commonServices = [
+    { name: 'HTTP', port: 80 },
+    { name: 'HTTPS', port: 443 },
+    { name: 'SSH', port: 22 },
+    { name: 'NatureCo Gateway', port: 3848 },
+    { name: 'Dashboard', port: 3849 },
+    { name: 'OpenClaw', port: 3000 },
+    { name: 'MCP', port: 3100 }
+  ];
+
+  const config = getConfig();
+  const additionalPorts = config.discoveryPorts || [];
+  const allServices = [...commonServices, ...additionalPorts.map(p => ({ name: `Port ${p}`, port: p }))];
+
+  const interfaces = os.networkInterfaces();
+  const results = [];
+
+  for (const [, addrs] of Object.entries(interfaces)) {
+    if (!addrs) continue;
+    for (const addr of addrs) {
+      if (addr.family === 'IPv4' && !addr.internal) {
+        const base = addr.address.split('.').slice(0, 3).join('.');
+        for (let i = 1; i <= 5; i++) {
+          const host = `${base}.${i}`;
+          for (const svc of allServices) {
+            try {
+              await new Promise((resolve, reject) => {
+                const sock = new (require('net').Socket)();
+                sock.setTimeout(200);
+                sock.on('connect', () => {
+                  sock.destroy();
+                  results.push({ host, port: svc.port, service: svc.name });
+                  resolve();
+                });
+                sock.on('error', () => reject());
+                sock.on('timeout', () => reject());
+                sock.connect(svc.port, host);
+              });
+            } catch {}
+          }
+        }
+      }
+    }
+  }
+
+  if (results.length === 0) {
+    console.log(chalk.gray('  Servis bulunamadı.\n'));
+    return;
+  }
+
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(chalk.cyan.bold('\n  Bulunan Servisler\n'));
+
+  results.forEach(r => {
+    console.log(`  ${chalk.green('●')} ${chalk.white(r.service)} ${chalk.gray(`→ ${r.host}:${r.port}`)}`);
+  });
+
+  console.log(chalk.gray('\n  Özel port eklemek: ') + chalk.cyan('natureco config set discoveryPorts [3000,4000]\n'));
+}
+
+function statusBonjour() {
+  console.log(chalk.gray('\n  Bonjour/mDNS Servis Keşfi\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(chalk.gray('  Ağ keşif aracı — NatureCo servislerini ve gateway\'i bulur.'));
+  console.log(chalk.gray('  Komutlar:'));
+  console.log(chalk.cyan('    scan      ') + chalk.gray('Ağ arayüzlerini ve IP\'leri listele'));
+  console.log(chalk.cyan('    discover  ') + chalk.gray('Yerel ağda NatureCo servislerini ara'));
+  console.log(chalk.gray('\n  Port yapılandırması:'));
+  console.log(chalk.gray('    Varsayılan: 3848 (Gateway), 3849 (Dashboard)'));
+  console.log(chalk.gray('    Özel: ') + chalk.cyan('natureco config set discoveryPorts [3000,4000]\n'));
+}
+
+module.exports = bonjour;