@geminilight/mindos 0.3.0 → 0.4.0

package/app/app/api/mcp/agents/route.ts

@@ -0,0 +1,72 @@
+export const dynamic = 'force-dynamic';
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+function expandHome(p: string): string {
+  return p.startsWith('~/') ? path.resolve(os.homedir(), p.slice(2)) : p;
+}
+
+interface AgentDef {
+  name: string;
+  project: string | null;
+  global: string;
+  key: string;
+}
+
+const MCP_AGENTS: Record<string, AgentDef> = {
+  'claude-code':    { name: 'Claude Code',    project: '.mcp.json',                       global: '~/.claude.json',    key: 'mcpServers' },
+  'claude-desktop': { name: 'Claude Desktop', project: null,                               global: process.platform === 'darwin' ? '~/Library/Application Support/Claude/claude_desktop_config.json' : '~/.config/Claude/claude_desktop_config.json', key: 'mcpServers' },
+  'cursor':         { name: 'Cursor',          project: '.cursor/mcp.json',                global: '~/.cursor/mcp.json', key: 'mcpServers' },
+  'windsurf':       { name: 'Windsurf',        project: null,                               global: '~/.codeium/windsurf/mcp_config.json', key: 'mcpServers' },
+  'cline':          { name: 'Cline',           project: null,                               global: process.platform === 'darwin' ? '~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json' : '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json', key: 'mcpServers' },
+  'trae':           { name: 'Trae',            project: '.trae/mcp.json',                  global: '~/.trae/mcp.json', key: 'mcpServers' },
+  'gemini-cli':     { name: 'Gemini CLI',      project: '.gemini/settings.json',           global: '~/.gemini/settings.json', key: 'mcpServers' },
+  'openclaw':       { name: 'OpenClaw',        project: null,                               global: '~/.openclaw/mcp.json', key: 'mcpServers' },
+  'codebuddy':      { name: 'CodeBuddy',       project: null,                               global: '~/.claude-internal/.claude.json', key: 'mcpServers' },
+};
+
+function detectInstalled(agentKey: string): { installed: boolean; scope?: string; transport?: string; configPath?: string } {
+  const agent = MCP_AGENTS[agentKey];
+  if (!agent) return { installed: false };
+
+  // Check global first, then project
+  for (const [scope, cfgPath] of [['global', agent.global], ['project', agent.project]] as const) {
+    if (!cfgPath) continue;
+    const absPath = expandHome(cfgPath);
+    if (!fs.existsSync(absPath)) continue;
+    try {
+      const config = JSON.parse(fs.readFileSync(absPath, 'utf-8'));
+      const servers = config[agent.key];
+      if (servers?.mindos) {
+        const entry = servers.mindos;
+        const transport = entry.type === 'stdio' ? 'stdio' : entry.url ? 'http' : 'unknown';
+        return { installed: true, scope, transport, configPath: cfgPath };
+      }
+    } catch { /* ignore parse errors */ }
+  }
+
+  return { installed: false };
+}
+
+export async function GET() {
+  try {
+    const agents = Object.entries(MCP_AGENTS).map(([key, agent]) => {
+      const status = detectInstalled(key);
+      return {
+        key,
+        name: agent.name,
+        installed: status.installed,
+        scope: status.scope,
+        transport: status.transport,
+        configPath: status.configPath,
+        hasProjectScope: !!agent.project,
+        hasGlobalScope: !!agent.global,
+      };
+    });
+    return NextResponse.json({ agents });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/mcp/install/route.ts

@@ -0,0 +1,95 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+function expandHome(p: string): string {
+  return p.startsWith('~/') ? path.resolve(os.homedir(), p.slice(2)) : p;
+}
+
+interface AgentDef {
+  name: string;
+  project: string | null;
+  global: string;
+  key: string;
+}
+
+const MCP_AGENTS: Record<string, AgentDef> = {
+  'claude-code':    { name: 'Claude Code',    project: '.mcp.json',                       global: '~/.claude.json',    key: 'mcpServers' },
+  'claude-desktop': { name: 'Claude Desktop', project: null,                               global: process.platform === 'darwin' ? '~/Library/Application Support/Claude/claude_desktop_config.json' : '~/.config/Claude/claude_desktop_config.json', key: 'mcpServers' },
+  'cursor':         { name: 'Cursor',          project: '.cursor/mcp.json',                global: '~/.cursor/mcp.json', key: 'mcpServers' },
+  'windsurf':       { name: 'Windsurf',        project: null,                               global: '~/.codeium/windsurf/mcp_config.json', key: 'mcpServers' },
+  'cline':          { name: 'Cline',           project: null,                               global: process.platform === 'darwin' ? '~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json' : '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json', key: 'mcpServers' },
+  'trae':           { name: 'Trae',            project: '.trae/mcp.json',                  global: '~/.trae/mcp.json', key: 'mcpServers' },
+  'gemini-cli':     { name: 'Gemini CLI',      project: '.gemini/settings.json',           global: '~/.gemini/settings.json', key: 'mcpServers' },
+  'openclaw':       { name: 'OpenClaw',        project: null,                               global: '~/.openclaw/mcp.json', key: 'mcpServers' },
+  'codebuddy':      { name: 'CodeBuddy',       project: null,                               global: '~/.claude-internal/.claude.json', key: 'mcpServers' },
+};
+
+interface InstallRequest {
+  agents: Array<{ key: string; scope: 'project' | 'global' }>;
+  transport: 'stdio' | 'http';
+  url?: string;
+  token?: string;
+}
+
+function buildEntry(transport: string, url?: string, token?: string) {
+  if (transport === 'stdio') {
+    return { type: 'stdio', command: 'mindos', args: ['mcp'], env: { MCP_TRANSPORT: 'stdio' } };
+  }
+  const entry: Record<string, unknown> = { url: url || 'http://localhost:8787/mcp' };
+  if (token) entry.headers = { Authorization: `Bearer ${token}` };
+  return entry;
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = (await req.json()) as InstallRequest;
+    const { agents, transport, url, token } = body;
+    const entry = buildEntry(transport, url, token);
+    const results: Array<{ agent: string; status: string; path?: string; message?: string }> = [];
+
+    for (const { key, scope } of agents) {
+      const agent = MCP_AGENTS[key];
+      if (!agent) {
+        results.push({ agent: key, status: 'error', message: `Unknown agent: ${key}` });
+        continue;
+      }
+
+      const isGlobal = scope === 'global';
+      const configPath = isGlobal ? agent.global : agent.project;
+      if (!configPath) {
+        results.push({ agent: key, status: 'error', message: `${agent.name} does not support ${scope} scope` });
+        continue;
+      }
+
+      const absPath = expandHome(configPath);
+
+      try {
+        // Read existing config
+        let config: Record<string, unknown> = {};
+        if (fs.existsSync(absPath)) {
+          config = JSON.parse(fs.readFileSync(absPath, 'utf-8'));
+        }
+
+        // Merge — only touch mcpServers.mindos
+        if (!config[agent.key]) config[agent.key] = {};
+        (config[agent.key] as Record<string, unknown>).mindos = entry;
+
+        // Write
+        const dir = path.dirname(absPath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+        results.push({ agent: key, status: 'ok', path: configPath });
+      } catch (err) {
+        results.push({ agent: key, status: 'error', message: String(err) });
+      }
+    }
+
+    return NextResponse.json({ results });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/mcp/status/route.ts

@@ -0,0 +1,47 @@
+export const dynamic = 'force-dynamic';
+import { NextResponse } from 'next/server';
+import { readSettings } from '@/lib/settings';
+
+export async function GET() {
+  try {
+    const settings = readSettings();
+    const port = settings.mcpPort ?? 8787;
+    const endpoint = `http://127.0.0.1:${port}/mcp`;
+    const authConfigured = !!settings.authToken;
+
+    // Check if MCP server is running
+    let running = false;
+    let toolCount = 0;
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 2000);
+      const res = await fetch(endpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }),
+        signal: controller.signal,
+      });
+      clearTimeout(timeout);
+      if (res.ok) {
+        running = true;
+        try {
+          const data = await res.json();
+          if (data?.result?.tools) toolCount = data.result.tools.length;
+        } catch { /* non-JSON response — still running */ }
+      }
+    } catch {
+      // Connection refused or timeout — not running
+    }
+
+    return NextResponse.json({
+      running,
+      transport: 'http',
+      endpoint,
+      port,
+      toolCount,
+      authConfigured,
+    });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/skills/route.ts

@@ -0,0 +1,208 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { readSettings, writeSettings } from '@/lib/settings';
+
+const PROJECT_ROOT = path.resolve(process.cwd(), '..');
+
+function getMindRoot(): string {
+  const s = readSettings();
+  return s.mindRoot || process.env.MIND_ROOT || path.join(os.homedir(), 'MindOS');
+}
+
+interface SkillInfo {
+  name: string;
+  description: string;
+  path: string;
+  source: 'builtin' | 'user';
+  enabled: boolean;
+  editable: boolean;
+}
+
+function parseSkillMd(content: string): { name: string; description: string } {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { name: '', description: '' };
+  const yaml = match[1];
+  const nameMatch = yaml.match(/^name:\s*(.+)/m);
+  const descMatch = yaml.match(/^description:\s*>?\s*\n?([\s\S]*?)(?=\n\w|\n---)/m);
+  const name = nameMatch ? nameMatch[1].trim() : '';
+  let description = '';
+  if (descMatch) {
+    description = descMatch[1].trim().split('\n').map(l => l.trim()).join(' ').slice(0, 200);
+  } else {
+    const simpleDesc = yaml.match(/^description:\s*(.+)/m);
+    if (simpleDesc) description = simpleDesc[1].trim().slice(0, 200);
+  }
+  return { name, description };
+}
+
+function scanSkillDirs(disabledSkills: string[]): SkillInfo[] {
+  const skills: SkillInfo[] = [];
+  const seen = new Set<string>();
+
+  // 1. app/data/skills/ — builtin
+  const builtinDir = path.join(PROJECT_ROOT, 'app', 'data', 'skills');
+  if (fs.existsSync(builtinDir)) {
+    for (const entry of fs.readdirSync(builtinDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(builtinDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) continue;
+      const content = fs.readFileSync(skillFile, 'utf-8');
+      const { name, description } = parseSkillMd(content);
+      const skillName = name || entry.name;
+      seen.add(skillName);
+      skills.push({
+        name: skillName,
+        description,
+        path: `app/data/skills/${entry.name}/SKILL.md`,
+        source: 'builtin',
+        enabled: !disabledSkills.includes(skillName),
+        editable: false,
+      });
+    }
+  }
+
+  // 2. skills/ — project root builtin
+  const skillsDir = path.join(PROJECT_ROOT, 'skills');
+  if (fs.existsSync(skillsDir)) {
+    for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(skillsDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) continue;
+      const content = fs.readFileSync(skillFile, 'utf-8');
+      const { name, description } = parseSkillMd(content);
+      const skillName = name || entry.name;
+      if (seen.has(skillName)) continue; // already listed from app/data/skills/
+      seen.add(skillName);
+      skills.push({
+        name: skillName,
+        description,
+        path: `skills/${entry.name}/SKILL.md`,
+        source: 'builtin',
+        enabled: !disabledSkills.includes(skillName),
+        editable: false,
+      });
+    }
+  }
+
+  // 3. {mindRoot}/.skills/ — user custom
+  const mindRoot = getMindRoot();
+  const userSkillsDir = path.join(mindRoot, '.skills');
+  if (fs.existsSync(userSkillsDir)) {
+    for (const entry of fs.readdirSync(userSkillsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(userSkillsDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) continue;
+      const content = fs.readFileSync(skillFile, 'utf-8');
+      const { name, description } = parseSkillMd(content);
+      const skillName = name || entry.name;
+      if (seen.has(skillName)) continue;
+      seen.add(skillName);
+      skills.push({
+        name: skillName,
+        description,
+        path: `{mindRoot}/.skills/${entry.name}/SKILL.md`,
+        source: 'user',
+        enabled: !disabledSkills.includes(skillName),
+        editable: true,
+      });
+    }
+  }
+
+  return skills;
+}
+
+export async function GET() {
+  try {
+    const settings = readSettings();
+    const disabledSkills = settings.disabledSkills ?? [];
+    const skills = scanSkillDirs(disabledSkills);
+    return NextResponse.json({ skills });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { action, name, description, content, enabled } = body as {
+      action: 'create' | 'update' | 'delete' | 'toggle';
+      name?: string;
+      description?: string;
+      content?: string;
+      enabled?: boolean;
+    };
+
+    const settings = readSettings();
+    const mindRoot = getMindRoot();
+    const userSkillsDir = path.join(mindRoot, '.skills');
+
+    // Validate skill name — prevent path traversal
+    if (name && !/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+      return NextResponse.json({ error: 'Invalid skill name. Use lowercase letters, numbers, and hyphens only.' }, { status: 400 });
+    }
+
+    switch (action) {
+      case 'toggle': {
+        if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+        const disabled = settings.disabledSkills ?? [];
+        if (enabled === false) {
+          if (!disabled.includes(name)) disabled.push(name);
+        } else {
+          const idx = disabled.indexOf(name);
+          if (idx >= 0) disabled.splice(idx, 1);
+        }
+        writeSettings({ ...settings, disabledSkills: disabled });
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'create': {
+        if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+        // Check for conflicts with builtin
+        const builtinDir = path.join(PROJECT_ROOT, 'app', 'data', 'skills', name);
+        const skillsRootDir = path.join(PROJECT_ROOT, 'skills', name);
+        if (fs.existsSync(builtinDir) || fs.existsSync(skillsRootDir)) {
+          return NextResponse.json({ error: 'A built-in skill with this name already exists' }, { status: 409 });
+        }
+        const skillDir = path.join(userSkillsDir, name);
+        if (fs.existsSync(skillDir)) {
+          return NextResponse.json({ error: 'A skill with this name already exists' }, { status: 409 });
+        }
+        fs.mkdirSync(skillDir, { recursive: true });
+        const frontmatter = `---\nname: ${name}\ndescription: ${description || name}\n---\n\n${content || ''}`;
+        fs.writeFileSync(path.join(skillDir, 'SKILL.md'), frontmatter, 'utf-8');
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'update': {
+        if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+        const skillDir = path.join(userSkillsDir, name);
+        if (!fs.existsSync(skillDir)) {
+          return NextResponse.json({ error: 'Skill not found' }, { status: 404 });
+        }
+        if (content !== undefined) {
+          fs.writeFileSync(path.join(skillDir, 'SKILL.md'), content, 'utf-8');
+        }
+        return NextResponse.json({ ok: true });
+      }
+
+      case 'delete': {
+        if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+        const skillDir = path.join(userSkillsDir, name);
+        if (!fs.existsSync(skillDir)) {
+          return NextResponse.json({ error: 'Skill not found' }, { status: 404 });
+        }
+        fs.rmSync(skillDir, { recursive: true, force: true });
+        return NextResponse.json({ ok: true });
+      }
+
+      default:
+        return NextResponse.json({ error: `Unknown action: ${action}` }, { status: 400 });
+    }
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/sync/route.ts

@@ -1,8 +1,8 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
-import { execSync } from 'child_process';
+import { execSync, execFile } from 'child_process';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { homedir } from 'os';
 
 const MINDOS_DIR = join(homedir(), '.mindos');
@@ -68,7 +68,7 @@ export async function GET() {
 
 export async function POST(req: NextRequest) {
   try {
-    const body = await req.json() as { action: string };
+    const body = await req.json() as { action: string; remote?: string; branch?: string; token?: string };
     const config = loadConfig();
     const mindRoot = config.mindRoot;
 
@@ -77,6 +77,57 @@ export async function POST(req: NextRequest) {
     }
 
     switch (body.action) {
+      case 'init': {
+        const remote = body.remote?.trim();
+        if (!remote) {
+          return NextResponse.json({ error: 'Remote URL is required' }, { status: 400 });
+        }
+
+        // Validate URL format
+        const isHTTPS = remote.startsWith('https://');
+        const isSSH = /^git@[\w.-]+:.+/.test(remote);
+        if (!isHTTPS && !isSSH) {
+          return NextResponse.json({ error: 'Invalid remote URL — must be HTTPS or SSH format' }, { status: 400 });
+        }
+
+        // Check if sync is already configured
+        if (config.sync?.enabled && isGitRepo(mindRoot) && getRemoteUrl(mindRoot)) {
+          return NextResponse.json({ error: 'Sync already configured' }, { status: 400 });
+        }
+
+        // Build the effective remote URL (inject token for HTTPS)
+        let effectiveRemote = remote;
+        if (isHTTPS && body.token) {
+          try {
+            const urlObj = new URL(remote);
+            urlObj.username = 'oauth2';
+            urlObj.password = body.token;
+            effectiveRemote = urlObj.toString();
+          } catch {
+            return NextResponse.json({ error: 'Invalid remote URL' }, { status: 400 });
+          }
+        }
+
+        const branch = body.branch?.trim() || 'main';
+
+        // Call CLI's sync init via execFile (avoids module resolution issues with Turbopack)
+        try {
+          const cliPath = resolve(process.cwd(), '..', 'bin', 'cli.js');
+          const args = ['sync', 'init', '--non-interactive', '--remote', effectiveRemote, '--branch', branch];
+
+          await new Promise<void>((res, rej) => {
+            execFile('node', [cliPath, ...args], { timeout: 30000 }, (err, stdout, stderr) => {
+              if (err) rej(new Error(stderr?.trim() || err.message));
+              else res();
+            });
+          });
+          return NextResponse.json({ success: true, message: 'Sync initialized' });
+        } catch (err: unknown) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          return NextResponse.json({ error: errMsg }, { status: 400 });
+        }
+      }
+
       case 'now': {
         if (!isGitRepo(mindRoot)) {
           return NextResponse.json({ error: 'Not a git repository' }, { status: 400 });

package/app/app/api/update-check/route.ts

@@ -0,0 +1,52 @@
+export const dynamic = 'force-dynamic';
+import { NextResponse } from 'next/server';
+import { gt } from 'semver';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+
+// Read version from package.json (not process.env.npm_package_version — unavailable in daemon mode)
+let current = '0.0.0';
+try {
+  const pkgPath = resolve(process.cwd(), '..', 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  current = pkg.version;
+} catch {}
+
+// npm registry sources: prefer China mirror, fallback to official
+const REGISTRIES = [
+  'https://registry.npmmirror.com/@geminilight/mindos/latest',
+  'https://registry.npmjs.org/@geminilight/mindos/latest',
+];
+
+export async function GET() {
+  let latest = current;
+
+  for (const url of REGISTRIES) {
+    try {
+      const res = await fetch(url, {
+        signal: AbortSignal.timeout(3000),
+        next: { revalidate: 300 }, // 5-minute ISR cache
+      });
+      if (res.ok) {
+        const data = await res.json();
+        latest = data.version;
+        break;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  let hasUpdate = false;
+  try {
+    hasUpdate = gt(latest, current);
+  } catch {
+    // Invalid version string from registry — treat as no update
+  }
+
+  return NextResponse.json({
+    current,
+    latest,
+    hasUpdate,
+  });
+}

package/app/app/globals.css

@@ -119,6 +119,9 @@ body {
   body { @apply bg-background text-foreground; }
 }
 
+/* Utility: IBM Plex Mono display heading font */
+.font-display { font-family: 'IBM Plex Mono', var(--font-ibm-plex-mono), monospace; }
+
 /* Content width — controlled by Settings > Appearance */
 :root { --content-width: 780px; }
 .content-width { max-width: var(--content-width-override, var(--content-width)); margin-left: auto; margin-right: auto; }
@@ -287,6 +290,15 @@ body {
   button, a { -webkit-tap-highlight-color: transparent; }
 }
 
+/* Global focus-visible ring for interactive elements */
+button:focus-visible,
+a:focus-visible,
+[role="button"]:focus-visible {
+  outline: 2px solid var(--amber);
+  outline-offset: 2px;
+  border-radius: 4px;
+}
+
 /* ─── Tiptap WYSIWYG editor ─────────────────────────────────────────── */
 .wysiwyg-wrapper {
   height: 100%;

package/app/app/layout.tsx

@@ -7,6 +7,7 @@ import { TooltipProvider } from '@/components/ui/tooltip';
 import { LocaleProvider } from '@/lib/LocaleContext';
 import ErrorBoundary from '@/components/ErrorBoundary';
 import RegisterSW from './register-sw';
+import UpdateBanner from '@/components/UpdateBanner';
 
 const geistSans = Geist({
   variable: '--font-geist-sans',
@@ -20,13 +21,13 @@ const geistMono = Geist_Mono({
 
 const ibmPlexMono = IBM_Plex_Mono({
   variable: '--font-ibm-plex-mono',
-  weight: ['400', '500', '600'],
+  weight: ['400', '600'],
   subsets: ['latin'],
 });
 
 const ibmPlexSans = IBM_Plex_Sans({
   variable: '--font-ibm-plex-sans',
-  weight: ['300', '400', '500', '600'],
+  weight: ['400', '500', '600'],
   subsets: ['latin'],
 });
 
@@ -91,6 +92,7 @@ export default function RootLayout({
         suppressHydrationWarning
       >
         <LocaleProvider>
+          <UpdateBanner />
           <TooltipProvider delay={300}>
             <ErrorBoundary>
               <ShellLayout fileTree={fileTree}>