natureco-cli 2.23.29 → 2.23.31

package/src/commands/nodes.js

@@ -0,0 +1,362 @@
+const chalk = require('chalk');
+const F = require('../utils/format');
+const { getConfig, saveConfig } = require('../utils/config');
+const crypto = require('crypto');
+
+function nodes(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'list') return listNodes();
+  if (action === 'pair') return pairNode(params[0]);
+  if (action === 'approve') return approveNode(params[0]);
+  if (action === 'reject') return rejectNode(params[0]);
+  if (action === 'remove') return removeNode(params[0]);
+  if (action === 'rename') return renameNode(params[0], params.slice(1).join(' '));
+  if (action === 'invoke') return invokeNode(params[0], params[1], params.slice(2));
+  if (action === 'notify') return notifyNode(params[0], params.slice(1).join(' '));
+  if (action === 'push') return pushNode(params[0]);
+  if (action === 'canvas') {
+    const sub = params[0];
+    if (sub === 'a2ui') {
+      if (params[1] === 'push') {
+        const nodeId = params[2];
+        const url = params[3];
+        if (!nodeId || !url) {
+          F.error('Node ID and URL required');
+          F.info('Usage: natureco nodes canvas a2ui push <nodeId> <url>');
+          process.exit(1);
+        }
+        F.info(`Would push A2UI from ${url} to node ${nodeId}`);
+        return;
+      }
+      if (params[1] === 'reset') {
+        const id = params[2] || 'default';
+        F.info(`Would reset A2UI for node ${id}`);
+        return;
+      }
+      F.error(`Unknown canvas a2ui command: ${params[1]}`);
+      F.info('Usage: natureco nodes canvas a2ui [push|reset]');
+      process.exit(1);
+    }
+    if (sub === 'snapshot') {
+      const nodeId = params[1];
+      if (!nodeId) {
+        F.error('Node ID required');
+        F.info('Usage: natureco nodes canvas snapshot <nodeId>');
+        process.exit(1);
+      }
+      F.info(`Would snapshot canvas on node ${nodeId}`);
+      return;
+    }
+    if (sub === 'present') {
+      const nodeId = params[1];
+      const url = params[2];
+      if (!nodeId || !url) {
+        F.error('Node ID and URL required');
+        F.info('Usage: natureco nodes canvas present <nodeId> <url>');
+        process.exit(1);
+      }
+      F.info(`Would present ${url} on node ${nodeId}`);
+      return;
+    }
+    if (sub === 'hide') {
+      const nodeId = params[1];
+      if (!nodeId) {
+        F.error('Node ID required');
+        F.info('Usage: natureco nodes canvas hide <nodeId>');
+        process.exit(1);
+      }
+      F.info(`Would hide canvas on node ${nodeId}`);
+      return;
+    }
+    if (sub === 'navigate') {
+      const nodeId = params[1];
+      const url = params[2];
+      if (!nodeId || !url) {
+        F.error('Node ID and URL required');
+        F.info('Usage: natureco nodes canvas navigate <nodeId> <url>');
+        process.exit(1);
+      }
+      F.info(`Would navigate node ${nodeId} to ${url}`);
+      return;
+    }
+    if (sub === 'eval') {
+      const nodeId = params[1];
+      const code = params.slice(2).join(' ');
+      if (!nodeId || !code) {
+        F.error('Node ID and code required');
+        F.info('Usage: natureco nodes canvas eval <nodeId> <code>');
+        process.exit(1);
+      }
+      F.info(`Would eval on node ${nodeId}: ${code}`);
+      return;
+    }
+    return canvasNode(sub, params[1]);
+  }
+  if (action === 'camera') {
+    const sub = params[0];
+    if (sub === 'list') {
+      const nodeId = params[1];
+      F.info(`Would list cameras${nodeId ? ' on node ' + nodeId : ''}`);
+      return;
+    }
+    if (sub === 'snap') {
+      const nodeId = params[1];
+      if (!nodeId) {
+        F.error('Node ID required');
+        F.info('Usage: natureco nodes camera snap <nodeId>');
+        process.exit(1);
+      }
+      F.info(`Would take snapshot on node ${nodeId}`);
+      return;
+    }
+    if (sub === 'clip') {
+      const nodeId = params[1];
+      if (!nodeId) {
+        F.error('Node ID required');
+        F.info('Usage: natureco nodes camera clip <nodeId>');
+        process.exit(1);
+      }
+      F.info(`Would record clip on node ${nodeId}`);
+      return;
+    }
+    return cameraNode(sub, params[1]);
+  }
+  if (action === 'screen') {
+    const sub = params[0];
+    if (sub === 'record') {
+      const nodeId = params[1];
+      if (!nodeId) {
+        F.error('Node ID required');
+        F.info('Usage: natureco nodes screen record <nodeId>');
+        process.exit(1);
+      }
+      F.info(`Would start screen recording on node ${nodeId}`);
+      return;
+    }
+    return screenNode(sub, params[1]);
+  }
+  if (action === 'location') {
+    const sub = params[0];
+    if (sub === 'get') {
+      const nodeId = params[1];
+      if (!nodeId) {
+        F.error('Node ID required');
+        F.info('Usage: natureco nodes location get <nodeId>');
+        process.exit(1);
+      }
+      F.kv('Node', nodeId);
+      F.kv('Latitude', '41.0082 (mock)');
+      F.kv('Longitude', '28.9784 (mock)');
+      return;
+    }
+    return locationNode(sub);
+  }
+  if (action === 'status') return nodeStatus(params[0]);
+  if (action === 'describe') return nodeDescribe(params[0]);
+
+  F.error(`Unknown command: ${action}`);
+  F.info('Usage: natureco nodes [list|pair|approve|reject|remove|rename|invoke|notify|push|canvas|camera|screen|location|status|describe]');
+  process.exit(1);
+}
+
+function listNodes() {
+  const config = getConfig();
+  const nodes = config.pairedNodes || [];
+
+  F.header('Nodes');
+
+  if (nodes.length === 0) {
+    F.info('No paired nodes.');
+    return;
+  }
+
+  F.table(['ID', 'Name', 'Status', 'LastSeen'],
+    nodes.map(n => [
+      n.id,
+      n.name || n.id,
+      'online (mock)',
+      n.pairedAt ? new Date(n.pairedAt).toLocaleString() : '—',
+    ])
+  );
+}
+
+function pairNode(url) {
+  if (!url) {
+    F.error('Node URL required');
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  if (!config.pairedNodes) config.pairedNodes = [];
+
+  const id = `node_${crypto.randomBytes(8).toString('hex')}`;
+  const key = crypto.randomBytes(16).toString('hex');
+
+  config.pairedNodes.push({ id, url, key, name: url, pairedAt: new Date().toISOString() });
+  saveConfig(config);
+
+  F.success(`Node paired: ${url}`);
+  F.info('Use the following link or scan the QR code in the NatureCo mobile app to link this device.');
+  F.kv('Pair Code', key);
+}
+
+function approveNode(id) {
+  F.success(`Node approved: ${id}`);
+}
+
+function rejectNode(id) {
+  F.error(`Node rejected: ${id}`);
+}
+
+function removeNode(id) {
+  if (!id) {
+    F.error('Node ID required');
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  const nodes = config.pairedNodes || [];
+  const idx = nodes.findIndex(n => n.id === id);
+
+  if (idx === -1) {
+    F.error(`Node not found: ${id}`);
+    process.exit(1);
+  }
+
+  nodes.splice(idx, 1);
+  config.pairedNodes = nodes;
+  saveConfig(config);
+  F.success(`Node removed: ${id}`);
+}
+
+function renameNode(id, name) {
+  if (!id || !name) {
+    F.error('Node ID and name required');
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  const node = (config.pairedNodes || []).find(n => n.id === id);
+  if (!node) {
+    F.error(`Node not found: ${id}`);
+    process.exit(1);
+  }
+
+  node.name = name;
+  saveConfig(config);
+  F.success(`Node renamed: ${name}`);
+}
+
+function invokeNode(nodeId, method, params) {
+  if (!nodeId || !method) {
+    F.error('Node ID and method required');
+    process.exit(1);
+  }
+  F.kv('Node', nodeId);
+  F.kv('Method', method);
+  F.kv('Params', (params || []).join(', '));
+  F.kv('Result', '[mock] invocation sent');
+}
+
+function notifyNode(nodeId, message) {
+  if (!nodeId || !message) {
+    F.error('Node ID and message required');
+    process.exit(1);
+  }
+  F.info(`Notify: ${nodeId} → "${message}"`);
+}
+
+function pushNode(nodeId) {
+  if (!nodeId) {
+    F.error('Node ID required');
+    process.exit(1);
+  }
+  F.info(`Push config to: ${nodeId}`);
+}
+
+function canvasNode(nodeId, sessionId) {
+  if (!nodeId) {
+    F.error('Node ID required');
+    process.exit(1);
+  }
+  F.info(`Canvas share: ${nodeId}${sessionId ? ' session: ' + sessionId : ''}`);
+}
+
+function cameraNode(nodeId, action) {
+  if (!nodeId) {
+    F.error('Node ID required');
+    process.exit(1);
+  }
+  const act = action || 'open';
+  F.info(`Camera ${act}: ${nodeId}`);
+}
+
+function screenNode(nodeId, action) {
+  if (!nodeId) {
+    F.error('Node ID required');
+    process.exit(1);
+  }
+  const act = action || 'view';
+  F.info(`Screen ${act}: ${nodeId}`);
+}
+
+function locationNode(nodeId) {
+  if (!nodeId) {
+    F.error('Node ID required');
+    process.exit(1);
+  }
+  F.kv('Node', nodeId);
+  F.kv('Latitude', '41.0082 (mock)');
+  F.kv('Longitude', '28.9784 (mock)');
+}
+
+function nodeStatus(nodeId) {
+  if (!nodeId) {
+    F.error('Node ID required');
+    F.info('Usage: natureco nodes status <nodeId>');
+    process.exit(1);
+  }
+  const config = getConfig();
+  const node = (config.pairedNodes || []).find(n => n.id === nodeId || n.name === nodeId);
+  if (!node) {
+    F.warning(`Node not found: ${nodeId}`);
+    process.exit(1);
+  }
+  F.header(`Node Status: ${node.name || node.id}`);
+  F.kv('ID', node.id);
+  F.kv('Name', node.name);
+  F.kv('URL', node.url || 'local');
+  F.kv('Status', 'connected (mock)');
+  F.kv('Latency', '~12ms (mock)');
+  F.kv('Uptime', '~3h (mock)');
+}
+
+function nodeDescribe(nodeId) {
+  if (!nodeId) {
+    F.error('Node ID required');
+    F.info('Usage: natureco nodes describe <nodeId>');
+    process.exit(1);
+  }
+  const config = getConfig();
+  const node = (config.pairedNodes || []).find(n => n.id === nodeId || n.name === nodeId);
+  if (!node) {
+    F.warning(`Node not found: ${nodeId}`);
+    process.exit(1);
+  }
+  F.header(`Node Details: ${node.name || node.id}`);
+  F.table(['Property', 'Value'], [
+    ['ID', node.id],
+    ['Name', node.name],
+    ['URL', node.url || 'local'],
+    ['Key', node.key ? node.key.substring(0, 8) + '...' : 'none'],
+    ['Paired At', node.pairedAt ? new Date(node.pairedAt).toLocaleString() : 'unknown'],
+    ['OS', 'linux (mock)'],
+    ['Version', '2.23.31 (mock)'],
+    ['CPU', '4 vCPU (mock)'],
+    ['Memory', '8 GB (mock)'],
+    ['Services', 'gateway, mcp, file-sync (mock)'],
+  ]);
+}
+
+module.exports = nodes;

package/src/commands/oc-path.js

@@ -0,0 +1,200 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+function normalizeNcPath(uri) {
+  if (!uri) return null;
+
+  const str = uri.trim();
+
+  if (str.startsWith('nc://')) return str.slice(5);
+  if (str.startsWith('natureco://')) return str.slice(10);
+
+  return str;
+}
+
+function resolveNcPath(ncPath) {
+  if (!ncPath) return null;
+
+  const parts = ncPath.split('/').filter(Boolean);
+  const scope = parts[0];
+  const rest = parts.slice(1);
+
+  if (scope === 'workspace' || scope === 'w') {
+    return { type: 'workspace', path: rest.join('/') || '.', description: 'Workspace path' };
+  }
+
+  if (scope === 'home' || scope === 'h') {
+    return { type: 'home', path: path.join(os.homedir(), ...rest), description: 'Home directory' };
+  }
+
+  if (scope === 'config' || scope === 'c') {
+    const configDir = path.join(os.homedir(), '.natureco');
+    return { type: 'config', path: rest.length ? path.join(configDir, ...rest) : configDir, description: 'Config directory' };
+  }
+
+  if (scope === 'tmp' || scope === 't') {
+    return { type: 'tmp', path: path.join(os.tmpdir(), ...rest), description: 'Temp directory' };
+  }
+
+  if (scope === 'tools' || scope === 'tool') {
+    const toolsDir = path.join(__dirname, '..', 'tools');
+    return { type: 'tools', path: path.join(toolsDir, ...rest), description: 'Tools directory' };
+  }
+
+  if (scope === 'commands' || scope === 'cmd') {
+    const cmdsDir = path.join(__dirname, '..', 'commands');
+    return { type: 'commands', path: path.join(cmdsDir, ...rest), description: 'Commands directory' };
+  }
+
+  if (scope === 'project' || scope === 'p') {
+    return { type: 'project', path: rest.join('/') || '.', description: 'Project path (CWD)' };
+  }
+
+  if (scope === 'skills' || scope === 's') {
+    const skillsDir = path.join(__dirname, '..', '..', 'skills');
+    return { type: 'skills', path: path.join(skillsDir, ...rest), description: 'Skills directory' };
+  }
+
+  if (scope === 'data' || scope === 'd') {
+    const dataDir = path.join(os.homedir(), '.natureco', 'data');
+    return { type: 'data', path: rest.length ? path.join(dataDir, ...rest) : dataDir, description: 'Data directory' };
+  }
+
+  return { type: 'unknown', path: ncPath, description: 'Unresolved path' };
+}
+
+function ocPath(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'resolve') return resolvePath(params.join('/'));
+  if (action === 'list') return listScopes();
+  if (action === 'cat') return catFile(params.join('/'));
+  if (action === 'ls') return lsPath(params.join('/'));
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco oc-path [resolve|list|cat|ls] <path>\n'));
+  process.exit(1);
+}
+
+function resolvePath(uri) {
+  const ncPath = normalizeNcPath(uri);
+  if (!ncPath) {
+    console.log(chalk.red('\n  ❌ Path gerekli\n'));
+    console.log(chalk.cyan('    natureco oc-path resolve nc://config\n'));
+    process.exit(1);
+  }
+
+  const resolved = resolveNcPath(ncPath);
+  if (!resolved) {
+    console.log(chalk.red(`\n  ❌ Çözümlenemedi: ${ncPath}\n`));
+    process.exit(1);
+  }
+
+  const exists = fs.existsSync(resolved.path);
+
+  console.log(chalk.cyan('\n  📍 nc:// Path Resolution\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Scope:')}       ${chalk.cyan(resolved.type)}`);
+  console.log(`  ${chalk.white('Path:')}        ${chalk.white(resolved.path)}`);
+  console.log(`  ${chalk.white('Description:')} ${chalk.gray(resolved.description)}`);
+  console.log(`  ${chalk.white('Exists:')}      ${exists ? chalk.green('Yes') : chalk.red('No')}`);
+  console.log();
+}
+
+function listScopes() {
+  console.log(chalk.cyan('\n  📍 nc:// Path Scopes\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  const scopes = [
+    { alias: 'w', scope: 'workspace', desc: 'CWD altındaki dosyalar' },
+    { alias: 'p', scope: 'project', desc: 'Proje kökü (CWD)' },
+    { alias: 'h', scope: 'home', desc: 'Kullanıcı ana dizini (~)' },
+    { alias: 'c', scope: 'config', desc: '~/.natureco yapılandırma' },
+    { alias: 'd', scope: 'data', desc: '~/.natureco/data veri dizini' },
+    { alias: 't', scope: 'tmp', desc: 'Geçici dizin' },
+    { alias: 's', scope: 'skills', desc: 'Skill dizini' },
+    { alias: 'tool', scope: 'tools', desc: 'Araçlar dizini' },
+    { alias: 'cmd', scope: 'commands', desc: 'Komutlar dizini' }
+  ];
+
+  for (const s of scopes) {
+    console.log(`  ${chalk.cyan(`nc://${s.scope}`)} ${chalk.gray(`(${s.alias})`)} ${chalk.white('-')} ${chalk.gray(s.desc)}`);
+  }
+
+  console.log(chalk.gray('\n  Examples:'));
+  console.log(chalk.cyan('    natureco oc-path resolve nc://config'));
+  console.log(chalk.cyan('    natureco oc-path ls nc://tools'));
+  console.log(chalk.cyan('    natureco oc-path cat nc://c/settings.json'));
+  console.log();
+}
+
+function catFile(uri) {
+  const ncPath = normalizeNcPath(uri);
+  if (!ncPath) {
+    console.log(chalk.red('\n  ❌ Path gerekli\n'));
+    process.exit(1);
+  }
+
+  const resolved = resolveNcPath(ncPath);
+  if (!resolved) {
+    console.log(chalk.red(`\n  ❌ Çözümlenemedi: ${ncPath}\n`));
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(resolved.path)) {
+    console.log(chalk.red(`\n  ❌ Dosya bulunamadı: ${resolved.path}\n`));
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(resolved.path);
+  if (stat.isDirectory()) {
+    console.log(chalk.yellow(`\n  ⚠️  Bu bir dizin, dosya değil: ${resolved.path}\n`));
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(resolved.path, 'utf8');
+  console.log(chalk.gray(`\n  📄 ${resolved.path}\n`));
+  console.log(content);
+  if (!content.endsWith('\n')) console.log();
+}
+
+function lsPath(uri) {
+  const ncPath = normalizeNcPath(uri || 'nc://w');
+  if (!ncPath) {
+    console.log(chalk.red('\n  ❌ Path gerekli\n'));
+    process.exit(1);
+  }
+
+  const resolved = resolveNcPath(ncPath);
+  if (!resolved) {
+    console.log(chalk.red(`\n  ❌ Çözümlenemedi: ${ncPath}\n`));
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(resolved.path)) {
+    console.log(chalk.red(`\n  ❌ Dizin bulunamadı: ${resolved.path}\n`));
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(resolved.path);
+  if (!stat.isDirectory()) {
+    console.log(chalk.yellow(`\n  ⚠️  Bu bir dosya: ${resolved.path}\n`));
+    process.exit(1);
+  }
+
+  const items = fs.readdirSync(resolved.path);
+  console.log(chalk.cyan(`\n  📂 ${resolved.path}\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  for (const item of items) {
+    const fullPath = path.join(resolved.path, item);
+    const isDir = fs.statSync(fullPath).isDirectory();
+    console.log(`  ${isDir ? chalk.blue('📁') : chalk.gray('📄')} ${isDir ? chalk.cyan(item + '/') : chalk.white(item)}`);
+  }
+
+  console.log();
+}
+
+module.exports = ocPath;

package/src/commands/onboard.js

@@ -0,0 +1,129 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BASE_DIR = path.join(os.homedir(), '.natureco');
+const CONFIG_FILE = path.join(BASE_DIR, 'config.json');
+
+const STEPS = ['gateway', 'auth', 'workspace', 'channels', 'skills', 'health'];
+
+function getConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); }
+  catch { return {}; }
+}
+
+function saveConfig(data) {
+  if (!fs.existsSync(BASE_DIR)) fs.mkdirSync(BASE_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function onboard(params) {
+  try {
+    const [action] = params || [];
+
+    if (!action || action === 'status') return cmdStatus();
+    if (action === 'gateway') return cmdGateway();
+    if (action === 'auth') return cmdAuth();
+    if (action === 'workspace') return cmdWorkspace();
+    if (action === 'channels') return cmdChannels();
+    if (action === 'skills') return cmdSkills();
+    if (action === 'health') return cmdHealth();
+
+    console.log(chalk.red(`\n  Unknown onboard action: ${action}\n`));
+    console.log(chalk.gray('  Usage: natureco onboard [gateway|auth|workspace|channels|skills|health|status]\n'));
+  } catch (err) {
+    console.log(chalk.red(`\n  Onboard error: ${err.message}\n`));
+  }
+}
+
+function cmdStatus() {
+  const cfg = getConfig();
+  console.log(chalk.cyan('\n  Onboarding Status\n'));
+
+  const status = {
+    gateway: cfg.gatewayUrl ? 'done' : 'pending',
+    auth: cfg.providerApiKey ? 'done' : 'pending',
+    workspace: cfg.workspacePath ? 'done' : 'pending',
+    channels: cfg.channels ? 'done' : 'pending',
+    skills: cfg.skills && cfg.skills.list && cfg.skills.list.length > 0 ? 'done' : 'pending',
+    health: cfg.setupCompleted ? 'done' : 'pending',
+  };
+
+  for (const step of STEPS) {
+    const icon = status[step] === 'done' ? chalk.green('✓') : chalk.yellow('○');
+    console.log(`  ${icon} ${step}`);
+  }
+  console.log('');
+}
+
+function cmdGateway() {
+  const cfg = getConfig();
+  console.log(chalk.cyan('\n  Gateway Setup\n'));
+  console.log(chalk.gray('  To configure the gateway, run:'));
+  console.log(chalk.cyan('    natureco configure gateway'));
+  console.log(chalk.gray('  Or start the gateway:'));
+  console.log(chalk.cyan('    natureco gateway start\n'));
+  cfg.gatewayUrl = 'ws://localhost:3848';
+  saveConfig(cfg);
+  console.log(chalk.green('  Gateway step marked as done.\n'));
+}
+
+function cmdAuth() {
+  const cfg = getConfig();
+  console.log(chalk.cyan('\n  Auth Setup\n'));
+  console.log(chalk.gray('  To configure authentication, run:'));
+  console.log(chalk.cyan('    natureco configure auth'));
+  console.log(chalk.gray('  Or set your API key in config.\n'));
+  cfg.authConfigured = true;
+  saveConfig(cfg);
+  console.log(chalk.green('  Auth step marked as done.\n'));
+}
+
+function cmdWorkspace() {
+  const cfg = getConfig();
+  const wsPath = cfg.workspacePath || path.join(os.homedir(), 'natureco-workspace');
+  if (!fs.existsSync(wsPath)) fs.mkdirSync(wsPath, { recursive: true });
+  cfg.workspacePath = wsPath;
+  saveConfig(cfg);
+  console.log(chalk.green('\n  Workspace ready at: ' + wsPath + '\n'));
+}
+
+function cmdChannels() {
+  console.log(chalk.cyan('\n  Channels Setup\n'));
+  console.log(chalk.gray('  Available channels:'));
+  const channels = ['telegram', 'whatsapp', 'discord', 'slack', 'signal', 'irc', 'mattermost', 'imessage'];
+  for (const ch of channels) {
+    console.log(chalk.gray('    natureco ' + ch + ' connect'));
+  }
+  console.log('');
+}
+
+function cmdSkills() {
+  console.log(chalk.cyan('\n  Skills Setup\n'));
+  console.log(chalk.gray('  To manage skills, run:'));
+  console.log(chalk.cyan('    natureco skills list'));
+  console.log(chalk.cyan('    natureco skills add <name>\n'));
+}
+
+function cmdHealth() {
+  const cfg = getConfig();
+  console.log(chalk.cyan('\n  Health Check\n'));
+
+  const checks = [
+    { label: 'Config exists', pass: fs.existsSync(CONFIG_FILE) },
+    { label: 'Gateway configured', pass: !!cfg.gatewayUrl },
+    { label: 'Auth configured', pass: !!cfg.providerApiKey },
+    { label: 'Workspace configured', pass: !!cfg.workspacePath },
+  ];
+
+  for (const c of checks) {
+    console.log(`  ${c.pass ? chalk.green('✓') : chalk.yellow('○')} ${c.label}`);
+  }
+
+  const done = checks.filter(c => c.pass).length;
+  console.log(chalk.gray(`\n  ${done}/${checks.length} checks passed\n`));
+}
+
+module.exports = onboard;