flowmind 1.4.8 → 1.5.0

package/core/sdd-agent-sync.js

@@ -0,0 +1,467 @@
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+
+const MCP_SERVER_ALIASES = Object.freeze({
+  'aomi-yapi-mcp': 'yapi-mcp',
+  'aomi-yuque-mcp': 'yuque-mcp'
+});
+
+const RESOURCE_BINDING_SPECS = Object.freeze({
+  yapi: { componentType: 'apiDoc', provider: 'yapi' },
+  yuque: { componentType: 'knowledgeBase', provider: 'yuque' },
+  database: { componentType: 'databaseQuery', provider: 'aliyun-rds-query' },
+  redis: { componentType: 'redisMonitor', provider: 'aliyun-redis' },
+  sls: { componentType: 'logService', provider: 'aliyun-sls' },
+  workflow: { componentType: 'workflow', provider: 'friday-flow' },
+  report: { componentType: 'report', provider: 'friday-report' }
+});
+
+function getHomeDir() {
+  return process.env.FLOWMIND_HOME || process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+
+function normalizeMcpServer(name) {
+  if (!name) return null;
+  return MCP_SERVER_ALIASES[name] || name;
+}
+
+function deepMerge(target, source) {
+  if (!isObject(target) || !isObject(source)) {
+    return source;
+  }
+
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (isObject(value) && isObject(result[key])) {
+      result[key] = deepMerge(result[key], value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function sanitizeResourceConfig(sddConfig) {
+  return {
+    version: sddConfig.version || '1.0',
+    lastUpdated: new Date().toISOString(),
+    resources: sddConfig.resources || {},
+    mcpServers: sddConfig.mcpServers || {},
+    aliases: sddConfig.aliases || {},
+    metadata: {
+      source: 'sdd-agent',
+      syncedAt: new Date().toISOString()
+    }
+  };
+}
+
+function buildAliasIndex(aliasConfig = {}) {
+  const index = {};
+  for (const [alias, mapping] of Object.entries(aliasConfig)) {
+    if (!isObject(mapping)) continue;
+    for (const [resourceType, bindingKey] of Object.entries(mapping)) {
+      if (!bindingKey) continue;
+      const composite = `${resourceType}:${bindingKey}`;
+      index[composite] = index[composite] || [];
+      index[composite].push(alias);
+    }
+  }
+  return index;
+}
+
+function inferBindingMcpServer(resourceType, resourceConfig = {}) {
+  if (resourceConfig.mcpServer) {
+    return normalizeMcpServer(resourceConfig.mcpServer);
+  }
+  if (isObject(resourceConfig.mcpServers)) {
+    let preferred = null;
+    if (resourceType === 'database') {
+      preferred = resourceConfig.mcpServers.directQuery || resourceConfig.mcpServers.dms;
+    } else if (resourceType === 'redis') {
+      preferred = resourceConfig.mcpServers.monitor || resourceConfig.mcpServers.directQuery;
+    } else {
+      preferred = resourceConfig.mcpServers.directQuery
+        || resourceConfig.mcpServers.monitor
+        || resourceConfig.mcpServers.dms;
+    }
+    return normalizeMcpServer(preferred);
+  }
+  return null;
+}
+
+function buildResourceBinding(resourceType, bindingKey, bindingValue, resourceConfig, aliasIndex) {
+  const spec = RESOURCE_BINDING_SPECS[resourceType];
+  if (!spec) return null;
+
+  const bindingAliases = aliasIndex[`${resourceType}:${bindingKey}`] || [];
+  const business = bindingAliases[0] || bindingValue.name || bindingKey;
+  const aliases = [
+    bindingKey,
+    bindingValue.name,
+    bindingValue.database,
+    bindingValue.namespace,
+    bindingValue.projectId,
+    bindingValue.envType,
+    bindingValue.env,
+    ...bindingAliases
+  ].filter(Boolean);
+
+  const env = bindingValue.envType || bindingValue.env || null;
+
+  return {
+    id: `sdd-${resourceType}-${bindingKey}`,
+    timestamp: new Date().toISOString(),
+    business,
+    aliases: [...new Set(aliases)],
+    componentType: spec.componentType,
+    provider: spec.provider,
+    mcpServer: inferBindingMcpServer(resourceType, resourceConfig),
+    source: 'sdd-agent-sync',
+    keywords: [...new Set([business, bindingKey, resourceType, env, ...aliases].filter(Boolean))],
+    connection: {
+      ...bindingValue,
+      env
+    },
+    metadata: {
+      source: 'sdd-agent',
+      resourceType,
+      bindingKey
+    },
+    stats: {
+      useCount: 0,
+      lastUsed: null
+    }
+  };
+}
+
+function buildLogBindings(resourceConfig = {}) {
+  const spec = RESOURCE_BINDING_SPECS.sls;
+  const envConfig = resourceConfig.envConfig || {};
+  return Object.entries(envConfig).map(([env, value]) => ({
+    id: `sdd-sls-${env}`,
+    timestamp: new Date().toISOString(),
+    business: `日志-${env}`,
+    aliases: [env, value.name, `${env}-日志`, `${env}-sls`].filter(Boolean),
+    componentType: spec.componentType,
+    provider: spec.provider,
+    mcpServer: normalizeMcpServer(resourceConfig.mcpServer),
+    source: 'sdd-agent-sync',
+    keywords: ['日志', 'log', 'trace', 'sls', env, value.logstore, value.project].filter(Boolean),
+    connection: {
+      env,
+      project: value.project,
+      endpoint: value.endpoint,
+      logstore: value.logstore,
+      ...value
+    },
+    metadata: {
+      source: 'sdd-agent',
+      resourceType: 'sls',
+      env
+    },
+    stats: {
+      useCount: 0,
+      lastUsed: null
+    }
+  }));
+}
+
+function convertResourceBindings(sddConfig) {
+  const resources = sddConfig.resources || {};
+  const aliasIndex = buildAliasIndex(sddConfig.aliases);
+  const bindings = [];
+
+  for (const [resourceType, resourceConfig] of Object.entries(resources)) {
+    if (resourceType === 'sls') {
+      bindings.push(...buildLogBindings(resourceConfig));
+      continue;
+    }
+
+    const bindingMap = resourceConfig.bindings || {};
+    for (const [bindingKey, bindingValue] of Object.entries(bindingMap)) {
+      const converted = buildResourceBinding(resourceType, bindingKey, bindingValue, resourceConfig, aliasIndex);
+      if (converted) bindings.push(converted);
+    }
+  }
+
+  return bindings;
+}
+
+function convertSceneMappings(sceneData = {}) {
+  const mappings = sceneData.mappings || [];
+  return mappings.map((mapping) => ({
+    id: `sdd-${mapping.id || mapping.sceneName || Date.now()}`,
+    name: mapping.sceneName || mapping.name || 'Imported Scene',
+    keywords: mapping.keywords || [],
+    patterns: mapping.patterns || [],
+    workflow: {
+      skills: (mapping.skillSequence || []).map((step) => ({
+        skill: step.skill,
+        params: {
+          action: step.action,
+          ...(step.params || {})
+        }
+      }))
+    },
+    preferences: mapping.userPreference || {},
+    stats: {
+      useCount: mapping.useCount || 0,
+      lastUsed: mapping.lastUsed || null,
+      successRate: typeof mapping.confidence === 'number' ? mapping.confidence : 1.0
+    },
+    metadata: {
+      source: 'sdd-agent',
+      originalId: mapping.id,
+      categoryHints: Object.keys(sceneData.sceneCategories || {}).filter((key) => (sceneData.sceneCategories[key] || []).includes(mapping.id)),
+      workflow: mapping.workflow || {}
+    }
+  }));
+}
+
+function buildComponentConfig(sddConfig) {
+  const resources = sddConfig.resources || {};
+  const components = {};
+
+  if (resources.sls?.enabled) {
+    const defaultEnv = resources.sls.defaultEnv || 'uat';
+    const envConfig = resources.sls.envConfig || {};
+    components.logService = {
+      default: 'aliyun-sls',
+      providers: {
+        'aliyun-sls': {
+          enabled: true,
+          mcpServer: normalizeMcpServer(resources.sls.mcpServer),
+          config: {
+            endpoints: {
+              test: envConfig.test?.endpoint || envConfig.uat?.endpoint,
+              prod: envConfig.prod?.endpoint || envConfig.gray?.endpoint
+            },
+            defaultProject: envConfig[defaultEnv]?.project,
+            defaultLogstore: envConfig[defaultEnv]?.logstore
+          }
+        }
+      }
+    };
+  }
+
+  if (resources.database?.enabled && resources.database.mcpServers?.dms) {
+    components.databaseManager = {
+      default: 'aliyun-dms',
+      providers: {
+        'aliyun-dms': {
+          enabled: true,
+          mcpServer: normalizeMcpServer(resources.database.mcpServers.dms)
+        }
+      }
+    };
+  }
+
+  if (resources.redis?.enabled && resources.redis.mcpServers?.monitor) {
+    components.redisMonitor = {
+      default: 'aliyun-redis',
+      providers: {
+        'aliyun-redis': {
+          enabled: true,
+          mcpServer: normalizeMcpServer(resources.redis.mcpServers.monitor)
+        }
+      }
+    };
+  }
+
+  if (resources.yapi?.enabled && resources.yapi.mcpServer) {
+    components.apiDoc = {
+      default: 'yapi',
+      providers: {
+        yapi: {
+          enabled: true,
+          mcpServer: normalizeMcpServer(resources.yapi.mcpServer)
+        }
+      }
+    };
+  }
+
+  if (resources.yuque?.enabled && resources.yuque.mcpServer) {
+    components.knowledgeBase = {
+      default: 'yuque',
+      providers: {
+        yuque: {
+          enabled: true,
+          mcpServer: normalizeMcpServer(resources.yuque.mcpServer)
+        }
+      }
+    };
+  }
+
+  if (resources.workflow?.enabled && resources.workflow.mcpServer) {
+    components.workflow = {
+      default: 'friday-flow',
+      providers: {
+        'friday-flow': {
+          enabled: true,
+          mcpServer: normalizeMcpServer(resources.workflow.mcpServer)
+        }
+      }
+    };
+  }
+
+  if (resources.report?.enabled && resources.report.mcpServer) {
+    components.report = {
+      default: 'friday-report',
+      providers: {
+        'friday-report': {
+          enabled: true,
+          mcpServer: normalizeMcpServer(resources.report.mcpServer)
+        }
+      }
+    };
+  }
+
+  return {
+    version: '1.0.0',
+    components
+  };
+}
+
+function mergeBindings(existingBindings = [], incomingBindings = []) {
+  const merged = [...existingBindings];
+  for (const binding of incomingBindings) {
+    const index = merged.findIndex((item) => item.id === binding.id
+      || (item.business === binding.business
+        && item.componentType === binding.componentType
+        && item.provider === binding.provider));
+    if (index >= 0) {
+      merged[index] = {
+        ...merged[index],
+        ...binding,
+        aliases: [...new Set([...(merged[index].aliases || []), ...(binding.aliases || [])])],
+        keywords: [...new Set([...(merged[index].keywords || []), ...(binding.keywords || [])])],
+        connection: {
+          ...(merged[index].connection || {}),
+          ...(binding.connection || {})
+        },
+        metadata: {
+          ...(merged[index].metadata || {}),
+          ...(binding.metadata || {})
+        }
+      };
+    } else {
+      merged.push(binding);
+    }
+  }
+  return merged;
+}
+
+function mergeScenes(existingScenes = [], incomingScenes = []) {
+  const merged = [...existingScenes];
+  for (const scene of incomingScenes) {
+    const index = merged.findIndex((item) => item.id === scene.id || item.name === scene.name);
+    if (index >= 0) {
+      merged[index] = {
+        ...merged[index],
+        ...scene,
+        keywords: [...new Set([...(merged[index].keywords || []), ...(scene.keywords || [])])],
+        patterns: [...new Set([...(merged[index].patterns || []), ...(scene.patterns || [])])],
+        workflow: scene.workflow || merged[index].workflow,
+        preferences: {
+          ...(merged[index].preferences || {}),
+          ...(scene.preferences || {})
+        },
+        metadata: {
+          ...(merged[index].metadata || {}),
+          ...(scene.metadata || {})
+        }
+      };
+    } else {
+      merged.push(scene);
+    }
+  }
+  return merged;
+}
+
+async function readJsonIfExists(filePath, fallback) {
+  if (!(await fs.pathExists(filePath))) return fallback;
+  return fs.readJson(filePath);
+}
+
+async function syncSddAgentToFlowMind(options = {}) {
+  const sourceDir = options.sourceDir || path.join(os.homedir(), '.sdd-agent');
+  const targetHome = options.targetHome || getHomeDir();
+  const sourceConfigPath = path.join(sourceDir, 'resource-config.json');
+  const sourceScenesPath = path.join(sourceDir, 'learning', 'scene-mappings.json');
+  const targetDir = path.join(targetHome, '.flowmind');
+  const targetLearningDir = path.join(targetDir, 'learning');
+
+  if (!(await fs.pathExists(sourceConfigPath))) {
+    throw new Error(`SDD-Agent resource config not found: ${sourceConfigPath}`);
+  }
+
+  const sddConfig = await fs.readJson(sourceConfigPath);
+  const sddScenes = await readJsonIfExists(sourceScenesPath, { mappings: [] });
+
+  const targetResourceConfigPath = path.join(targetDir, 'resource-config.json');
+  const targetComponentConfigPath = path.join(targetDir, 'component-config.json');
+  const targetBindingsPath = path.join(targetLearningDir, 'resource-bindings.json');
+  const targetScenesPath = path.join(targetLearningDir, 'scenes.json');
+
+  const existingResourceConfig = await readJsonIfExists(targetResourceConfigPath, {});
+  const existingComponentConfig = await readJsonIfExists(targetComponentConfigPath, { version: '1.0.0', components: {} });
+  const existingBindings = await readJsonIfExists(targetBindingsPath, { version: '1.0', bindings: [] });
+  const existingScenes = await readJsonIfExists(targetScenesPath, { version: '1.0', mappings: [] });
+
+  const nextResourceConfig = deepMerge(existingResourceConfig, sanitizeResourceConfig(sddConfig));
+  const nextComponentConfig = deepMerge(existingComponentConfig, buildComponentConfig(sddConfig));
+  const importedBindings = convertResourceBindings(sddConfig);
+  const nextBindings = {
+    version: existingBindings.version || '1.0',
+    lastUpdated: new Date().toISOString(),
+    bindings: mergeBindings(existingBindings.bindings || [], importedBindings)
+  };
+  const importedScenes = convertSceneMappings(sddScenes);
+  const nextScenes = {
+    version: existingScenes.version || '1.0',
+    lastUpdated: new Date().toISOString(),
+    mappings: mergeScenes(existingScenes.mappings || [], importedScenes)
+  };
+
+  await fs.ensureDir(targetLearningDir);
+  await fs.writeJson(targetResourceConfigPath, nextResourceConfig, { spaces: 2 });
+  await fs.writeJson(targetComponentConfigPath, nextComponentConfig, { spaces: 2 });
+  await fs.writeJson(targetBindingsPath, nextBindings, { spaces: 2 });
+  await fs.writeJson(targetScenesPath, nextScenes, { spaces: 2 });
+
+  return {
+    sourceDir,
+    targetDir,
+    files: {
+      resourceConfig: targetResourceConfigPath,
+      componentConfig: targetComponentConfigPath,
+      resourceBindings: targetBindingsPath,
+      scenes: targetScenesPath
+    },
+    counts: {
+      importedBindings: importedBindings.length,
+      totalBindings: nextBindings.bindings.length,
+      importedScenes: importedScenes.length,
+      totalScenes: nextScenes.mappings.length,
+      components: Object.keys(nextComponentConfig.components || {}).length
+    }
+  };
+}
+
+module.exports = {
+  buildAliasIndex,
+  buildComponentConfig,
+  convertResourceBindings,
+  convertSceneMappings,
+  deepMerge,
+  mergeBindings,
+  mergeScenes,
+  normalizeMcpServer,
+  sanitizeResourceConfig,
+  syncSddAgentToFlowMind
+};

package/core/skill-loader.js

@@ -255,14 +255,19 @@ class SkillLoader {
     for (const [name, skill] of this.skills) {
       try {
         const canHandle = await skill.canHandle(input, context);
-        if (canHandle) {
+        const fallbackMatch = this.matchDefinitionSignals(skill, input);
+
+        if (canHandle || fallbackMatch.matched) {
           candidates.push({
             name: skill.name,
             skill: skill,
             description: skill.definition?.description || '',
             triggers: skill.definition?.triggers || [],
             category: skill.definition?.category || skill.definition?.metadata?.category || '',
-            score: this.calculateSkillScore(skill, input, context)
+            score: this.calculateSkillScore(skill, input, context, {
+              canHandle,
+              ...fallbackMatch
+            })
           });
         }
       } catch (error) {
@@ -276,19 +281,16 @@ class SkillLoader {
   /**
    * Calculate skill score for selection
    */
-  calculateSkillScore(skill, input, context) {
+  calculateSkillScore(skill, input, context, matchInfo = {}) {
     let score = 0;
 
     // Base score for matching
-    score += 10;
+    score += matchInfo.canHandle ? 10 : 4;
 
     // Bonus for trigger specificity
-    const triggers = skill.definition?.triggers || [];
-    for (const trigger of triggers) {
-      if (input.toLowerCase().includes(trigger.toLowerCase())) {
-        score += 5;
-      }
-    }
+    score += (matchInfo.triggerHits?.length || 0) * 5;
+    score += (matchInfo.nameHits?.length || 0) * 4;
+    score += matchInfo.categoryHit ? 2 : 0;
 
     // Bonus for recent successful use
     const bindings = this.learning?.skillBindings?.bindings?.[skill.name];
@@ -299,6 +301,45 @@ class SkillLoader {
     return score;
   }
 
+  matchDefinitionSignals(skill, input) {
+    if (!input) {
+      return {
+        matched: false,
+        triggerHits: [],
+        nameHits: [],
+        categoryHit: false
+      };
+    }
+
+    const inputLower = input.toLowerCase();
+    const triggers = skill.definition?.triggers || [];
+    const triggerHits = triggers.filter((trigger) => inputLower.includes(String(trigger).toLowerCase()));
+
+    const nameVariants = this.getSkillNameVariants(skill.name);
+    const nameHits = nameVariants.filter((variant) => inputLower.includes(variant));
+
+    const category = skill.definition?.category || skill.definition?.metadata?.category || '';
+    const categoryHit = category ? inputLower.includes(String(category).toLowerCase()) : false;
+
+    return {
+      matched: triggerHits.length > 0 || nameHits.length > 0 || categoryHit,
+      triggerHits,
+      nameHits,
+      categoryHit
+    };
+  }
+
+  getSkillNameVariants(name = '') {
+    const normalized = String(name).toLowerCase();
+    return [...new Set([
+      normalized,
+      normalized.replace(/-/g, ' '),
+      normalized.replace(/-/g, ''),
+      normalized.replace(/_/g, ' '),
+      normalized.replace(/_/g, '')
+    ])].filter(Boolean);
+  }
+
   /**
    * Get skill by name
    */

package/core/utils.js

@@ -15,4 +15,58 @@ function expandPath(filePath) {
   return filePath;
 }
 
-module.exports = { expandPath };
+function detectManagedCliHost(env = process.env) {
+  if (env.FLOWMIND_ALLOW_NESTED_TUI === '1') {
+    return null;
+  }
+
+  if (env.CODEX_THREAD_ID || env.CODEX_MANAGED_PACKAGE_ROOT || env.OPENAI_CODEX === '1') {
+    return {
+      id: 'codex',
+      name: 'Codex CLI'
+    };
+  }
+
+  if (env.CLAUDECODE === '1' || env.CLAUDE_CODE === '1' || env.CLAUDECODE_ENTRYPOINT) {
+    return {
+      id: 'claude-code',
+      name: 'Claude Code'
+    };
+  }
+
+  return null;
+}
+
+function shouldUseAsciiUi(env = process.env) {
+  if (env.FLOWMIND_FORCE_UNICODE_UI === '1') {
+    return false;
+  }
+
+  if (env.FLOWMIND_ASCII_UI === '1') {
+    return true;
+  }
+
+  return env.TERM_PROGRAM === 'Apple_Terminal';
+}
+
+function shouldProxyInkStdin(stdin = process.stdin) {
+  return !stdin || stdin.isTTY !== true || typeof stdin.setRawMode !== 'function';
+}
+
+function getNestedTuiGuardMessage(host) {
+  const hostName = host?.name || 'this host CLI';
+  return [
+    `${hostName} already controls raw stdin and the fullscreen terminal surface.`,
+    'Launching FlowMind TUI/Dashboard inside it can terminate the outer session as soon as input is captured.',
+    'Use `flowmind-codex` for JSON-based integration, or run `flowmind tui` in a standalone terminal.',
+    'Set `FLOWMIND_ALLOW_NESTED_TUI=1` only if you explicitly want to bypass this safeguard.'
+  ].join(' ');
+}
+
+module.exports = {
+  expandPath,
+  detectManagedCliHost,
+  shouldUseAsciiUi,
+  shouldProxyInkStdin,
+  getNestedTuiGuardMessage
+};

package/dashboard/app.jsx

@@ -5,7 +5,7 @@ const StatsRow = require('./components/StatsRow.jsx');
 const DragonPanel = require('./components/DragonPanel.jsx');
 const McpStatusBar = require('./components/McpStatusBar.jsx');
 
-function DashboardApp({ flowmind, eventBus }) {
+function DashboardApp({ flowmind, eventBus, asciiMode = false }) {
   const { exit } = useApp();
 
   useInput((input, key) => {
@@ -15,13 +15,13 @@ function DashboardApp({ flowmind, eventBus }) {
   return (
     React.createElement(Box, { flexDirection: 'column', width: '100%', height: '100%' },
       React.createElement(Box, { flexDirection: 'row', flexGrow: 1 },
-        React.createElement(ActivityFeed, { eventBus: eventBus }),
+        React.createElement(ActivityFeed, { eventBus: eventBus, asciiMode: asciiMode }),
         React.createElement(Box, { flexDirection: 'column', width: '60%', flexGrow: 1 },
-          React.createElement(StatsRow, { flowmind: flowmind }),
-          React.createElement(DragonPanel, { flowmind: flowmind })
+          React.createElement(StatsRow, { flowmind: flowmind, asciiMode: asciiMode }),
+          React.createElement(DragonPanel, { flowmind: flowmind, asciiMode: asciiMode })
         )
       ),
-      React.createElement(McpStatusBar, { eventBus: eventBus })
+      React.createElement(McpStatusBar, { eventBus: eventBus, asciiMode: asciiMode })
     )
   );
 }

package/dashboard/components/ActivityFeed.jsx

@@ -1,5 +1,6 @@
 const React = require('react');
 const { Box, Text } = require('ink');
+const { getBorderStyle, getCheckMark } = require('../../tui/ui');
 
 const EVENT_COLORS = {
   'skill:executed': 'green',
@@ -16,16 +17,16 @@ function formatTime(timestamp) {
   return new Date(timestamp).toTimeString().substring(0, 8);
 }
 
-function formatEvent(event) {
+function formatEvent(event, asciiMode) {
   switch (event.type) {
     case 'skill:executed':
-      return 'skill:' + (event.data?.name || '?') + ' ' + (event.data?.success ? '\u2713' : '\u2717');
+      return 'skill:' + (event.data?.name || '?') + ' ' + getCheckMark(event.data?.success, asciiMode);
     case 'honor:awarded':
       return 'honor +' + (event.data?.points || 0) + ' (' + (event.data?.description || '') + ')';
     case 'learning:recorded':
       return 'learning:' + (event.data?.type || '?') + ' ' + (event.data?.skill || '');
     case 'mcp:tool_called':
-      return 'MCP:' + (event.data?.tool || '?') + ' ' + (event.data?.success ? '\u2713' : '\u2717') + ' ' + (event.data?.duration || 0) + 'ms';
+      return 'MCP:' + (event.data?.tool || '?') + ' ' + getCheckMark(event.data?.success, asciiMode) + ' ' + (event.data?.duration || 0) + 'ms';
     case 'process:start':
       return 'process: ' + (event.data?.input?.substring(0, 30) || '?') + '...';
     case 'process:complete':
@@ -37,7 +38,7 @@ function formatEvent(event) {
   }
 }
 
-function ActivityFeed({ eventBus }) {
+function ActivityFeed({ eventBus, asciiMode = false }) {
   const [events, setEvents] = React.useState([]);
 
   React.useEffect(() => {
@@ -68,14 +69,14 @@ function ActivityFeed({ eventBus }) {
   const displayEvents = events.slice(-30);
 
   return (
-    React.createElement(Box, { flexDirection: 'column', borderStyle: 'single', borderColor: 'green', paddingX: 1, width: '40%' },
+    React.createElement(Box, { flexDirection: 'column', borderStyle: getBorderStyle(asciiMode), borderColor: 'green', paddingX: 1, width: '40%' },
       React.createElement(Text, { bold: true, color: 'green' }, 'Activity Feed'),
       React.createElement(Box, { flexDirection: 'column', marginTop: 1, overflow: 'hidden' },
         displayEvents.length === 0 && React.createElement(Text, { color: 'gray' }, 'Waiting for events...'),
         displayEvents.map((event, i) =>
           React.createElement(Text, { key: i },
             React.createElement(Text, { color: 'gray' }, formatTime(event.timestamp) + ' '),
-            React.createElement(Text, { color: EVENT_COLORS[event.type] || 'white' }, formatEvent(event))
+            React.createElement(Text, { color: EVENT_COLORS[event.type] || 'white' }, formatEvent(event, asciiMode))
           )
         )
       )