@geminilight/mindos 0.5.10 → 0.5.11

package/app/app/api/settings/test-key/route.ts

@@ -0,0 +1,111 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import { effectiveAiConfig } from '@/lib/settings';
+
+const TIMEOUT = 10_000;
+
+type ErrorCode = 'auth_error' | 'model_not_found' | 'rate_limited' | 'network_error' | 'unknown';
+
+function classifyError(status: number, body: string): { code: ErrorCode; error: string } {
+  if (status === 401 || status === 403) return { code: 'auth_error', error: 'Invalid API key' };
+  if (status === 404) return { code: 'model_not_found', error: 'Model not found' };
+  if (status === 429) return { code: 'rate_limited', error: 'Rate limited' };
+  // Try to extract error message from response body
+  try {
+    const parsed = JSON.parse(body);
+    const msg = parsed?.error?.message || parsed?.error || '';
+    if (typeof msg === 'string' && msg.length > 0) return { code: 'unknown', error: msg.slice(0, 200) };
+  } catch { /* not JSON */ }
+  return { code: 'unknown', error: `HTTP ${status}` };
+}
+
+async function testAnthropic(apiKey: string, model: string): Promise<{ ok: boolean; latency?: number; code?: ErrorCode; error?: string }> {
+  const start = Date.now();
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
+  try {
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({ model, max_tokens: 1, messages: [{ role: 'user', content: 'hi' }] }),
+      signal: ctrl.signal,
+    });
+    const latency = Date.now() - start;
+    if (res.ok) return { ok: true, latency };
+    const body = await res.text();
+    return { ok: false, ...classifyError(res.status, body) };
+  } catch (e: unknown) {
+    if (e instanceof Error && e.name === 'AbortError') return { ok: false, code: 'network_error', error: 'Request timed out' };
+    return { ok: false, code: 'network_error', error: e instanceof Error ? e.message : 'Network error' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function testOpenAI(apiKey: string, model: string, baseUrl: string): Promise<{ ok: boolean; latency?: number; code?: ErrorCode; error?: string }> {
+  const start = Date.now();
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
+  const url = (baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '') + '/chat/completions';
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({ model, max_tokens: 1, messages: [{ role: 'user', content: 'hi' }] }),
+      signal: ctrl.signal,
+    });
+    const latency = Date.now() - start;
+    if (res.ok) return { ok: true, latency };
+    const body = await res.text();
+    return { ok: false, ...classifyError(res.status, body) };
+  } catch (e: unknown) {
+    if (e instanceof Error && e.name === 'AbortError') return { ok: false, code: 'network_error', error: 'Request timed out' };
+    return { ok: false, code: 'network_error', error: e instanceof Error ? e.message : 'Network error' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { provider, apiKey, model, baseUrl } = body as {
+      provider?: string;
+      apiKey?: string;
+      model?: string;
+      baseUrl?: string;
+    };
+
+    if (provider !== 'anthropic' && provider !== 'openai') {
+      return NextResponse.json({ ok: false, code: 'unknown', error: 'Invalid provider' }, { status: 400 });
+    }
+
+    // Resolve actual API key: use provided key, fallback to config/env for masked or missing
+    const cfg = effectiveAiConfig();
+    let resolvedKey = apiKey || '';
+    if (!resolvedKey || resolvedKey === '***set***') {
+      resolvedKey = provider === 'anthropic' ? cfg.anthropicApiKey : cfg.openaiApiKey;
+    }
+
+    if (!resolvedKey) {
+      return NextResponse.json({ ok: false, code: 'auth_error', error: 'No API key configured' });
+    }
+
+    const resolvedModel = model || (provider === 'anthropic' ? cfg.anthropicModel : cfg.openaiModel);
+
+    const result = provider === 'anthropic'
+      ? await testAnthropic(resolvedKey, resolvedModel)
+      : await testOpenAI(resolvedKey, resolvedModel, baseUrl || cfg.openaiBaseUrl);
+
+    return NextResponse.json(result);
+  } catch (err) {
+    return NextResponse.json({ ok: false, code: 'unknown', error: String(err) }, { status: 500 });
+  }
+}

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

@@ -95,25 +95,13 @@ export async function POST(req: NextRequest) {
           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)
+        // Call CLI's sync init — pass clean remote + token separately (never embed token in URL)
         try {
           const cliPath = resolve(process.cwd(), '..', 'bin', 'cli.js');
-          const args = ['sync', 'init', '--non-interactive', '--remote', effectiveRemote, '--branch', branch];
+          const args = ['sync', 'init', '--non-interactive', '--remote', remote, '--branch', branch];
+          if (body.token) args.push('--token', body.token);
 
           await new Promise<void>((res, rej) => {
             execFile('node', [cliPath, ...args], { timeout: 30000 }, (err, stdout, stderr) => {
@@ -132,23 +120,20 @@ export async function POST(req: NextRequest) {
         if (!isGitRepo(mindRoot)) {
           return NextResponse.json({ error: 'Not a git repository' }, { status: 400 });
         }
-        // Pull
-        try { execSync('git pull --rebase --autostash', { cwd: mindRoot, stdio: 'pipe' }); } catch {
-          try { execSync('git rebase --abort', { cwd: mindRoot, stdio: 'pipe' }); } catch {}
-          try { execSync('git pull --no-rebase', { cwd: mindRoot, stdio: 'pipe' }); } catch {}
-        }
-        // Commit + push
-        execSync('git add -A', { cwd: mindRoot, stdio: 'pipe' });
-        const status = execSync('git status --porcelain', { cwd: mindRoot, encoding: 'utf-8' }).trim();
-        if (status) {
-          const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
-          execSync(`git commit -m "auto-sync: ${timestamp}"`, { cwd: mindRoot, stdio: 'pipe' });
-          execSync('git push', { cwd: mindRoot, stdio: 'pipe' });
+        // Delegate to CLI for unified conflict handling
+        try {
+          const cliPath = resolve(process.cwd(), '..', 'bin', 'cli.js');
+          await new Promise<void>((res, rej) => {
+            execFile('node', [cliPath, 'sync', 'now'], { timeout: 60000 }, (err, stdout, stderr) => {
+              if (err) rej(new Error(stderr?.trim() || err.message));
+              else res();
+            });
+          });
+          return NextResponse.json({ ok: true });
+        } catch (err: unknown) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          return NextResponse.json({ error: errMsg }, { status: 500 });
         }
-        const state = loadSyncState();
-        state.lastSync = new Date().toISOString();
-        writeFileSync(SYNC_STATE_PATH, JSON.stringify(state, null, 2) + '\n');
-        return NextResponse.json({ ok: true });
       }
 
       case 'on': {

package/app/components/settings/AiTab.tsx

@@ -1,9 +1,30 @@
 'use client';
 
-import { AlertCircle } from 'lucide-react';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { AlertCircle, Loader2 } from 'lucide-react';
 import type { AiSettings, ProviderConfig, SettingsData } from './types';
 import { Field, Select, Input, EnvBadge, ApiKeyInput } from './Primitives';
 
+type TestState = 'idle' | 'testing' | 'ok' | 'error';
+type ErrorCode = 'auth_error' | 'model_not_found' | 'rate_limited' | 'network_error' | 'unknown';
+
+interface TestResult {
+  state: TestState;
+  latency?: number;
+  error?: string;
+  code?: ErrorCode;
+}
+
+function errorMessage(t: any, code?: ErrorCode): string {
+  switch (code) {
+    case 'auth_error': return t.settings.ai.testKeyAuthError;
+    case 'model_not_found': return t.settings.ai.testKeyModelNotFound;
+    case 'rate_limited': return t.settings.ai.testKeyRateLimited;
+    case 'network_error': return t.settings.ai.testKeyNetworkError;
+    default: return t.settings.ai.testKeyUnknown;
+  }
+}
+
 interface AiTabProps {
   data: SettingsData;
   updateAi: (patch: Partial<AiSettings>) => void;
@@ -15,13 +36,76 @@ export function AiTab({ data, updateAi, t }: AiTabProps) {
   const envVal = data.envValues ?? {};
   const provider = data.ai.provider;
 
-  function patchProvider(name: 'anthropic' | 'openai', patch: Partial<ProviderConfig>) {
+  // --- Test key state ---
+  const [testResult, setTestResult] = useState<Record<string, TestResult>>({});
+  const okTimerRef = useRef<ReturnType<typeof setTimeout>>(undefined);
+  const prevProviderRef = useRef(provider);
+
+  // Reset test result when provider changes
+  useEffect(() => {
+    if (prevProviderRef.current !== provider) {
+      prevProviderRef.current = provider;
+      setTestResult({});
+      if (okTimerRef.current) { clearTimeout(okTimerRef.current); okTimerRef.current = undefined; }
+    }
+  }, [provider]);
+
+  // Cleanup ok timer
+  useEffect(() => () => { if (okTimerRef.current) clearTimeout(okTimerRef.current); }, []);
+
+  const handleTestKey = useCallback(async (providerName: 'anthropic' | 'openai') => {
+    const prov = data.ai.providers?.[providerName] ?? {} as ProviderConfig;
+    setTestResult(prev => ({ ...prev, [providerName]: { state: 'testing' } }));
+
+    try {
+      const body: Record<string, string> = { provider: providerName };
+      if (prov.apiKey) body.apiKey = prov.apiKey;
+      if (prov.model) body.model = prov.model;
+      if (providerName === 'openai' && prov.baseUrl) body.baseUrl = prov.baseUrl;
+
+      const res = await fetch('/api/settings/test-key', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      const json = await res.json();
+
+      if (json.ok) {
+        setTestResult(prev => ({ ...prev, [providerName]: { state: 'ok', latency: json.latency } }));
+        // Auto-clear after 5s
+        if (okTimerRef.current) clearTimeout(okTimerRef.current);
+        okTimerRef.current = setTimeout(() => {
+          setTestResult(prev => ({ ...prev, [providerName]: { state: 'idle' } }));
+        }, 5000);
+      } else {
+        setTestResult(prev => ({
+          ...prev,
+          [providerName]: { state: 'error', error: json.error, code: json.code },
+        }));
+      }
+    } catch {
+      setTestResult(prev => ({
+        ...prev,
+        [providerName]: { state: 'error', code: 'network_error', error: 'Network error' },
+      }));
+    }
+  }, [data.ai.providers]);
+
+  // Reset test result when key changes
+  const patchProviderWithReset = useCallback((name: 'anthropic' | 'openai', patch: Partial<ProviderConfig>) => {
+    if ('apiKey' in patch) {
+      setTestResult(prev => ({ ...prev, [name]: { state: 'idle' } }));
+    }
     updateAi({
       providers: {
         ...data.ai.providers,
         [name]: { ...data.ai.providers?.[name], ...patch },
       },
     });
+  }, [data.ai.providers, updateAi]);
+
+  function patchProvider(name: 'anthropic' | 'openai', patch: Partial<ProviderConfig>) {
+    patchProviderWithReset(name, patch);
   }
 
   const anthropic = data.ai.providers?.anthropic ?? { apiKey: '', model: '' };
@@ -31,6 +115,38 @@ export function AiTab({ data, updateAi, t }: AiTabProps) {
   const activeEnvKey = provider === 'anthropic' ? env.ANTHROPIC_API_KEY : env.OPENAI_API_KEY;
   const missingApiKey = !activeApiKey && !activeEnvKey;
 
+  // Test button helper
+  const renderTestButton = (providerName: 'anthropic' | 'openai', hasKey: boolean, hasEnv: boolean) => {
+    const result = testResult[providerName] ?? { state: 'idle' as TestState };
+    const disabled = result.state === 'testing' || (!hasKey && !hasEnv);
+
+    return (
+      <div className="flex items-center gap-2 mt-1.5">
+        <button
+          type="button"
+          disabled={disabled}
+          onClick={() => handleTestKey(providerName)}
+          className="inline-flex items-center gap-1.5 px-2.5 py-1 text-xs rounded-md border border-border text-muted-foreground hover:text-foreground hover:border-foreground/20 transition-colors disabled:opacity-40 disabled:cursor-not-allowed"
+        >
+          {result.state === 'testing' ? (
+            <>
+              <Loader2 size={12} className="animate-spin" />
+              {t.settings.ai.testKeyTesting}
+            </>
+          ) : (
+            t.settings.ai.testKey
+          )}
+        </button>
+        {result.state === 'ok' && result.latency != null && (
+          <span className="text-xs text-success">{t.settings.ai.testKeyOk(result.latency)}</span>
+        )}
+        {result.state === 'error' && (
+          <span className="text-xs text-error">✗ {errorMessage(t, result.code)}</span>
+        )}
+      </div>
+    );
+  };
+
   return (
     <div className="space-y-5">
       <Field label={<>{t.settings.ai.provider} <EnvBadge overridden={env.AI_PROVIDER} /></>}>
@@ -60,6 +176,7 @@ export function AiTab({ data, updateAi, t }: AiTabProps) {
               value={anthropic.apiKey}
               onChange={v => patchProvider('anthropic', { apiKey: v })}
             />
+            {renderTestButton('anthropic', !!anthropic.apiKey, !!env.ANTHROPIC_API_KEY)}
           </Field>
         </>
       ) : (
@@ -79,6 +196,7 @@ export function AiTab({ data, updateAi, t }: AiTabProps) {
               value={openai.apiKey}
               onChange={v => patchProvider('openai', { apiKey: v })}
             />
+            {renderTestButton('openai', !!openai.apiKey, !!env.OPENAI_API_KEY)}
           </Field>
           <Field
             label={<>{t.settings.ai.baseUrl} <EnvBadge overridden={env.OPENAI_BASE_URL} /></>}

package/app/instrumentation.ts

@@ -0,0 +1,19 @@
+export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { readFileSync } = await import('fs');
+    const { join, resolve } = await import('path');
+    const { homedir } = await import('os');
+    try {
+      const configPath = join(homedir(), '.mindos', 'config.json');
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      if (config.sync?.enabled && config.mindRoot) {
+        // Resolve absolute path to avoid Turbopack bundling issues
+        const syncModule = resolve(process.cwd(), '..', 'bin', 'lib', 'sync.js');
+        const { startSyncDaemon } = await import(/* webpackIgnore: true */ syncModule);
+        await startSyncDaemon(config.mindRoot);
+      }
+    } catch {
+      // Sync not configured or failed to start — silently skip
+    }
+  }
+}

package/app/lib/i18n.ts

@@ -119,6 +119,15 @@ export const messages = {
         resetToEnv: 'Reset to env value',
         restoreFromEnv: 'Restore from env',
         noApiKey: 'API key is not set. AI features will be unavailable until you add one.',
+        testKey: 'Test',
+        testKeyTesting: 'Testing...',
+        testKeyOk: (ms: number) => `\u2713 ${ms}ms`,
+        testKeyAuthError: 'Invalid API key',
+        testKeyModelNotFound: 'Model not found',
+        testKeyRateLimited: 'Rate limited, try again later',
+        testKeyNetworkError: 'Network error',
+        testKeyNoKey: 'No API key configured',
+        testKeyUnknown: 'Test failed',
       },
       appearance: {
         readingFont: 'Reading font',
@@ -514,6 +523,15 @@ export const messages = {
         resetToEnv: '恢复为环境变量',
         restoreFromEnv: '从环境变量恢复',
         noApiKey: 'API 密钥未设置，AI 功能暂不可用，请在此填写。',
+        testKey: '测试',
+        testKeyTesting: '测试中...',
+        testKeyOk: (ms: number) => `\u2713 ${ms}ms`,
+        testKeyAuthError: 'API Key 无效',
+        testKeyModelNotFound: '模型不存在',
+        testKeyRateLimited: '请求频率限制，稍后重试',
+        testKeyNetworkError: '网络错误',
+        testKeyNoKey: '未配置 API Key',
+        testKeyUnknown: '测试失败',
       },
       appearance: {
         readingFont: '正文字体',

package/app/next.config.ts

@@ -3,7 +3,7 @@ import path from "path";
 
 const nextConfig: NextConfig = {
   transpilePackages: ['github-slugger'],
-  serverExternalPackages: ['pdfjs-dist', 'pdf-parse'],
+  serverExternalPackages: ['pdfjs-dist', 'pdf-parse', 'chokidar'],
   outputFileTracingRoot: path.join(__dirname),
   turbopack: {
     root: path.join(__dirname),

package/bin/cli.js

@@ -803,7 +803,14 @@ ${bold('Examples:')}
     }
 
     if (sub === 'now') {
-      manualSync(mindRoot);
+      try {
+        console.log(dim('Pulling...'));
+        manualSync(mindRoot);
+        console.log(green('✔ Sync complete'));
+      } catch (err) {
+        console.error(red(err.message));
+        process.exit(1);
+      }
       return;
     }
 

package/bin/lib/sync.js

@@ -1,6 +1,7 @@
 import { execSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { resolve } from 'node:path';
+import { homedir } from 'node:os';
 import { CONFIG_PATH, MINDOS_DIR } from './constants.js';
 import { bold, dim, cyan, green, red, yellow } from './colors.js';
 
@@ -129,12 +130,24 @@ function autoPull(mindRoot) {
       }
     }
   }
+
+  // Retry any pending pushes (handles previous push failures)
+  try {
+    const unpushed = gitExec('git rev-list --count @{u}..HEAD', mindRoot);
+    if (parseInt(unpushed) > 0) {
+      execSync('git push', { cwd: mindRoot, stdio: 'pipe' });
+      saveSyncState({ ...loadSyncState(), lastSync: new Date().toISOString(), lastError: null });
+    }
+  } catch {
+    // No upstream tracking or push failed — ignore silently, autoCommitAndPush handles primary pushes
+  }
 }
 
 // ── Exported API ────────────────────────────────────────────────────────────
 
 let activeWatcher = null;
 let activePullInterval = null;
+let activeShutdownHandler = null;
 
 /**
  * Interactive sync init — configure remote git repo
@@ -187,18 +200,43 @@ export async function initSync(mindRoot, opts = {}) {
     try { execSync('git checkout -b main', { cwd: mindRoot, stdio: 'pipe' }); } catch {}
   }
 
+  // 1b. Ensure .gitignore exists
+  const gitignorePath = resolve(mindRoot, '.gitignore');
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, [
+      '# MindOS auto-generated',
+      '.DS_Store',
+      'Thumbs.db',
+      '*.tmp',
+      '*.bak',
+      '*.swp',
+      '*.sync-conflict',
+      'node_modules/',
+      '.obsidian/',
+      '',
+    ].join('\n'), 'utf-8');
+  }
+
   // Handle token for HTTPS
   if (token && remoteUrl.startsWith('https://')) {
     const urlObj = new URL(remoteUrl);
-    urlObj.username = 'oauth2';
-    urlObj.password = token;
-    // Configure credential helper
-    try { execSync(`git config credential.helper store`, { cwd: mindRoot, stdio: 'pipe' }); } catch {}
-    // Store the credential
+    // Choose credential helper by platform
+    const platform = process.platform;
+    let helper;
+    if (platform === 'darwin') helper = 'osxkeychain';
+    else if (platform === 'win32') helper = 'manager';
+    else helper = 'store';
+    try { execSync(`git config credential.helper '${helper}'`, { cwd: mindRoot, stdio: 'pipe' }); } catch {}
+    // Store the credential via git credential approve
     try {
       const credInput = `protocol=${urlObj.protocol.replace(':', '')}\nhost=${urlObj.host}\nusername=oauth2\npassword=${token}\n\n`;
       execSync('git credential approve', { cwd: mindRoot, input: credInput, stdio: 'pipe' });
     } catch {}
+    // For 'store' helper, restrict file permissions AFTER credential file is created
+    if (helper === 'store') {
+      const credFile = resolve(process.env.HOME || homedir(), '.git-credentials');
+      try { execSync(`chmod 600 "${credFile}"`, { stdio: 'pipe' }); } catch {}
+    }
   }
 
   // 4. Set remote
@@ -257,6 +295,7 @@ export async function initSync(mindRoot, opts = {}) {
  * Start file watcher + periodic pull
  */
 export async function startSyncDaemon(mindRoot) {
+  if (activeWatcher) return null; // already running — idempotent guard
   const config = loadSyncConfig();
   if (!config.enabled) return null;
   if (!mindRoot || !isGitRepo(mindRoot)) return null;
@@ -281,10 +320,20 @@ export async function startSyncDaemon(mindRoot) {
   // Pull on startup
   autoPull(mindRoot);
 
+  // Graceful shutdown: flush pending changes before exit
+  const gracefulShutdown = () => {
+    if (commitTimer) { clearTimeout(commitTimer); commitTimer = null; }
+    try { autoCommitAndPush(mindRoot); } catch {}
+    stopSyncDaemon();
+  };
+  process.on('SIGTERM', gracefulShutdown);
+  process.on('SIGINT', gracefulShutdown);
+
   activeWatcher = watcher;
   activePullInterval = pullInterval;
+  activeShutdownHandler = gracefulShutdown;
 
-  return { watcher, pullInterval };
+  return { watcher, pullInterval, gracefulShutdown };
 }
 
 /**
@@ -299,6 +348,11 @@ export function stopSyncDaemon() {
     clearInterval(activePullInterval);
     activePullInterval = null;
   }
+  if (activeShutdownHandler) {
+    process.removeListener('SIGTERM', activeShutdownHandler);
+    process.removeListener('SIGINT', activeShutdownHandler);
+    activeShutdownHandler = null;
+  }
 }
 
 /**
@@ -336,14 +390,10 @@ export function getSyncStatus(mindRoot) {
  */
 export function manualSync(mindRoot) {
   if (!mindRoot || !isGitRepo(mindRoot)) {
-    console.error(red('Not a git repository. Run `mindos sync init` first.'));
-    process.exit(1);
+    throw new Error('Not a git repository. Run `mindos sync init` first.');
   }
-  console.log(dim('Pulling...'));
   autoPull(mindRoot);
-  console.log(dim('Committing & pushing...'));
   autoCommitAndPush(mindRoot);
-  console.log(green('✔ Sync complete'));
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.5.10",
+  "version": "0.5.11",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",
@@ -54,8 +54,10 @@
     "!assets/capture-demo.mjs",
     "!assets/demo-flow.html",
     "!assets/demo-flow-zh.html",
+    "!assets/images",
     "!mcp/node_modules",
-    "!mcp/dist"
+    "!mcp/dist",
+    "!mcp/package-lock.json"
   ],
   "scripts": {
     "setup": "node scripts/setup.js",