kernelbot 1.0.2 → 1.0.3

package/README.md

@@ -6,10 +6,10 @@ Send a message in Telegram, and KernelBot will read files, write code, run comma
 
 ## How It Works
 
-```
+```text
 You (Telegram) → KernelBot → Claude Sonnet (Anthropic API)
-                                    ↕
-                              OS Tools (shell, files, directories)
+                                   ↕
+                             OS Tools (shell, files, directories)
 ```
 
 KernelBot runs a **tool-use loop**: Claude decides which tools to call, KernelBot executes them on your OS, feeds results back, and Claude continues until the task is done. One message can trigger dozens of tool calls autonomously.
@@ -29,42 +29,35 @@ KernelBot runs a **tool-use loop**: Claude decides which tools to call, KernelBo
 npm install -g kernelbot
 ```
 
-This installs the `kernelbot` command globally.
-
 ## Quick Start
 
 ```bash
-# Interactive setup — creates .env and config.yaml
-kernelbot init
-
-# Verify everything works
-kernelbot check
-
-# Launch the bot
-kernelbot start
+kernelbot
 ```
 
-## Commands
+That's it. On first run, KernelBot will:
 
-| Command                   | Description                                               |
-| ------------------------- | --------------------------------------------------------- |
-| `kernelbot start`         | Start the Telegram bot                                    |
-| `kernelbot run "prompt"`  | One-off agent call without Telegram (for testing/scripts) |
-| `kernelbot check`         | Validate config and test API connections                  |
-| `kernelbot init`          | Interactive setup wizard                                  |
+1. Detect missing credentials and prompt for them
+2. Save them to `~/.kernelbot/.env`
+3. Verify API connections
+4. Launch the Telegram bot
 
 ## Configuration
 
-KernelBot looks for `config.yaml` in the current directory or `~/.kernelbot/`. Secrets are loaded from `.env`.
+KernelBot auto-detects config from the current directory or `~/.kernelbot/`. Everything works with zero config — just provide your API keys when prompted.
 
-### `.env`
+### Environment Variables
 
-```
+Set these in `.env` or as system environment variables:
+
+```text
 ANTHROPIC_API_KEY=sk-ant-...
 TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
 ```
 
-### `config.yaml`
+### `config.yaml` (optional)
+
+Drop a `config.yaml` in your working directory or `~/.kernelbot/` to customize behavior:
 
 ```yaml
 bot:
@@ -102,10 +95,10 @@ conversation:
 
 ## Project Structure
 
-```
+```text
 KernelBot/
 ├── bin/
-│   └── kernel.js           # CLI entry point
+│   └── kernel.js           # Entry point
 ├── src/
 │   ├── agent.js            # Sonnet tool-use loop
 │   ├── bot.js              # Telegram bot (polling, auth, message handling)
@@ -119,7 +112,7 @@ KernelBot/
 │   │   ├── os.js           # OS tool definitions + handlers
 │   │   └── index.js        # Tool registry + dispatcher
 │   └── utils/
-│       ├── config.js       # Config loading (yaml + env + defaults)
+│       ├── config.js       # Config loading (auto-detect + prompt)
 │       ├── display.js      # CLI display (logo, spinners, banners)
 │       └── logger.js       # Winston logger
 ├── config.example.yaml

package/bin/kernel.js

@@ -4,14 +4,15 @@
 process.removeAllListeners('warning');
 process.on('warning', (w) => { if (w.name !== 'DeprecationWarning' || !w.message.includes('punycode')) console.warn(w); });
 
-import { Command } from 'commander';
 import { createInterface } from 'readline';
-import { writeFileSync, existsSync } from 'fs';
-import { loadConfig } from '../src/utils/config.js';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import chalk from 'chalk';
+import { loadConfig, loadConfigInteractive } from '../src/utils/config.js';
 import { createLogger, getLogger } from '../src/utils/logger.js';
 import {
   showLogo,
-  showHelp,
   showStartupCheck,
   showStartupComplete,
   showError,
@@ -22,180 +23,163 @@ import { Agent } from '../src/agent.js';
 import { startBot } from '../src/bot.js';
 import Anthropic from '@anthropic-ai/sdk';
 
-const program = new Command();
-
-program
-  .name('kernelbot')
-  .description('KernelBot — AI engineering agent with full OS control')
-  .version('1.0.0')
-  .action(() => {
-    showHelp();
-  });
-
-// ─── kernel start ────────────────────────────────────────────
-program
-  .command('start')
-  .description('Start KernelBot Telegram bot')
-  .action(async () => {
-    showLogo();
-
-    const config = loadConfig();
-    createLogger(config);
-    createAuditLogger();
-    const logger = getLogger();
-
-    // Startup checks
-    const checks = [];
-
-    checks.push(
-      await showStartupCheck('Configuration loaded', async () => {
-        if (!config.anthropic.api_key) throw new Error('ANTHROPIC_API_KEY not set');
-        if (!config.telegram.bot_token) throw new Error('TELEGRAM_BOT_TOKEN not set');
-      }),
-    );
-
-    checks.push(
-      await showStartupCheck('Anthropic API connection', async () => {
-        const client = new Anthropic({ apiKey: config.anthropic.api_key });
-        await client.messages.create({
-          model: config.anthropic.model,
-          max_tokens: 16,
-          messages: [{ role: 'user', content: 'ping' }],
-        });
-      }),
-    );
-
-    if (checks.some((c) => !c)) {
-      showError('Startup checks failed. Fix the issues above and try again.');
-      process.exit(1);
+function showMenu() {
+  console.log('');
+  console.log(chalk.bold('  What would you like to do?\n'));
+  console.log(`  ${chalk.cyan('1.')} Start bot`);
+  console.log(`  ${chalk.cyan('2.')} Check connections`);
+  console.log(`  ${chalk.cyan('3.')} View logs`);
+  console.log(`  ${chalk.cyan('4.')} View audit logs`);
+  console.log(`  ${chalk.cyan('5.')} Exit`);
+  console.log('');
+}
+
+function ask(rl, question) {
+  return new Promise((res) => rl.question(question, res));
+}
+
+function viewLog(filename) {
+  const paths = [
+    join(process.cwd(), filename),
+    join(homedir(), '.kernelbot', filename),
+  ];
+
+  for (const p of paths) {
+    if (existsSync(p)) {
+      const content = readFileSync(p, 'utf-8');
+      const lines = content.split('\n').filter(Boolean);
+      const recent = lines.slice(-30);
+      console.log(chalk.dim(`\n  Showing last ${recent.length} entries from ${p}\n`));
+      for (const line of recent) {
+        try {
+          const entry = JSON.parse(line);
+          const time = entry.timestamp || '';
+          const level = entry.level || '';
+          const msg = entry.message || '';
+          const color = level === 'error' ? chalk.red : level === 'warn' ? chalk.yellow : chalk.dim;
+          console.log(`  ${chalk.dim(time)} ${color(level)} ${msg}`);
+        } catch {
+          console.log(`  ${line}`);
+        }
+      }
+      console.log('');
+      return;
     }
+  }
+  console.log(chalk.dim(`\n  No ${filename} found yet.\n`));
+}
 
-    const conversationManager = new ConversationManager(config);
-    const agent = new Agent({ config, conversationManager });
-
-    startBot(config, agent);
-    showStartupComplete();
+async function runCheck(config) {
+  await showStartupCheck('ANTHROPIC_API_KEY', async () => {
+    if (!config.anthropic.api_key) throw new Error('Not set');
   });
 
-// ─── kernel run ──────────────────────────────────────────────
-program
-  .command('run')
-  .description('Run a one-off prompt through the agent (no Telegram)')
-  .argument('<prompt>', 'The prompt to send')
-  .action(async (prompt) => {
-    const config = loadConfig();
-    createLogger(config);
-    createAuditLogger();
-
-    if (!config.anthropic.api_key) {
-      showError('ANTHROPIC_API_KEY not set. Run `kernelbot init` first.');
-      process.exit(1);
-    }
-
-    const conversationManager = new ConversationManager(config);
-    const agent = new Agent({ config, conversationManager });
+  await showStartupCheck('TELEGRAM_BOT_TOKEN', async () => {
+    if (!config.telegram.bot_token) throw new Error('Not set');
+  });
 
-    const reply = await agent.processMessage('cli', prompt, {
-      id: 'cli',
-      username: 'cli',
+  await showStartupCheck('Anthropic API connection', async () => {
+    const client = new Anthropic({ apiKey: config.anthropic.api_key });
+    await client.messages.create({
+      model: config.anthropic.model,
+      max_tokens: 16,
+      messages: [{ role: 'user', content: 'ping' }],
     });
-
-    console.log('\n' + reply);
   });
 
-// ─── kernel check ────────────────────────────────────────────
-program
-  .command('check')
-  .description('Validate configuration and test API connections')
-  .action(async () => {
-    showLogo();
-
-    const config = loadConfig();
-    createLogger(config);
+  await showStartupCheck('Telegram Bot API', async () => {
+    const res = await fetch(
+      `https://api.telegram.org/bot${config.telegram.bot_token}/getMe`,
+    );
+    const data = await res.json();
+    if (!data.ok) throw new Error(data.description || 'Invalid token');
+  });
 
-    await showStartupCheck('Configuration file', async () => {
-      // loadConfig already succeeded if we got here
-    });
+  console.log(chalk.green('\n  All checks passed.\n'));
+}
 
-    await showStartupCheck('ANTHROPIC_API_KEY', async () => {
-      if (!config.anthropic.api_key) throw new Error('Not set');
-    });
+async function startBotFlow(config) {
+  createAuditLogger();
+  const logger = getLogger();
 
-    await showStartupCheck('TELEGRAM_BOT_TOKEN', async () => {
-      if (!config.telegram.bot_token) throw new Error('Not set');
-    });
+  const checks = [];
 
-    await showStartupCheck('Anthropic API connection', async () => {
+  checks.push(
+    await showStartupCheck('Anthropic API', async () => {
       const client = new Anthropic({ apiKey: config.anthropic.api_key });
       await client.messages.create({
         model: config.anthropic.model,
         max_tokens: 16,
         messages: [{ role: 'user', content: 'ping' }],
       });
-    });
+    }),
+  );
 
+  checks.push(
     await showStartupCheck('Telegram Bot API', async () => {
       const res = await fetch(
         `https://api.telegram.org/bot${config.telegram.bot_token}/getMe`,
       );
       const data = await res.json();
       if (!data.ok) throw new Error(data.description || 'Invalid token');
-    });
-
-    console.log('\nAll checks complete.');
-  });
-
-// ─── kernel init ─────────────────────────────────────────────
-program
-  .command('init')
-  .description('Interactive setup: create .env and config.yaml')
-  .action(async () => {
-    showLogo();
-
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    const ask = (q) => new Promise((res) => rl.question(q, res));
-
-    const apiKey = await ask('Anthropic API key: ');
-    const botToken = await ask('Telegram Bot Token: ');
-    const userId = await ask('Your Telegram User ID (leave blank for dev mode): ');
-
-    rl.close();
-
-    // Write .env
-    const envContent = `ANTHROPIC_API_KEY=${apiKey}\nTELEGRAM_BOT_TOKEN=${botToken}\n`;
-    writeFileSync('.env', envContent);
-
-    // Write config.yaml
-    const allowedUsers =
-      userId.trim() ? `\n  allowed_users:\n    - ${userId.trim()}` : '\n  allowed_users: []';
-
-    const configContent = `bot:
-  name: KernelBot
-
-anthropic:
-  model: claude-sonnet-4-20250514
-  max_tokens: 8192
-  temperature: 0.3
-  max_tool_depth: 25
-
-telegram:${allowedUsers}
-
-security:
-  blocked_paths:
-    - /etc/shadow
-    - /etc/passwd
-
-logging:
-  level: info
-  max_file_size: 5242880
-
-conversation:
-  max_history: 50
-`;
-    writeFileSync('config.yaml', configContent);
+    }),
+  );
+
+  if (checks.some((c) => !c)) {
+    showError('Startup failed. Fix the issues above and try again.');
+    return false;
+  }
+
+  const conversationManager = new ConversationManager(config);
+  const agent = new Agent({ config, conversationManager });
+
+  startBot(config, agent);
+  showStartupComplete();
+  return true;
+}
+
+async function main() {
+  showLogo();
+
+  const config = await loadConfigInteractive();
+  createLogger(config);
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  let running = true;
+  while (running) {
+    showMenu();
+    const choice = await ask(rl, chalk.cyan('  > '));
+
+    switch (choice.trim()) {
+      case '1': {
+        rl.close();
+        const started = await startBotFlow(config);
+        if (!started) process.exit(1);
+        return; // bot is running, don't show menu again
+      }
+      case '2':
+        await runCheck(config);
+        break;
+      case '3':
+        viewLog('kernel.log');
+        break;
+      case '4':
+        viewLog('kernel-audit.log');
+        break;
+      case '5':
+        running = false;
+        break;
+      default:
+        console.log(chalk.dim('  Invalid choice.\n'));
+    }
+  }
 
-    console.log('\nCreated .env and config.yaml');
-    console.log('Run `kernelbot check` to verify, then `kernelbot start` to launch.');
-  });
+  rl.close();
+  console.log(chalk.dim('  Goodbye.\n'));
+}
 
-program.parse();
+main().catch((err) => {
+  showError(err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.002",
+  "version": "1.0.003",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Tahrei <abdullah@altaheri.me>",

package/src/utils/config.js

@@ -1,8 +1,10 @@
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { createInterface } from 'readline';
 import yaml from 'js-yaml';
 import dotenv from 'dotenv';
+import chalk from 'chalk';
 
 const DEFAULTS = {
   bot: {
@@ -54,18 +56,96 @@ function deepMerge(target, source) {
   return result;
 }
 
+function getConfigDir() {
+  return join(homedir(), '.kernelbot');
+}
+
+function getEnvPath() {
+  const cwdEnv = join(process.cwd(), '.env');
+  if (existsSync(cwdEnv)) return cwdEnv;
+  return join(getConfigDir(), '.env');
+}
+
 function findConfigFile() {
   const cwdPath = join(process.cwd(), 'config.yaml');
   if (existsSync(cwdPath)) return cwdPath;
 
-  const homePath = join(homedir(), '.kernelbot', 'config.yaml');
+  const homePath = join(getConfigDir(), 'config.yaml');
   if (existsSync(homePath)) return homePath;
 
   return null;
 }
 
+function ask(rl, question) {
+  return new Promise((res) => rl.question(question, res));
+}
+
+async function promptForMissing(config) {
+  const missing = [];
+  if (!config.anthropic.api_key) missing.push('ANTHROPIC_API_KEY');
+  if (!config.telegram.bot_token) missing.push('TELEGRAM_BOT_TOKEN');
+
+  if (missing.length === 0) return config;
+
+  console.log(chalk.yellow('\n  Missing credentials detected. Let\'s set them up.\n'));
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const mutableConfig = JSON.parse(JSON.stringify(config));
+  const envLines = [];
+
+  // Read existing .env if any
+  const envPath = getEnvPath();
+  let existingEnv = '';
+  if (existsSync(envPath)) {
+    existingEnv = readFileSync(envPath, 'utf-8');
+  }
+
+  if (!mutableConfig.anthropic.api_key) {
+    const key = await ask(rl, chalk.cyan('  Anthropic API key: '));
+    mutableConfig.anthropic.api_key = key.trim();
+    envLines.push(`ANTHROPIC_API_KEY=${key.trim()}`);
+  }
+
+  if (!mutableConfig.telegram.bot_token) {
+    const token = await ask(rl, chalk.cyan('  Telegram Bot Token: '));
+    mutableConfig.telegram.bot_token = token.trim();
+    envLines.push(`TELEGRAM_BOT_TOKEN=${token.trim()}`);
+  }
+
+  rl.close();
+
+  // Save to ~/.kernelbot/.env so it persists globally
+  if (envLines.length > 0) {
+    const configDir = getConfigDir();
+    mkdirSync(configDir, { recursive: true });
+    const savePath = join(configDir, '.env');
+
+    // Merge with existing content
+    let content = existingEnv ? existingEnv.trimEnd() + '\n' : '';
+    for (const line of envLines) {
+      const key = line.split('=')[0];
+      // Replace if exists, append if not
+      const regex = new RegExp(`^${key}=.*$`, 'm');
+      if (regex.test(content)) {
+        content = content.replace(regex, line);
+      } else {
+        content += line + '\n';
+      }
+    }
+    writeFileSync(savePath, content);
+    console.log(chalk.dim(`\n  Saved to ${savePath}\n`));
+  }
+
+  return mutableConfig;
+}
+
 export function loadConfig() {
+  // Load .env from CWD first, then from ~/.kernelbot/
   dotenv.config();
+  const globalEnv = join(getConfigDir(), '.env');
+  if (existsSync(globalEnv)) {
+    dotenv.config({ path: globalEnv });
+  }
 
   let fileConfig = {};
   const configPath = findConfigFile();
@@ -84,5 +164,10 @@ export function loadConfig() {
     config.telegram.bot_token = process.env.TELEGRAM_BOT_TOKEN;
   }
 
-  return Object.freeze(config);
+  return config;
+}
+
+export async function loadConfigInteractive() {
+  const config = loadConfig();
+  return await promptForMissing(config);
 }

package/src/utils/display.js

@@ -59,29 +59,6 @@ export function showError(msg) {
   );
 }
 
-export function showHelp() {
-  showLogo();
-  console.log(
-    boxen(
-      [
-        chalk.bold('Commands:'),
-        '',
-        `  ${chalk.cyan('kernelbot start')}          ${chalk.dim('Launch the Telegram bot')}`,
-        `  ${chalk.cyan('kernelbot run')} ${chalk.yellow('"prompt"')}   ${chalk.dim('One-off agent call (no Telegram)')}`,
-        `  ${chalk.cyan('kernelbot check')}          ${chalk.dim('Validate config & test APIs')}`,
-        `  ${chalk.cyan('kernelbot init')}           ${chalk.dim('Interactive setup wizard')}`,
-        '',
-        chalk.dim(`  kernelbot --help         Show all options`),
-      ].join('\n'),
-      {
-        padding: 1,
-        borderStyle: 'round',
-        borderColor: 'cyan',
-      },
-    ),
-  );
-}
-
 export function createSpinner(text) {
   return ora({ text, color: 'cyan' });
 }