natureco-cli 2.23.29 → 2.23.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "2.23.29",
+  "version": "2.23.31",
   "description": "NatureCo AI Bot Terminal Interface",
   "bin": {
     "natureco": "bin/natureco.js"

package/src/commands/acp.js

@@ -0,0 +1,39 @@
+const chalk = require('chalk');
+
+function acp(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'status') return cmdStatus();
+  if (action === 'info') return cmdInfo();
+
+  console.log(chalk.red(`\n  Unknown acp action: ${action}\n`));
+  console.log(chalk.gray('  Usage: natureco acp <action>'));
+  console.log(chalk.gray('  Actions: status, info\n'));
+  process.exit(1);
+}
+
+function cmdStatus() {
+  console.log(chalk.cyan('\n  ACP (Agent Communication Protocol) Status\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Endpoint:')}  ${chalk.green('http://127.0.0.1:3847/acp')}`);
+  console.log(`  ${chalk.white('Status:')}    ${chalk.gray('Stub — no real implementation')}`);
+  console.log('');
+  console.log(chalk.gray('  Available endpoints:'));
+  console.log(chalk.gray('    GET  /acp           — Protocol root'));
+  console.log(chalk.gray('    GET  /acp/health    — Health check'));
+  console.log(chalk.gray('    POST /acp/message   — Send agent message'));
+  console.log(chalk.gray('    GET  /acp/agents    — List agents'));
+  console.log('');
+}
+
+function cmdInfo() {
+  console.log(chalk.cyan('\n  ACP Protocol Info\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Protocol:')}  ${chalk.cyan('Agent Communication Protocol')}`);
+  console.log(`  ${chalk.white('Version:')}   ${chalk.cyan('1.0.0')}`);
+  console.log(`  ${chalk.white('Port:')}      ${chalk.cyan('3847')}`);
+  console.log(`  ${chalk.white('Transport:')} ${chalk.cyan('HTTP/JSON')}`);
+  console.log('');
+}
+
+module.exports = acp;

package/src/commands/admin-rpc.js

@@ -0,0 +1,302 @@
+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;
+  }
+
+  if (method === 'config.set') {
+    const { setConfigValue } = require('../utils/config');
+    if (!params.key) { console.log(chalk.red('\n  ❌ params.key gerekli\n')); process.exit(1); }
+    setConfigValue(params.key, params.value);
+    console.log(chalk.green(`\n  ✅ config.${params.key} = ${JSON.stringify(params.value)}\n`));
+    return;
+  }
+
+  if (method === 'channels.status' || method === 'channels.start' || method === 'channels.stop') {
+    const { getAllConfig } = require('../utils/config');
+    const cfg = getAllConfig();
+    const channels = ['telegram', 'discord', 'slack', 'whatsapp'];
+    console.log(chalk.cyan(`\n  📡 Channel: ${method}\n`));
+    if (method === 'channels.status') {
+      for (const ch of channels) {
+        const token = cfg[`${ch}Token`];
+        console.log(`  ${token ? chalk.green('●') : chalk.gray('○')} ${ch} ${token ? chalk.gray('(configured)') : chalk.gray('(not set)')}`);
+      }
+    } else {
+      const ch = params.name || 'all';
+      console.log(chalk.gray(`  ${method.split('.')[1]} ${ch} (simulated)\n`));
+    }
+    console.log();
+    return;
+  }
+
+  if (method === 'agents.list') {
+    const { listTasks, getTaskSummary } = require('../utils/background');
+    const tasks = listTasks({ limit: 20 });
+    const summary = getTaskSummary();
+    console.log(chalk.cyan(`\n  👤 Agents (${summary.active} active, ${summary.total} total)\n`));
+    console.log(chalk.gray('  ' + '─'.repeat(48)));
+    for (const t of tasks.slice(0, 10)) {
+      const icon = t.status === 'succeeded' ? chalk.green('✓') : t.status === 'running' ? chalk.yellow('●') : chalk.gray('○');
+      console.log(`  ${icon} ${chalk.white(t.message || '(no message)')}`);
+      console.log(chalk.gray(`     [${t.id}] ${t.runtime} — ${t.status}`));
+    }
+    console.log();
+    return;
+  }
+
+  if (method === 'cron.list' || method === 'cron.status') {
+    const { getConfig } = require('../utils/config');
+    const config = getConfig();
+    const jobs = config.cronJobs || [];
+    console.log(chalk.cyan(`\n  ⏰ ${method} (${jobs.length} jobs)\n`));
+    if (jobs.length === 0) {
+      console.log(chalk.gray('  Cron job yapılandırılmamış.\n'));
+      return;
+    }
+    for (const j of jobs) {
+      console.log(`  ${chalk.white(j.name || '(unnamed)')} — ${chalk.gray(j.schedule || j.interval)}`);
+    }
+    console.log();
+    return;
+  }
+
+  if (method === 'tasks.list') {
+    const { listTasks, getTaskSummary } = require('../utils/background');
+    const tasks = listTasks({ limit: 20 });
+    const summary = getTaskSummary();
+    console.log(chalk.cyan(`\n  📋 Tasks (${summary.active} active, ${summary.total} total)\n`));
+    for (const t of tasks.slice(0, 15)) {
+      console.log(`  ${chalk.white(t.id)} — ${chalk.cyan(t.status)} — ${chalk.gray(t.message?.substring(0, 50) || '')}`);
+    }
+    console.log();
+    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 if (rpc.method === 'config.set') {
+          const { setConfigValue } = require('../utils/config');
+          setConfigValue(rpc.params.key, rpc.params.value);
+          payload = { ok: true, key: rpc.params.key, value: rpc.params.value };
+        } else if (rpc.method === 'channels.status' || rpc.method === 'channels.start' || rpc.method === 'channels.stop') {
+          const channels = ['telegram', 'discord', 'slack', 'whatsapp'];
+          const status = {};
+          for (const ch of channels) status[ch] = !!config[`${ch}Token`];
+          payload = { action: rpc.method, channels: status };
+        } else if (rpc.method === 'agents.list' || rpc.method === 'tasks.list') {
+          const { listTasks, getTaskSummary } = require('../utils/background');
+          payload = { summary: getTaskSummary(), tasks: listTasks({ limit: 20 }) };
+        } else if (rpc.method === 'cron.list' || rpc.method === 'cron.status') {
+          payload = { jobs: config.cronJobs || [] };
+        } 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,280 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BINDINGS_FILE = path.join(os.homedir(), '.natureco', 'agent-bindings.json');
+const IDENTITIES_FILE = path.join(os.homedir(), '.natureco', 'agent-identities.json');
+
+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];
+    else (opts._positional = opts._positional || []).push(args[i]);
+  }
+
+  if (!opts.action || opts.action === 'help') return showHelp();
+  if (opts.action === 'run') return runAgent(opts);
+  if (opts.action === 'abort') return abortAgent(opts.message);
+  if (opts.action === 'tail') return tailAgent(opts.message);
+  if (opts.action === 'logs') return logsAgent(opts.message);
+  if (opts.action === 'bindings') return listBindings();
+  if (opts.action === 'bind') return bindAgent(opts);
+  if (opts.action === 'unbind') return unbindAgent(opts);
+  if (opts.action === 'set-identity') return setIdentity(opts);
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${opts.action}\n`));
+  process.exit(1);
+}
+
+async function runAgent(opts) {
+  const { getConfig } = require('../utils/config');
+  const { createTask } = require('../utils/background');
+  const { getProviderConfig } = require('../utils/api');
+  const config = getConfig();
+  const pc = getProviderConfig();
+
+  const provider = opts.provider || (pc?.url?.includes('groq') ? 'groq' : config.provider || 'openai');
+  const model = opts.model || config.providerModel || config.model || 'llama-3.3-70b-versatile';
+  const message = opts.message || 'Hello';
+  const apiKey = pc?.apiKey || config[`${provider}ApiKey`] || process.env[`${provider.toUpperCase()}_API_KEY`];
+
+  if (!apiKey) {
+    console.log(chalk.red(`\n  ❌ ${provider} API key gerekli\n`));
+    process.exit(1);
+  }
+
+  const task = createTask({
+    runtime: 'cli',
+    message: message.substring(0, 80),
+    botName: opts.to || 'default',
+  });
+
+  console.log(chalk.cyan(`\n  🤖 Agent Turn [${task.id}]\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 { updateTask } = require('../utils/background');
+    updateTask(task.id, { status: 'running' });
+
+    const apiUrl = pc?.url || `https://api.${provider}.com/v1`;
+    const response = await fetch(`${apiUrl}/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) {
+      updateTask(task.id, { status: 'failed', error: `API error ${response.status}` });
+      throw new Error(`API error ${response.status}`);
+    }
+
+    const data = await response.json();
+    const reply = data.choices?.[0]?.message?.content || 'No response';
+
+    updateTask(task.id, { status: 'succeeded', result: reply.substring(0, 500) });
+
+    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 abortAgent(taskId) {
+  const { cancelTask, listTasks } = require('../utils/background');
+  if (taskId) {
+    const t = cancelTask(taskId);
+    if (!t) { console.log(chalk.red(`\n  ❌ Task bulunamadı: ${taskId}\n`)); process.exit(1); }
+    console.log(chalk.yellow(`\n  🛑 Task iptal edildi: ${taskId}\n`));
+    return;
+  }
+  const running = listTasks({ status: 'running' });
+  if (running.length === 0) {
+    console.log(chalk.gray('\n  Çalışan task yok\n'));
+    return;
+  }
+  for (const t of running) {
+    cancelTask(t.id);
+    console.log(chalk.yellow(`  🛑 Task iptal edildi: ${t.id} — ${t.message}`));
+  }
+  console.log();
+}
+
+function tailAgent(taskId) {
+  const { getTask } = require('../utils/background');
+  if (!taskId) {
+    console.log(chalk.red('\n  ❌ Task ID gerekli. Kullanım: natureco agent tail <id>\n'));
+    process.exit(1);
+  }
+  const task = getTask(taskId);
+  if (!task) { console.log(chalk.red(`\n  ❌ Task bulunamadı: ${taskId}\n`)); process.exit(1); }
+  console.log(chalk.cyan(`\n  📋 Task: ${task.id}\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Message:')}  ${task.message}`);
+  console.log(`  ${chalk.white('Status:')}   ${statusColor(task.status)}`);
+  if (task.result) console.log(`  ${chalk.white('Result:')}   ${chalk.gray(task.result.substring(0, 300))}`);
+  if (task.error) console.log(`  ${chalk.white('Error:')}    ${chalk.red(task.error)}`);
+  if (task.createdAt) console.log(`  ${chalk.white('Created:')} ${chalk.gray(task.createdAt)}`);
+  if (task.endedAt) console.log(`  ${chalk.white('Ended:')}   ${chalk.gray(task.endedAt)}`);
+  console.log();
+}
+
+function logsAgent(statusFilter) {
+  const { listTasks } = require('../utils/background');
+  const tasks = listTasks(statusFilter ? { status: statusFilter } : {});
+  console.log(chalk.cyan(`\n  📜 Agent Logs${statusFilter ? ` (${statusFilter})` : ''}\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  if (tasks.length === 0) {
+    console.log(chalk.gray('  Task bulunamadı.\n'));
+    return;
+  }
+  for (const t of tasks.slice(0, 20)) {
+    console.log(`  ${statusColor(t.status)} ${chalk.white(t.message || '(boş)')}`);
+    console.log(chalk.gray(`     [${t.id}] ${t.createdAt?.slice(0, 16) || ''} — ${t.runtime}`));
+  }
+  console.log();
+}
+
+// ── bindings ──────────────────────────────────────────────────────────
+function listBindings() {
+  const bindings = loadBindings();
+  const ids = loadIdentities();
+  console.log(chalk.cyan('\n  Agent Bindings\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  const entries = Object.entries(bindings);
+  if (entries.length === 0) {
+    console.log(chalk.gray('  No agents bound to any channels.\n'));
+    return;
+  }
+  for (const [agentId, channels] of entries) {
+    const identity = ids[agentId];
+    console.log(`  ${chalk.white(agentId)}${identity ? chalk.gray(' (' + identity + ')') : ''}`);
+    for (const ch of channels) {
+      console.log(chalk.gray('    └─ ') + chalk.cyan(ch));
+    }
+  }
+  console.log('');
+}
+
+function loadBindings() {
+  if (!fs.existsSync(BINDINGS_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(BINDINGS_FILE, 'utf8')); } catch { return {}; }
+}
+
+function saveBindings(data) {
+  const dir = path.dirname(BINDINGS_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(BINDINGS_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function bindAgent(opts) {
+  const pos = opts._positional || [];
+  const agentId = pos[0];
+  const channel = pos[1] || opts.channel;
+  if (!agentId || !channel) {
+    console.log(chalk.red('\nUsage: natureco agents bind <agentId> <channel>\n'));
+    process.exit(1);
+  }
+  const bindings = loadBindings();
+  if (!bindings[agentId]) bindings[agentId] = [];
+  if (!bindings[agentId].includes(channel)) bindings[agentId].push(channel);
+  saveBindings(bindings);
+  console.log(chalk.green('\nAgent "' + agentId + '" bound to ' + channel + '\n'));
+}
+
+function unbindAgent(opts) {
+  const pos = opts._positional || [];
+  const agentId = pos[0];
+  const channel = pos[1] || opts.channel;
+  if (!agentId || !channel) {
+    console.log(chalk.red('\nUsage: natureco agents unbind <agentId> <channel>\n'));
+    process.exit(1);
+  }
+  const bindings = loadBindings();
+  if (bindings[agentId]) {
+    bindings[agentId] = bindings[agentId].filter(c => c !== channel);
+    if (bindings[agentId].length === 0) delete bindings[agentId];
+  }
+  saveBindings(bindings);
+  console.log(chalk.green('\nAgent "' + agentId + '" unbound from ' + channel + '\n'));
+}
+
+// ── identities ────────────────────────────────────────────────────────
+function loadIdentities() {
+  if (!fs.existsSync(IDENTITIES_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(IDENTITIES_FILE, 'utf8')); } catch { return {}; }
+}
+
+function saveIdentities(data) {
+  const dir = path.dirname(IDENTITIES_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(IDENTITIES_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function setIdentity(opts) {
+  const pos = opts._positional || [];
+  const agentId = pos[0];
+  const identity = pos.slice(1).join(' ') || opts.message;
+  if (!agentId || !identity) {
+    console.log(chalk.red('\nUsage: natureco agents set-identity <agentId> <identity>\n'));
+    process.exit(1);
+  }
+  const ids = loadIdentities();
+  ids[agentId] = identity;
+  saveIdentities(ids);
+  console.log(chalk.green('\nIdentity set for agent "' + agentId + '": ' + identity + '\n'));
+}
+
+function statusColor(s) {
+  const m = { succeeded: chalk.green('✓'), failed: chalk.red('✗'), running: chalk.yellow('●'), queued: chalk.cyan('○'), cancelled: chalk.gray('−'), timed_out: chalk.red('⚠'), lost: chalk.magenta('?') };
+  return m[s] || chalk.gray('○');
+}
+
+function showHelp() {
+  console.log(chalk.cyan('\n  🤖 Agent\n'));
+  console.log(chalk.gray('  Run, manage, and monitor agent tasks.\n'));
+  console.log(chalk.gray('  Usage: natureco agent <action> [options]'));
+  console.log(chalk.gray('\n  Actions:'));
+  console.log(chalk.cyan('    run') + chalk.gray('                     Run an agent turn'));
+  console.log(chalk.cyan('    abort [id]') + chalk.gray('             Cancel a running task'));
+  console.log(chalk.cyan('    tail <id>') + chalk.gray('              Show task details'));
+  console.log(chalk.cyan('    logs [status]') + chalk.gray('          List recent tasks'));
+  console.log(chalk.cyan('    bindings') + chalk.gray('               List agent bindings'));
+  console.log(chalk.cyan('    bind <id> <ch>') + chalk.gray('        Bind agent to channel'));
+  console.log(chalk.cyan('    unbind <id> <ch>') + chalk.gray('      Unbind agent from channel'));
+  console.log(chalk.cyan('    set-identity <id> <persona>') + chalk.gray('   Set agent identity'));
+  console.log(chalk.gray('\n  Options for run:'));
+  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 "Merhaba"'));
+  console.log(chalk.gray('    natureco agent abort'));
+  console.log(chalk.gray('    natureco agent tail <id>'));
+  console.log(chalk.gray('    natureco agent logs running\n'));
+}
+
+module.exports = agent;