kernelbot 1.0.38 → 1.0.40

package/src/tools/os.js

@@ -137,12 +137,26 @@ export const handlers = {
     const { config } = context;
     const blockedPaths = config.security?.blocked_paths || [];
 
-    // Simple check: if the command references a blocked path, reject
-    for (const bp of blockedPaths) {
-      const expanded = expandPath(bp);
-      if (command.includes(expanded)) {
-        logger.warn(`execute_command blocked: command references restricted path ${bp}`);
-        return { error: `Blocked: command references restricted path ${bp}` };
+    // Tokenize the command to extract all path-like arguments, then resolve
+    // each one and check against blocked paths. This prevents bypasses via
+    // shell operators (&&, |, ;), quoting, or subshells.
+    const shellTokens = command.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+    for (const token of shellTokens) {
+      // Strip surrounding quotes
+      const cleaned = token.replace(/^["']|["']$/g, '');
+      // Skip tokens that look like flags or shell operators
+      if (/^[-|;&<>]/.test(cleaned) || cleaned.length === 0) continue;
+      try {
+        const resolved = expandPath(cleaned);
+        for (const bp of blockedPaths) {
+          const expandedBp = expandPath(bp);
+          if (resolved.startsWith(expandedBp) || resolved === expandedBp) {
+            logger.warn(`execute_command blocked: argument "${cleaned}" references restricted path ${bp}`);
+            return { error: `Blocked: command references restricted path ${bp}` };
+          }
+        }
+      } catch {
+        // Not a valid path — skip
       }
     }
 

package/src/utils/config.js

@@ -1,11 +1,12 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { createInterface } from 'readline';
 import yaml from 'js-yaml';
 import dotenv from 'dotenv';
 import chalk from 'chalk';
+import * as p from '@clack/prompts';
 import { PROVIDERS } from '../providers/models.js';
+import { handleCancel } from './display.js';
 
 const DEFAULTS = {
   bot: {
@@ -37,7 +38,7 @@ const DEFAULTS = {
   claude_code: {
     model: 'claude-opus-4-6',
     max_turns: 50,
-    timeout_seconds: 600,
+    timeout_seconds: 86400,
     workspace_dir: null, // defaults to ~/.kernelbot/workspaces
     auth_mode: 'system', // system | api_key | oauth_token
   },
@@ -108,10 +109,6 @@ function findConfigFile() {
   return null;
 }
 
-function ask(rl, question) {
-  return new Promise((res) => rl.question(question, res));
-}
-
 /**
  * Migrate legacy `anthropic` config section → `brain` section.
  */
@@ -132,44 +129,33 @@ function migrateAnthropicConfig(config) {
 }
 
 /**
- * Interactive provider → model picker.
+ * Interactive provider → model picker using @clack/prompts.
  */
-export async function promptProviderSelection(rl) {
+export async function promptProviderSelection() {
   const providerKeys = Object.keys(PROVIDERS);
 
-  console.log(chalk.bold('\n  Select AI provider:\n'));
-  providerKeys.forEach((key, i) => {
-    console.log(`  ${chalk.cyan(`${i + 1}.`)} ${PROVIDERS[key].name}`);
+  const providerKey = await p.select({
+    message: 'Select AI provider',
+    options: providerKeys.map(key => ({
+      value: key,
+      label: PROVIDERS[key].name,
+    })),
   });
-  console.log('');
-
-  let providerIdx;
-  while (true) {
-    const input = await ask(rl, chalk.cyan('  Provider (number): '));
-    providerIdx = parseInt(input.trim(), 10) - 1;
-    if (providerIdx >= 0 && providerIdx < providerKeys.length) break;
-    console.log(chalk.dim('  Invalid choice, try again.'));
-  }
+  if (handleCancel(providerKey)) return null;
 
-  const providerKey = providerKeys[providerIdx];
   const provider = PROVIDERS[providerKey];
 
-  console.log(chalk.bold(`\n  Select model for ${provider.name}:\n`));
-  provider.models.forEach((m, i) => {
-    console.log(`  ${chalk.cyan(`${i + 1}.`)} ${m.label} (${m.id})`);
+  const modelId = await p.select({
+    message: `Select model for ${provider.name}`,
+    options: provider.models.map(m => ({
+      value: m.id,
+      label: m.label,
+      hint: m.id,
+    })),
   });
-  console.log('');
+  if (handleCancel(modelId)) return null;
 
-  let modelIdx;
-  while (true) {
-    const input = await ask(rl, chalk.cyan('  Model (number): '));
-    modelIdx = parseInt(input.trim(), 10) - 1;
-    if (modelIdx >= 0 && modelIdx < provider.models.length) break;
-    console.log(chalk.dim('  Invalid choice, try again.'));
-  }
-
-  const model = provider.models[modelIdx];
-  return { providerKey, modelId: model.id };
+  return { providerKey, modelId };
 }
 
 /**
@@ -252,26 +238,29 @@ export function saveClaudeCodeAuth(config, mode, value) {
 /**
  * Full interactive flow: change orchestrator model + optionally enter API key.
  */
-export async function changeOrchestratorModel(config, rl) {
+export async function changeOrchestratorModel(config) {
   const { createProvider } = await import('../providers/index.js');
-  const { providerKey, modelId } = await promptProviderSelection(rl);
+  const result = await promptProviderSelection();
+  if (!result) return config;
 
+  const { providerKey, modelId } = result;
   const providerDef = PROVIDERS[providerKey];
 
   // Resolve API key
   const envKey = providerDef.envKey;
   let apiKey = process.env[envKey];
   if (!apiKey) {
-    const key = await ask(rl, chalk.cyan(`\n  ${providerDef.name} API key (${envKey}): `));
-    if (!key.trim()) {
-      console.log(chalk.yellow('\n  No API key provided. Orchestrator not changed.\n'));
-      return config;
-    }
+    const key = await p.text({
+      message: `${providerDef.name} API key (${envKey})`,
+      validate: (v) => (!v.trim() ? 'API key is required' : undefined),
+    });
+    if (handleCancel(key)) return config;
     apiKey = key.trim();
   }
 
   // Validate the new provider before saving anything
-  console.log(chalk.dim(`\n  Verifying ${providerDef.name} / ${modelId}...`));
+  const s = p.spinner();
+  s.start(`Verifying ${providerDef.name} / ${modelId}`);
   const testConfig = {
     brain: {
       provider: providerKey,
@@ -284,16 +273,15 @@ export async function changeOrchestratorModel(config, rl) {
   try {
     const testProvider = createProvider(testConfig);
     await testProvider.ping();
+    s.stop(`${providerDef.name} / ${modelId} verified`);
   } catch (err) {
-    console.log(chalk.red(`\n  ✖ Verification failed: ${err.message}`));
-    console.log(chalk.yellow(`  Orchestrator not changed. Keeping current model.\n`));
+    s.stop(chalk.red(`Verification failed: ${err.message}`));
+    p.log.warn('Orchestrator not changed. Keeping current model.');
     return config;
   }
 
   // Validation passed — save everything
   const savedPath = saveOrchestratorToYaml(providerKey, modelId);
-  console.log(chalk.dim(`  Saved to ${savedPath}`));
-
   config.orchestrator.provider = providerKey;
   config.orchestrator.model = modelId;
   config.orchestrator.api_key = apiKey;
@@ -301,50 +289,51 @@ export async function changeOrchestratorModel(config, rl) {
   // Save the key if it was newly entered
   if (!process.env[envKey]) {
     saveCredential(config, envKey, apiKey);
-    console.log(chalk.dim('  API key saved.\n'));
   }
 
-  console.log(chalk.green(`  ✔ Orchestrator switched to ${providerDef.name} / ${modelId}\n`));
+  p.log.success(`Orchestrator switched to ${providerDef.name} / ${modelId}`);
   return config;
 }
 
 /**
  * Full interactive flow: change brain model + optionally enter API key.
  */
-export async function changeBrainModel(config, rl) {
+export async function changeBrainModel(config) {
   const { createProvider } = await import('../providers/index.js');
-  const { providerKey, modelId } = await promptProviderSelection(rl);
+  const result = await promptProviderSelection();
+  if (!result) return config;
 
+  const { providerKey, modelId } = result;
   const providerDef = PROVIDERS[providerKey];
 
   // Resolve API key
   const envKey = providerDef.envKey;
   let apiKey = process.env[envKey];
   if (!apiKey) {
-    const key = await ask(rl, chalk.cyan(`\n  ${providerDef.name} API key (${envKey}): `));
-    if (!key.trim()) {
-      console.log(chalk.yellow('\n  No API key provided. Brain not changed.\n'));
-      return config;
-    }
+    const key = await p.text({
+      message: `${providerDef.name} API key (${envKey})`,
+      validate: (v) => (!v.trim() ? 'API key is required' : undefined),
+    });
+    if (handleCancel(key)) return config;
     apiKey = key.trim();
   }
 
   // Validate the new provider before saving anything
-  console.log(chalk.dim(`\n  Verifying ${providerDef.name} / ${modelId}...`));
+  const s = p.spinner();
+  s.start(`Verifying ${providerDef.name} / ${modelId}`);
   const testConfig = { ...config, brain: { ...config.brain, provider: providerKey, model: modelId, api_key: apiKey } };
   try {
     const testProvider = createProvider(testConfig);
     await testProvider.ping();
+    s.stop(`${providerDef.name} / ${modelId} verified`);
   } catch (err) {
-    console.log(chalk.red(`\n  ✖ Verification failed: ${err.message}`));
-    console.log(chalk.yellow(`  Brain not changed. Keeping current model.\n`));
+    s.stop(chalk.red(`Verification failed: ${err.message}`));
+    p.log.warn('Brain not changed. Keeping current model.');
     return config;
   }
 
   // Validation passed — save everything
-  const savedPath = saveProviderToYaml(providerKey, modelId);
-  console.log(chalk.dim(`  Saved to ${savedPath}`));
-
+  saveProviderToYaml(providerKey, modelId);
   config.brain.provider = providerKey;
   config.brain.model = modelId;
   config.brain.api_key = apiKey;
@@ -352,10 +341,9 @@ export async function changeBrainModel(config, rl) {
   // Save the key if it was newly entered
   if (!process.env[envKey]) {
     saveCredential(config, envKey, apiKey);
-    console.log(chalk.dim('  API key saved.\n'));
   }
 
-  console.log(chalk.green(`  ✔ Brain switched to ${providerDef.name} / ${modelId}\n`));
+  p.log.success(`Brain switched to ${providerDef.name} / ${modelId}`);
   return config;
 }
 
@@ -366,9 +354,8 @@ async function promptForMissing(config) {
 
   if (missing.length === 0) return config;
 
-  console.log(chalk.yellow('\n  Missing credentials detected. Let\'s set them up.\n'));
+  p.log.warn('Missing credentials detected. Let\'s set them up.');
 
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
   const mutableConfig = JSON.parse(JSON.stringify(config));
   const envLines = [];
 
@@ -381,8 +368,11 @@ async function promptForMissing(config) {
 
   if (!mutableConfig.brain.api_key) {
     // Run brain provider selection flow
-    console.log(chalk.bold('\n  🧠 Worker Brain'));
-    const { providerKey, modelId } = await promptProviderSelection(rl);
+    p.log.step('Worker Brain');
+    const brainResult = await promptProviderSelection();
+    if (!brainResult) { p.cancel('Setup cancelled.'); process.exit(0); }
+
+    const { providerKey, modelId } = brainResult;
     mutableConfig.brain.provider = providerKey;
     mutableConfig.brain.model = modelId;
     saveProviderToYaml(providerKey, modelId);
@@ -390,36 +380,49 @@ async function promptForMissing(config) {
     const providerDef = PROVIDERS[providerKey];
     const envKey = providerDef.envKey;
 
-    const key = await ask(rl, chalk.cyan(`\n  ${providerDef.name} API key: `));
+    const key = await p.text({
+      message: `${providerDef.name} API key`,
+      validate: (v) => (!v.trim() ? 'API key is required' : undefined),
+    });
+    if (handleCancel(key)) { process.exit(0); }
     mutableConfig.brain.api_key = key.trim();
     envLines.push(`${envKey}=${key.trim()}`);
 
     // Orchestrator provider selection
-    console.log(chalk.bold('\n  🎛️  Orchestrator'));
-    const sameChoice = await ask(rl, chalk.cyan(`  Use same provider (${providerDef.name} / ${modelId}) for orchestrator? [Y/n]: `));
-    if (!sameChoice.trim() || sameChoice.trim().toLowerCase() === 'y') {
+    p.log.step('Orchestrator');
+    const sameChoice = await p.confirm({
+      message: `Use same provider (${providerDef.name} / ${modelId}) for orchestrator?`,
+      initialValue: true,
+    });
+    if (handleCancel(sameChoice)) { process.exit(0); }
+
+    if (sameChoice) {
       mutableConfig.orchestrator.provider = providerKey;
       mutableConfig.orchestrator.model = modelId;
       mutableConfig.orchestrator.api_key = key.trim();
       saveOrchestratorToYaml(providerKey, modelId);
     } else {
-      const orch = await promptProviderSelection(rl);
+      const orch = await promptProviderSelection();
+      if (!orch) { p.cancel('Setup cancelled.'); process.exit(0); }
+
       mutableConfig.orchestrator.provider = orch.providerKey;
       mutableConfig.orchestrator.model = orch.modelId;
       saveOrchestratorToYaml(orch.providerKey, orch.modelId);
 
       const orchProviderDef = PROVIDERS[orch.providerKey];
       if (orch.providerKey === providerKey) {
-        // Same provider — reuse the API key
         mutableConfig.orchestrator.api_key = key.trim();
       } else {
-        // Different provider — need a separate key
         const orchEnvKey = orchProviderDef.envKey;
         const orchExisting = process.env[orchEnvKey];
         if (orchExisting) {
           mutableConfig.orchestrator.api_key = orchExisting;
         } else {
-          const orchKey = await ask(rl, chalk.cyan(`\n  ${orchProviderDef.name} API key: `));
+          const orchKey = await p.text({
+            message: `${orchProviderDef.name} API key`,
+            validate: (v) => (!v.trim() ? 'API key is required' : undefined),
+          });
+          if (handleCancel(orchKey)) { process.exit(0); }
           mutableConfig.orchestrator.api_key = orchKey.trim();
           envLines.push(`${orchEnvKey}=${orchKey.trim()}`);
         }
@@ -428,13 +431,15 @@ async function promptForMissing(config) {
   }
 
   if (!mutableConfig.telegram.bot_token) {
-    const token = await ask(rl, chalk.cyan('  Telegram Bot Token: '));
+    const token = await p.text({
+      message: 'Telegram Bot Token',
+      validate: (v) => (!v.trim() ? 'Token is required' : undefined),
+    });
+    if (handleCancel(token)) { process.exit(0); }
     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();
@@ -444,9 +449,8 @@ async function promptForMissing(config) {
     // 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');
+      const envKey = line.split('=')[0];
+      const regex = new RegExp(`^${envKey}=.*$`, 'm');
       if (regex.test(content)) {
         content = content.replace(regex, line);
       } else {
@@ -454,7 +458,7 @@ async function promptForMissing(config) {
       }
     }
     writeFileSync(savePath, content);
-    console.log(chalk.dim(`\n  Saved to ${savePath}\n`));
+    p.log.info(`Saved to ${savePath}`);
   }
 
   return mutableConfig;

package/src/utils/display.js

@@ -1,19 +1,34 @@
-import { readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import chalk from 'chalk';
-import ora from 'ora';
-import boxen from 'boxen';
-import gradient from 'gradient-string';
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { networkInterfaces } from "os";
+import chalk from "chalk";
+import ora from "ora";
+import boxen from "boxen";
+import gradient from "gradient-string";
+import * as p from "@clack/prompts";
+import { PROVIDERS } from "../providers/models.js";
+
+export { p };
+
+function getLocalIp() {
+  const nets = networkInterfaces();
+  for (const iface of Object.values(nets)) {
+    for (const info of iface) {
+      if (info.family === "IPv4" && !info.internal) return info.address;
+    }
+  }
+  return "localhost";
+}
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 function getVersion() {
   try {
-    const pkg = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf-8'));
+    const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf-8"));
     return pkg.version;
   } catch {
-    return 'unknown';
+    return "unknown";
   }
 }
 
@@ -38,38 +53,14 @@ const LOGO = `
 `;
 
 // Green terminal gradient
-const monoGradient = gradient([
-  '#00ff41',
-  '#00cc33',
-  '#009926',
-  '#006619',
-]);
+const monoGradient = gradient(["#00ff41", "#00cc33", "#009926", "#006619"]);
 
 export function showLogo() {
   console.log(monoGradient.multiline(LOGO));
-  console.log(chalk.dim(`  AI Engineering Agent — v${getVersion()}\n`));
-  console.log(
-    boxen(
-      chalk.yellow.bold('WARNING') +
-        chalk.yellow(
-          '\n\nKernelBot has full access to your operating system.\n' +
-            'It can execute commands, read/write files, manage processes,\n' +
-            'and interact with external services on your behalf.\n\n' +
-            'Only run this on machines you control.\n' +
-            'Set OWNER_TELEGRAM_ID in .env or allowed_users in config.yaml.',
-        ),
-      {
-        padding: 1,
-        borderStyle: 'round',
-        borderColor: 'yellow',
-      },
-    ),
-  );
-  console.log('');
 }
 
 export async function showStartupCheck(label, checkFn) {
-  const spinner = ora({ text: label, color: 'cyan' }).start();
+  const spinner = ora({ text: label, color: "cyan" }).start();
   try {
     await checkFn();
     spinner.succeed(chalk.green(label));
@@ -82,11 +73,11 @@ export async function showStartupCheck(label, checkFn) {
 
 export function showStartupComplete() {
   console.log(
-    boxen(chalk.green.bold('KernelBot is live'), {
+    boxen(chalk.green.bold("KernelBot is live"), {
       padding: 1,
       margin: { top: 1 },
-      borderStyle: 'round',
-      borderColor: 'green',
+      borderStyle: "round",
+      borderColor: "green",
     }),
   );
 }
@@ -95,8 +86,8 @@ export function showSuccess(msg) {
   console.log(
     boxen(chalk.green(msg), {
       padding: 1,
-      borderStyle: 'round',
-      borderColor: 'green',
+      borderStyle: "round",
+      borderColor: "green",
     }),
   );
 }
@@ -105,14 +96,14 @@ export function showError(msg) {
   console.log(
     boxen(chalk.red(msg), {
       padding: 1,
-      borderStyle: 'round',
-      borderColor: 'red',
+      borderStyle: "round",
+      borderColor: "red",
     }),
   );
 }
 
 export function createSpinner(text) {
-  return ora({ text, color: 'cyan' });
+  return ora({ text, color: "cyan" });
 }
 
 /**
@@ -121,47 +112,108 @@ export function createSpinner(text) {
  * @param {boolean} isActive — whether this is the currently active character
  */
 export function showCharacterCard(character, isActive = false) {
-  const art = character.asciiArt || '';
-  const activeTag = isActive ? chalk.green(' (active)') : '';
+  const art = character.asciiArt || "";
+  const activeTag = isActive ? chalk.green(" (active)") : "";
   const content = [
     `${character.emoji}  ${chalk.bold(character.name)}${activeTag}`,
     chalk.dim(`"${character.tagline}"`),
-    '',
-    ...(art ? art.split('\n').map(line => chalk.cyan(line)) : []),
-    '',
-    chalk.dim(`Origin: ${character.origin || 'Unknown'}`),
-    chalk.dim(`Style: ${character.age || 'Unknown'}`),
-  ].join('\n');
+    "",
+    ...(art ? art.split("\n").map((line) => chalk.cyan(line)) : []),
+    "",
+    chalk.dim(`Origin: ${character.origin || "Unknown"}`),
+    chalk.dim(`Age: ${character.age || "Unknown"}`),
+  ].join("\n");
 
   console.log(
     boxen(content, {
       padding: 1,
-      borderStyle: 'round',
-      borderColor: isActive ? 'green' : 'cyan',
+      borderStyle: "round",
+      borderColor: isActive ? "green" : "cyan",
     }),
   );
 }
 
 /**
- * Display the full character gallery for CLI selection.
- * @param {object[]} characters — array of character profiles
- * @param {string|null} activeId — ID of the currently active character
+ * Format "Provider / model" label for a config section.
+ * @param {object} config — full config
+ * @param {'brain'|'orchestrator'} section
+ */
+export function formatProviderLabel(config, section) {
+  const sec = config[section];
+  const providerDef = PROVIDERS[sec.provider];
+  const name = providerDef ? providerDef.name : sec.provider;
+  return `${name} / ${sec.model}`;
+}
+
+/**
+ * Centralized cancel handler for @clack/prompts.
+ * Call after every prompt — exits gracefully on Ctrl+C.
+ */
+export function handleCancel(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Claude Code-inspired info box shown after the logo.
  */
+export function showWelcomeScreen(config, characterManager) {
+  const version = getVersion();
+
+  const orchLabel = formatProviderLabel(config, "orchestrator");
+  const brainLabel = formatProviderLabel(config, "brain");
+
+  let charLabel = "None";
+  if (characterManager) {
+    const activeId = characterManager.getActiveCharacterId();
+    const active = characterManager.getCharacter(activeId);
+    if (active) charLabel = `${active.emoji} ${active.name}`;
+  }
+
+  const lifeEnabled = config.life?.enabled !== false;
+  const dashPort = config.dashboard?.port || 3000;
+  const dashEnabled = config.dashboard?.enabled;
+
+  const pad = (label, width = 18) => label.padEnd(width);
+
+  const lines = [
+    "",
+    `  ${chalk.dim(pad("Orchestrator"))}${orchLabel}`,
+    `  ${chalk.dim(pad("Brain"))}${brainLabel}`,
+    `  ${chalk.dim(pad("Character"))}${charLabel}`,
+    `  ${chalk.dim(pad("Life Engine"))}${lifeEnabled ? chalk.green("enabled") : chalk.yellow("disabled")}`,
+    `  ${chalk.dim(pad("Dashboard"))}${dashEnabled ? chalk.green(`http://${getLocalIp()}:${dashPort}/`) : chalk.yellow("off")}`,
+    "",
+    chalk.dim("  ↑↓ Navigate · Enter Select · Ctrl+C Cancel"),
+  ];
+
+  console.log(
+    boxen(lines.join("\n"), {
+      title: `KERNEL Bot v${version}`,
+      titleAlignment: "left",
+      padding: { top: 0, bottom: 0, left: 0, right: 2 },
+      borderStyle: "round",
+      borderColor: "green",
+    }),
+  );
+}
+
 export function showCharacterGallery(characters, activeId = null) {
-  console.log('');
+  console.log("");
   console.log(
-    gradient(['#ff6b6b', '#feca57', '#48dbfb', '#ff9ff3']).multiline(
-      '  ═══════════════════════════════\n' +
-      '     CHOOSE YOUR CHARACTER\n' +
-      '  ═══════════════════════════════',
+    gradient(["#ff6b6b", "#feca57", "#48dbfb", "#ff9ff3"]).multiline(
+      "  ═══════════════════════════════\n" + "     CHOOSE YOUR CHARACTER\n" + "  ═══════════════════════════════",
     ),
   );
-  console.log('');
-  console.log(chalk.dim('  Each character has their own personality,'));
-  console.log(chalk.dim('  memories, and story that evolves with you.'));
-  console.log('');
+  console.log("");
+  console.log(chalk.dim("  Each character has their own personality,"));
+  console.log(chalk.dim("  memories, and story that evolves with you."));
+  console.log("");
 
   for (const c of characters) {
     showCharacterCard(c, c.id === activeId);
   }
-}
+}

package/src/utils/logger.js

@@ -16,7 +16,7 @@ export function createLogger(config) {
         format: winston.format.combine(
           winston.format.colorize(),
           winston.format.printf(({ level, message, timestamp }) => {
-            return `[KernelBot] ${level}: ${message}`;
+            return `${timestamp} [KernelBot] ${level}: ${message}`;
           }),
         ),
       }),