kernelbot 1.0.37 → 1.0.38

package/src/tools/x.js

@@ -0,0 +1,256 @@
+import { XApi } from '../services/x-api.js';
+import { getLogger } from '../utils/logger.js';
+
+/**
+ * Get a configured X API client from the tool context.
+ */
+function getClient(context) {
+  const cfg = context.config.x;
+  if (!cfg?.consumer_key || !cfg?.consumer_secret || !cfg?.access_token || !cfg?.access_token_secret) {
+    throw new Error('X (Twitter) not connected. Use /x link to connect your account.');
+  }
+  return new XApi({
+    consumerKey: cfg.consumer_key,
+    consumerSecret: cfg.consumer_secret,
+    accessToken: cfg.access_token,
+    accessTokenSecret: cfg.access_token_secret,
+  });
+}
+
+function handle403(err) {
+  if (err.response?.status === 403) {
+    return { error: 'Access denied (403). Your X Access Token may be Read-only. Go to the X Developer Portal → App Settings → change permissions to "Read and Write", then regenerate your Access Token.' };
+  }
+  return null;
+}
+
+export const definitions = [
+  {
+    name: 'x_post_tweet',
+    description: 'Post a new tweet on X (Twitter).',
+    input_schema: {
+      type: 'object',
+      properties: {
+        text: {
+          type: 'string',
+          description: 'The tweet text (max 280 characters)',
+        },
+      },
+      required: ['text'],
+    },
+  },
+  {
+    name: 'x_reply_to_tweet',
+    description: 'Reply to an existing tweet on X (Twitter).',
+    input_schema: {
+      type: 'object',
+      properties: {
+        text: {
+          type: 'string',
+          description: 'The reply text',
+        },
+        reply_to_id: {
+          type: 'string',
+          description: 'The tweet ID to reply to',
+        },
+      },
+      required: ['text', 'reply_to_id'],
+    },
+  },
+  {
+    name: 'x_get_my_tweets',
+    description: 'Get the authenticated user\'s recent tweets on X (Twitter).',
+    input_schema: {
+      type: 'object',
+      properties: {
+        count: {
+          type: 'number',
+          description: 'Number of tweets to fetch (default 10, max 100)',
+        },
+      },
+    },
+  },
+  {
+    name: 'x_get_tweet',
+    description: 'Get a specific tweet by its ID.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        tweet_id: {
+          type: 'string',
+          description: 'The tweet ID',
+        },
+      },
+      required: ['tweet_id'],
+    },
+  },
+  {
+    name: 'x_search_tweets',
+    description: 'Search recent tweets on X (Twitter). Returns tweets from the last 7 days.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Search query (supports X search operators)',
+        },
+        count: {
+          type: 'number',
+          description: 'Number of results (default 10, max 100)',
+        },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'x_like_tweet',
+    description: 'Like a tweet on X (Twitter).',
+    input_schema: {
+      type: 'object',
+      properties: {
+        tweet_id: {
+          type: 'string',
+          description: 'The tweet ID to like',
+        },
+      },
+      required: ['tweet_id'],
+    },
+  },
+  {
+    name: 'x_retweet',
+    description: 'Retweet a tweet on X (Twitter).',
+    input_schema: {
+      type: 'object',
+      properties: {
+        tweet_id: {
+          type: 'string',
+          description: 'The tweet ID to retweet',
+        },
+      },
+      required: ['tweet_id'],
+    },
+  },
+  {
+    name: 'x_delete_tweet',
+    description: 'Delete one of your own tweets on X (Twitter).',
+    input_schema: {
+      type: 'object',
+      properties: {
+        tweet_id: {
+          type: 'string',
+          description: 'The tweet ID to delete',
+        },
+      },
+      required: ['tweet_id'],
+    },
+  },
+  {
+    name: 'x_get_profile',
+    description: 'Get the authenticated X (Twitter) profile info.',
+    input_schema: {
+      type: 'object',
+      properties: {},
+    },
+  },
+];
+
+export const handlers = {
+  x_post_tweet: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const tweet = await client.postTweet(params.text);
+      return { success: true, message: 'Tweet posted', tweet };
+    } catch (err) {
+      getLogger().error(`x_post_tweet failed: ${err.message}`);
+      return handle403(err) || { error: err.response?.data?.detail || err.message };
+    }
+  },
+
+  x_reply_to_tweet: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const tweet = await client.replyToTweet(params.text, params.reply_to_id);
+      return { success: true, message: 'Reply posted', tweet };
+    } catch (err) {
+      getLogger().error(`x_reply_to_tweet failed: ${err.message}`);
+      return handle403(err) || { error: err.response?.data?.detail || err.message };
+    }
+  },
+
+  x_get_my_tweets: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const tweets = await client.getMyTweets(params.count || 10);
+      return { tweets, count: tweets.length };
+    } catch (err) {
+      getLogger().error(`x_get_my_tweets failed: ${err.message}`);
+      return { error: err.response?.data?.detail || err.message };
+    }
+  },
+
+  x_get_tweet: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const tweet = await client.getTweet(params.tweet_id);
+      return { tweet };
+    } catch (err) {
+      getLogger().error(`x_get_tweet failed: ${err.message}`);
+      return { error: err.response?.data?.detail || err.message };
+    }
+  },
+
+  x_search_tweets: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const tweets = await client.searchRecentTweets(params.query, params.count || 10);
+      return { tweets, count: tweets.length, query: params.query };
+    } catch (err) {
+      getLogger().error(`x_search_tweets failed: ${err.message}`);
+      return { error: err.response?.data?.detail || err.message };
+    }
+  },
+
+  x_like_tweet: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const result = await client.likeTweet(params.tweet_id);
+      return { success: true, message: 'Tweet liked', result };
+    } catch (err) {
+      getLogger().error(`x_like_tweet failed: ${err.message}`);
+      return handle403(err) || { error: err.response?.data?.detail || err.message };
+    }
+  },
+
+  x_retweet: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const result = await client.retweet(params.tweet_id);
+      return { success: true, message: 'Retweeted', result };
+    } catch (err) {
+      getLogger().error(`x_retweet failed: ${err.message}`);
+      return handle403(err) || { error: err.response?.data?.detail || err.message };
+    }
+  },
+
+  x_delete_tweet: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const result = await client.deleteTweet(params.tweet_id);
+      return { success: true, message: 'Tweet deleted', result };
+    } catch (err) {
+      getLogger().error(`x_delete_tweet failed: ${err.message}`);
+      return handle403(err) || { error: err.response?.data?.detail || err.message };
+    }
+  },
+
+  x_get_profile: async (params, context) => {
+    try {
+      const client = getClient(context);
+      const profile = await client.getMe();
+      return { profile };
+    } catch (err) {
+      getLogger().error(`x_get_profile failed: ${err.message}`);
+      return { error: err.response?.data?.detail || err.message };
+    }
+  },
+};

package/src/utils/config.js

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
+import { join } from 'path';
 import { homedir } from 'os';
 import { createInterface } from 'readline';
 import yaml from 'js-yaml';
@@ -61,6 +61,12 @@ const DEFAULTS = {
     max_history: 50,
     recent_window: 10,
   },
+  dashboard: {
+    enabled: false,
+    port: 3000,
+  },
+  linkedin: {},
+  x: {},
 };
 
 function deepMerge(target, source) {
@@ -167,9 +173,12 @@ export async function promptProviderSelection(rl) {
 }
 
 /**
- * Save provider and model to config.yaml.
+ * Read config.yaml, merge changes into a top-level section, and write it back.
+ * @param {string} section - The top-level YAML key to update (e.g. 'brain', 'orchestrator').
+ * @param {object} changes - Key-value pairs to merge into that section.
+ * @returns {string} The path to the written config file.
  */
-export function saveProviderToYaml(providerKey, modelId) {
+function _patchConfigYaml(section, changes) {
   const configDir = getConfigDir();
   mkdirSync(configDir, { recursive: true });
   const configPath = join(configDir, 'config.yaml');
@@ -179,16 +188,24 @@ export function saveProviderToYaml(providerKey, modelId) {
     existing = yaml.load(readFileSync(configPath, 'utf-8')) || {};
   }
 
-  existing.brain = {
-    ...(existing.brain || {}),
-    provider: providerKey,
-    model: modelId,
-  };
+  existing[section] = { ...(existing[section] || {}), ...changes };
+  writeFileSync(configPath, yaml.dump(existing, { lineWidth: -1 }));
+  return configPath;
+}
+
+/**
+ * Save provider and model to config.yaml.
+ */
+export function saveProviderToYaml(providerKey, modelId) {
+  const configPath = _patchConfigYaml('brain', { provider: providerKey, model: modelId });
 
   // Remove legacy anthropic section if migrating
-  delete existing.anthropic;
+  let existing = yaml.load(readFileSync(configPath, 'utf-8')) || {};
+  if (existing.anthropic) {
+    delete existing.anthropic;
+    writeFileSync(configPath, yaml.dump(existing, { lineWidth: -1 }));
+  }
 
-  writeFileSync(configPath, yaml.dump(existing, { lineWidth: -1 }));
   return configPath;
 }
 
@@ -196,66 +213,28 @@ export function saveProviderToYaml(providerKey, modelId) {
  * Save orchestrator provider and model to config.yaml.
  */
 export function saveOrchestratorToYaml(providerKey, modelId) {
-  const configDir = getConfigDir();
-  mkdirSync(configDir, { recursive: true });
-  const configPath = join(configDir, 'config.yaml');
-
-  let existing = {};
-  if (existsSync(configPath)) {
-    existing = yaml.load(readFileSync(configPath, 'utf-8')) || {};
-  }
-
-  existing.orchestrator = {
-    ...(existing.orchestrator || {}),
-    provider: providerKey,
-    model: modelId,
-  };
+  return _patchConfigYaml('orchestrator', { provider: providerKey, model: modelId });
+}
 
-  writeFileSync(configPath, yaml.dump(existing, { lineWidth: -1 }));
-  return configPath;
+/**
+ * Save dashboard config to config.yaml.
+ */
+export function saveDashboardToYaml(changes) {
+  return _patchConfigYaml('dashboard', changes);
 }
 
 /**
  * Save Claude Code model to config.yaml.
  */
 export function saveClaudeCodeModelToYaml(modelId) {
-  const configDir = getConfigDir();
-  mkdirSync(configDir, { recursive: true });
-  const configPath = join(configDir, 'config.yaml');
-
-  let existing = {};
-  if (existsSync(configPath)) {
-    existing = yaml.load(readFileSync(configPath, 'utf-8')) || {};
-  }
-
-  existing.claude_code = {
-    ...(existing.claude_code || {}),
-    model: modelId,
-  };
-
-  writeFileSync(configPath, yaml.dump(existing, { lineWidth: -1 }));
-  return configPath;
+  return _patchConfigYaml('claude_code', { model: modelId });
 }
 
 /**
  * Save Claude Code auth mode + credential to config.yaml and .env.
  */
 export function saveClaudeCodeAuth(config, mode, value) {
-  const configDir = getConfigDir();
-  mkdirSync(configDir, { recursive: true });
-  const configPath = join(configDir, 'config.yaml');
-
-  let existing = {};
-  if (existsSync(configPath)) {
-    existing = yaml.load(readFileSync(configPath, 'utf-8')) || {};
-  }
-
-  existing.claude_code = {
-    ...(existing.claude_code || {}),
-    auth_mode: mode,
-  };
-
-  writeFileSync(configPath, yaml.dump(existing, { lineWidth: -1 }));
+  _patchConfigYaml('claude_code', { auth_mode: mode });
 
   // Update live config
   config.claude_code.auth_mode = mode;
@@ -556,6 +535,34 @@ export function loadConfig() {
     config.claude_code.oauth_token = process.env.CLAUDE_CODE_OAUTH_TOKEN;
   }
 
+  // LinkedIn token-based auth from env
+  if (process.env.LINKEDIN_ACCESS_TOKEN) {
+    if (!config.linkedin) config.linkedin = {};
+    config.linkedin.access_token = process.env.LINKEDIN_ACCESS_TOKEN;
+  }
+  if (process.env.LINKEDIN_PERSON_URN) {
+    if (!config.linkedin) config.linkedin = {};
+    config.linkedin.person_urn = process.env.LINKEDIN_PERSON_URN;
+  }
+
+  // X (Twitter) OAuth 1.0a credentials from env
+  if (process.env.X_CONSUMER_KEY) {
+    if (!config.x) config.x = {};
+    config.x.consumer_key = process.env.X_CONSUMER_KEY;
+  }
+  if (process.env.X_CONSUMER_SECRET) {
+    if (!config.x) config.x = {};
+    config.x.consumer_secret = process.env.X_CONSUMER_SECRET;
+  }
+  if (process.env.X_ACCESS_TOKEN) {
+    if (!config.x) config.x = {};
+    config.x.access_token = process.env.X_ACCESS_TOKEN;
+  }
+  if (process.env.X_ACCESS_TOKEN_SECRET) {
+    if (!config.x) config.x = {};
+    config.x.access_token_secret = process.env.X_ACCESS_TOKEN_SECRET;
+  }
+
   return config;
 }
 
@@ -619,6 +626,30 @@ export function saveCredential(config, envKey, value) {
       if (!config.jira) config.jira = {};
       config.jira.api_token = value;
       break;
+    case 'LINKEDIN_ACCESS_TOKEN':
+      if (!config.linkedin) config.linkedin = {};
+      config.linkedin.access_token = value;
+      break;
+    case 'LINKEDIN_PERSON_URN':
+      if (!config.linkedin) config.linkedin = {};
+      config.linkedin.person_urn = value;
+      break;
+    case 'X_CONSUMER_KEY':
+      if (!config.x) config.x = {};
+      config.x.consumer_key = value;
+      break;
+    case 'X_CONSUMER_SECRET':
+      if (!config.x) config.x = {};
+      config.x.consumer_secret = value;
+      break;
+    case 'X_ACCESS_TOKEN':
+      if (!config.x) config.x = {};
+      config.x.access_token = value;
+      break;
+    case 'X_ACCESS_TOKEN_SECRET':
+      if (!config.x) config.x = {};
+      config.x.access_token_secret = value;
+      break;
   }
 
   // Also set in process.env so tools pick it up
@@ -652,5 +683,21 @@ export function getMissingCredential(toolName, config) {
     }
   }
 
+  const linkedinTools = ['linkedin_create_post', 'linkedin_get_my_posts', 'linkedin_get_post', 'linkedin_comment_on_post', 'linkedin_get_comments', 'linkedin_like_post', 'linkedin_get_profile', 'linkedin_delete_post'];
+
+  if (linkedinTools.includes(toolName)) {
+    if (!config.linkedin?.access_token && !process.env.LINKEDIN_ACCESS_TOKEN) {
+      return { envKey: 'LINKEDIN_ACCESS_TOKEN', label: 'LinkedIn Access Token (from /linkedin link or https://www.linkedin.com/developers/tools/oauth/token-generator)' };
+    }
+  }
+
+  const xTools = ['x_post_tweet', 'x_reply_to_tweet', 'x_get_my_tweets', 'x_get_tweet', 'x_search_tweets', 'x_like_tweet', 'x_retweet', 'x_delete_tweet', 'x_get_profile'];
+
+  if (xTools.includes(toolName)) {
+    if (!config.x?.consumer_key && !process.env.X_CONSUMER_KEY) {
+      return { envKey: 'X_CONSUMER_KEY', label: 'X (Twitter) Consumer Key (from /x link or X Developer Portal)' };
+    }
+  }
+
   return null;
 }

package/src/utils/display.js

@@ -18,21 +18,31 @@ function getVersion() {
 }
 
 const LOGO = `
- ██╗  ██╗███████╗██████╗ ███╗   ██╗███████╗██╗     ██████╗  ██████╗ ████████╗
- ██║ ██╔╝██╔════╝██╔══██╗████╗  ██║██╔════╝██║     ██╔══██╗██╔═══██╗╚══██╔══╝
- █████╔╝ █████╗  ██████╔╝██╔██╗ ██║█████╗  ██║     ██████╔╝██║   ██║   ██║
- ██╔═██╗ ██╔══╝  ██╔══██╗██║╚██╗██║██╔══╝  ██║     ██╔══██╗██║   ██║   ██║
- ██║  ██╗███████╗██║  ██║██║ ╚████║███████╗███████╗██████╔╝╚██████╔╝   ██║
- ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚══════╝╚══════╝╚═════╝  ╚═════╝    ╚═╝
+          ▄▄████████▄▄
+       ▄██▀▀        ▀▀██▄
+     ▄█▀    ▄██████▄    ▀█▄
+    █▀   ▄██▀      ▀██▄   ▀█
+   █▀  ▄█▀   ▄████▄  ▀█▄  ▀█
+  ▐█  ██   ▄█▀    ▀█▄  ██  █▌
+  ▐█  █▌  █▀   ██   ▀█ ▐█  █▌
+  ▐█  █▌  ▀█▄  ▀▀██▀  ▐█  █▌
+   █▄  ██   ▀▀████▀  ██  ▄█
+    █▄  ▀██▄      ▄██▀  ▄█
+     ▀█▄   ▀██████▀   ▄█▀
+       ▀██▄▄      ▄▄██▀
+          ▀▀████████▀▀
+
+ █▄▀ █▀▀ █▀█ █▄ █ █▀▀ █   █▀▄ █▀█ ▀█▀
+ █▀▄ █▀▀ █▄▀ █ ██ █▀▀ █   ██▀ █ █  █
+ █ █ █▄▄ █ █ █ ▀█ █▄▄ █▄▄ █▄▀ █▄█  █
 `;
 
-// White to ~70% black gradient
+// Green terminal gradient
 const monoGradient = gradient([
-  '#FFFFFF',
-  '#D0D0D0',
-  '#A0A0A0',
-  '#707070',
-  '#4D4D4D',
+  '#00ff41',
+  '#00cc33',
+  '#009926',
+  '#006619',
 ]);
 
 export function showLogo() {
@@ -103,4 +113,55 @@ export function showError(msg) {
 
 export function createSpinner(text) {
   return ora({ text, color: 'cyan' });
+}
+
+/**
+ * Display a single character card in the CLI.
+ * @param {object} character — character profile with name, emoji, tagline, origin, age, asciiArt
+ * @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 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');
+
+  console.log(
+    boxen(content, {
+      padding: 1,
+      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
+ */
+export function showCharacterGallery(characters, activeId = null) {
+  console.log('');
+  console.log(
+    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('');
+
+  for (const c of characters) {
+    showCharacterCard(c, c.id === activeId);
+  }
 }

package/src/utils/temporal-awareness.js

@@ -117,17 +117,30 @@ function determineStatus(hour, dayOfWeek, workingHours) {
 }
 
 /**
- * Determine the likely activity period for more nuanced awareness.
+ * Activity period definitions with behavioral tone hints.
+ * Each period carries a label and a short guidance string that gets
+ * injected into the system prompt so the LLM adapts its personality
+ * to the owner's real-time situation.
+ */
+const ACTIVITY_PERIODS = [
+  { start: 0,  end: 5,  label: 'late_night',    tone: 'Keep it calm and gentle — they may be winding down or unable to sleep. Avoid high-energy openers.' },
+  { start: 5,  end: 7,  label: 'early_morning',  tone: 'They are just waking up. Be warm but concise — ease them into the day without overwhelming detail.' },
+  { start: 7,  end: 12, label: 'morning',        tone: 'Good energy window. Match an upbeat, productive tone — they are likely starting their day.' },
+  { start: 12, end: 14, label: 'midday',         tone: 'Lunch break energy — keep things light and conversational unless they initiate something serious.' },
+  { start: 14, end: 17, label: 'afternoon',      tone: 'Afternoon focus. Be direct and helpful — they may be deep in work.' },
+  { start: 17, end: 20, label: 'evening',        tone: 'Winding down from the day. Be relaxed and friendly — match a casual, end-of-day vibe.' },
+  { start: 20, end: 23, label: 'night',          tone: 'Late evening — be warm and unhurried. They are likely relaxing, so keep the mood easy-going.' },
+];
+
+/**
+ * Determine the likely activity period and its behavioral tone hint.
+ * Returns { label, tone } for richer LLM context.
  */
 function determineActivityPeriod(hour) {
-  if (hour >= 0 && hour < 5) return 'late_night';
-  if (hour >= 5 && hour < 7) return 'early_morning';
-  if (hour >= 7 && hour < 12) return 'morning';
-  if (hour >= 12 && hour < 14) return 'midday';
-  if (hour >= 14 && hour < 17) return 'afternoon';
-  if (hour >= 17 && hour < 20) return 'evening';
-  if (hour >= 20 && hour < 23) return 'night';
-  return 'late_night';
+  const period = ACTIVITY_PERIODS.find(p => hour >= p.start && hour < p.end);
+  if (period) return { label: period.label, tone: period.tone };
+  // hour 23 falls outside all ranges — treat as late_night
+  return { label: 'late_night', tone: ACTIVITY_PERIODS[0].tone };
 }
 
 /**
@@ -163,7 +176,7 @@ export function buildTemporalAwareness() {
   const currentHour = getCurrentHour(now, timezone);
   const currentDay = getCurrentDayOfWeek(now, timezone);
   const { status, detail } = determineStatus(currentHour, currentDay, owner.working_hours);
-  const period = determineActivityPeriod(currentHour);
+  const { label: period, tone: periodTone } = determineActivityPeriod(currentHour);
 
   const lines = [
     `## Owner's Real-Time Context`,
@@ -190,6 +203,7 @@ export function buildTemporalAwareness() {
   lines.push('IMPORTANT: Be aware of the owner\'s current local time and status.');
   lines.push('Do NOT assume they are at work during off-hours, or sleeping during work hours.');
   lines.push('Adjust greetings, tone, and context to match their real-time situation.');
+  lines.push(`Tone hint: ${periodTone}`);
 
   const block = lines.join('\n');