@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/lib/stores/hidden-files.ts

@@ -0,0 +1,43 @@
+/**
+ * Hidden-files visibility store (localStorage-backed, reactive via useSyncExternalStore).
+ */
+import { useSyncExternalStore } from 'react';
+import type { FileNode } from '@/lib/types';
+import { SYSTEM_FILES } from '@/lib/types';
+
+const HIDDEN_FILES_KEY = 'show-hidden-files';
+
+function subscribeHiddenFiles(cb: () => void) {
+  const handler = (e: StorageEvent) => { if (e.key === HIDDEN_FILES_KEY) cb(); };
+  const custom = () => cb();
+  window.addEventListener('storage', handler);
+  window.addEventListener('mindos:hidden-files-changed', custom);
+  return () => {
+    window.removeEventListener('storage', handler);
+    window.removeEventListener('mindos:hidden-files-changed', custom);
+  };
+}
+
+function getShowHiddenFiles() {
+  if (typeof window === 'undefined') return false;
+  return localStorage.getItem(HIDDEN_FILES_KEY) === 'true';
+}
+
+export function setShowHiddenFiles(value: boolean) {
+  localStorage.setItem(HIDDEN_FILES_KEY, String(value));
+  window.dispatchEvent(new Event('mindos:hidden-files-changed'));
+}
+
+export function useShowHiddenFiles() {
+  return useSyncExternalStore(subscribeHiddenFiles, getShowHiddenFiles, () => false);
+}
+
+/** Filter out hidden entries (dot-files at root, system files) when show-hidden is off. */
+export function filterHiddenNodes(nodes: FileNode[], isRoot: boolean): FileNode[] {
+  return nodes.filter(node => {
+    if (isRoot && node.name.startsWith('.')) return false;
+    if (node.type === 'file' && SYSTEM_FILES.has(node.name)) return false;
+    if (node.type === 'directory' && node.name.startsWith('.')) return false;
+    return true;
+  });
+}

package/_standalone/lib/stores/locale-store.ts

@@ -0,0 +1,69 @@
+'use client';
+
+import { create } from 'zustand';
+import { Locale, messages, Messages } from '@/lib/i18n';
+
+/* ── Store ── */
+
+export interface LocaleStoreState {
+  locale: Locale;
+  t: Messages;
+  setLocale: (l: Locale) => void;
+  /** Hydrate from SSR value + attach listeners. Returns cleanup. */
+  _init: (ssrLocale: Locale) => () => void;
+}
+
+/** Read locale from localStorage, resolving 'system' */
+function getLocaleSnapshot(): Locale {
+  if (typeof window === 'undefined') return 'en';
+  const saved = localStorage.getItem('locale');
+  if (saved === 'zh') return 'zh';
+  if (saved === 'en') return 'en';
+  return navigator.language.startsWith('zh') ? 'zh' : 'en';
+}
+
+/**
+ * Read the locale that the inline <script> in layout.tsx already resolved.
+ * Returns 'en' to match SSR default — the LocaleStoreInit component
+ * reconciles to the real locale synchronously before first commit.
+ */
+function getPreHydrateLocale(): Locale {
+  return 'en';
+}
+
+const initialLocale = getPreHydrateLocale();
+
+export const useLocaleStore = create<LocaleStoreState>((set) => ({
+  locale: initialLocale,
+  t: messages[initialLocale] as unknown as Messages,
+
+  setLocale: (l: Locale) => {
+    document.cookie = `locale=${l};path=/;max-age=31536000;SameSite=Lax`;
+    document.documentElement.lang = l === 'zh' ? 'zh' : 'en';
+    (window as any).__mindos_locale__ = l;
+    set({ locale: l, t: messages[l] as unknown as Messages });
+    window.dispatchEvent(new Event('mindos-locale-change'));
+  },
+
+  _init: (ssrLocale: Locale) => {
+    // Reconcile: if client localStorage disagrees with current store, update once
+    const clientLocale = getLocaleSnapshot();
+    const current = useLocaleStore.getState().locale;
+    if (clientLocale !== current) {
+      set({ locale: clientLocale, t: messages[clientLocale] as unknown as Messages });
+    }
+
+    const handler = () => {
+      const l = getLocaleSnapshot();
+      set({ locale: l, t: messages[l] as unknown as Messages });
+    };
+    window.addEventListener('mindos-locale-change', handler);
+    return () => window.removeEventListener('mindos-locale-change', handler);
+  },
+}));
+
+/* ── Backward-compatible hook ── */
+
+export function useLocale() {
+  return useLocaleStore();
+}

package/_standalone/lib/stores/mcp-store.ts

@@ -0,0 +1,166 @@
+'use client';
+
+import { create } from 'zustand';
+import { apiFetch } from '@/lib/api';
+import type { McpStatus, AgentInfo, SkillInfo } from '@/components/settings/types';
+
+/* ── Public interface (unchanged from old Context) ── */
+
+export interface McpStoreState {
+  status: McpStatus | null;
+  agents: AgentInfo[];
+  skills: SkillInfo[];
+  loading: boolean;
+
+  /* actions */
+  refresh: () => Promise<void>;
+  toggleSkill: (name: string, enabled: boolean) => Promise<boolean>;
+  installAgent: (key: string, opts?: { scope?: string; transport?: string }) => Promise<boolean>;
+
+  /* lifecycle (called once by McpStoreInit) */
+  _init: () => () => void;
+}
+
+/** Keep the old name as an alias so consumers that import the type still compile. */
+export type McpContextValue = McpStoreState;
+
+/* ── Abort controller for race-condition safety ── */
+
+let abortCtrl: AbortController | null = null;
+
+/* ── Store ── */
+
+const POLL_INTERVAL = 30_000;
+
+async function fetchAll(set: (partial: Partial<McpStoreState>) => void) {
+  abortCtrl?.abort();
+  const ac = new AbortController();
+  abortCtrl = ac;
+
+  try {
+    const [statusData, agentsData, skillsData] = await Promise.all([
+      apiFetch<McpStatus>('/api/mcp/status', { signal: ac.signal }),
+      apiFetch<{ agents: AgentInfo[] }>('/api/mcp/agents', { signal: ac.signal }),
+      apiFetch<{ skills: SkillInfo[] }>('/api/skills', { signal: ac.signal }),
+    ]);
+    if (!ac.signal.aborted) {
+      set({ status: statusData, agents: agentsData.agents, skills: skillsData.skills });
+    }
+  } catch (err: unknown) {
+    if (err instanceof DOMException && err.name === 'AbortError') return;
+  } finally {
+    if (!ac.signal.aborted) set({ loading: false });
+  }
+}
+
+export const useMcpStore = create<McpStoreState>((set, get) => ({
+  status: null,
+  agents: [],
+  skills: [],
+  loading: true,
+
+  refresh: () => fetchAll(set),
+
+  toggleSkill: async (name, enabled) => {
+    // Optimistic update
+    set({ skills: get().skills.map(s => s.name === name ? { ...s, enabled } : s) });
+    try {
+      await apiFetch('/api/skills', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'toggle', name, enabled }),
+      });
+      return true;
+    } catch {
+      // Revert on failure
+      set({ skills: get().skills.map(s => s.name === name ? { ...s, enabled: !enabled } : s) });
+      return false;
+    }
+  },
+
+  installAgent: async (key, opts) => {
+    const agent = get().agents.find(a => a.key === key);
+    if (!agent) return false;
+
+    try {
+      const res = await apiFetch<{ results: Array<{ agent?: string; status?: string; ok?: boolean; error?: string }> }>('/api/mcp/install', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          agents: [{
+            key,
+            scope: opts?.scope ?? (agent.hasProjectScope ? 'project' : 'global'),
+            transport: opts?.transport ?? agent.preferredTransport,
+          }],
+          transport: 'auto',
+        }),
+      });
+
+      const first = res.results?.[0];
+      const ok = first?.ok === true || first?.status === 'ok';
+      if (ok) await fetchAll(set);
+      return ok;
+    } catch {
+      return false;
+    }
+  },
+
+  /**
+   * Start polling + event listeners. Returns a cleanup function.
+   * Must be called exactly once (by McpStoreInit).
+   */
+  _init: () => {
+    // Initial fetch
+    fetchAll(set);
+
+    // Event listener: skill CRUD mutations (debounced 500ms)
+    let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+    const onSkillsChanged = () => {
+      clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => fetchAll(set), 500);
+    };
+    window.addEventListener('mindos:skills-changed', onSkillsChanged);
+
+    // 30s polling when visible
+    const pollTimer = setInterval(() => {
+      if (document.visibilityState === 'visible') fetchAll(set);
+    }, POLL_INTERVAL);
+
+    return () => {
+      abortCtrl?.abort();
+      clearTimeout(debounceTimer);
+      clearInterval(pollTimer);
+      window.removeEventListener('mindos:skills-changed', onSkillsChanged);
+    };
+  },
+}));
+
+/* ── Convenience hooks (backward-compatible API) ── */
+
+/**
+ * Required hook — same behavior as old useMcpData().
+ * With Zustand this never throws because the store is global,
+ * but we keep the name for migration compatibility.
+ */
+export function useMcpData(): McpStoreState {
+  return useMcpStore();
+}
+
+/**
+ * Optional hook — returns the full store (never null with Zustand).
+ * Kept for backward-compat; callers that checked `if (!mcp)` will
+ * now always get a value (loading=true initially, then loading=false).
+ */
+export function useMcpDataOptional(): McpStoreState {
+  return useMcpStore();
+}
+
+/* ── Granular selectors — subscribe to individual fields to avoid unnecessary re-renders ── */
+
+export const useMcpLoading = () => useMcpStore(s => s.loading);
+export const useMcpAgents = () => useMcpStore(s => s.agents);
+export const useMcpSkills = () => useMcpStore(s => s.skills);
+export const useMcpStatus = () => useMcpStore(s => s.status);
+export const useMcpRefresh = () => useMcpStore(s => s.refresh);
+export const useMcpToggleSkill = () => useMcpStore(s => s.toggleSkill);
+export const useMcpInstallAgent = () => useMcpStore(s => s.installAgent);

package/_standalone/lib/stores/walkthrough-store.ts

@@ -0,0 +1,150 @@
+'use client';
+
+import { create } from 'zustand';
+import { walkthroughSteps } from '@/components/walkthrough/steps';
+
+/* ── Types ── */
+
+export type WalkthroughStatus = 'idle' | 'active' | 'completed' | 'dismissed';
+
+export interface WalkthroughStoreState {
+  status: WalkthroughStatus;
+  currentStep: number;
+  totalSteps: number;
+  start: () => void;
+  next: () => void;
+  back: () => void;
+  skip: () => void;
+  /** Called once to load from backend + attach URL param check. Returns cleanup. */
+  _init: () => () => void;
+}
+
+/* ── Helpers ── */
+
+const LS_KEY = 'mindos_walkthrough_done';
+
+/**
+ * Persist walkthrough state to server AND localStorage.
+ * localStorage acts as a safety net: even if the server persist fails
+ * (e.g. during update restart, network blip), the completion state
+ * survives page reload and prevents the "stuck overlay" bug.
+ */
+function persistStep(step: number, dismissed: boolean) {
+  // Local safety net — instant, survives server outage
+  if (step >= walkthroughSteps.length || dismissed) {
+    try { localStorage.setItem(LS_KEY, '1'); } catch {}
+  }
+  // Server persist — fire-and-forget (localStorage is the safety net)
+  fetch('/api/setup', {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      guideState: { walkthroughStep: step, walkthroughDismissed: dismissed },
+    }),
+  }).catch((err) => { console.warn('[walkthrough-store] persist failed:', err); });
+}
+
+/** Check if walkthrough was completed/dismissed (fast, sync, local) */
+function isLocallyDone(): boolean {
+  try { return localStorage.getItem(LS_KEY) === '1'; } catch { return false; }
+}
+
+/* ── Store ── */
+
+export const useWalkthroughStore = create<WalkthroughStoreState>((set, get) => {
+  const totalSteps = walkthroughSteps.length;
+
+  return {
+    status: 'idle',
+    currentStep: 0,
+    totalSteps,
+
+    start: () => {
+      set({ currentStep: 0, status: 'active' });
+      persistStep(0, false);
+    },
+
+    next: () => {
+      const nextStep = get().currentStep + 1;
+      if (nextStep >= totalSteps) {
+        set({ status: 'completed' });
+        persistStep(totalSteps, false);
+      } else {
+        set({ currentStep: nextStep });
+        persistStep(nextStep, false);
+      }
+    },
+
+    back: () => {
+      const cur = get().currentStep;
+      if (cur > 0) {
+        set({ currentStep: cur - 1 });
+        persistStep(cur - 1, false);
+      }
+    },
+
+    skip: () => {
+      set({ status: 'dismissed' });
+      persistStep(get().currentStep, true);
+    },
+
+    _init: () => {
+      // Handle ?welcome=1 URL param
+      const params = new URLSearchParams(window.location.search);
+      const isWelcome = params.get('welcome') === '1';
+      if (isWelcome) {
+        const url = new URL(window.location.href);
+        url.searchParams.delete('welcome');
+        window.history.replaceState({}, '', url.pathname + (url.search || ''));
+        window.dispatchEvent(new Event('mindos:first-visit'));
+      }
+
+      // Only auto-start on desktop
+      if (window.innerWidth < 768) return () => {};
+
+      // Fast local check: if walkthrough was completed/dismissed, never reactivate.
+      // This prevents the "stuck overlay" bug where server persist failed during
+      // update restart but localStorage recorded the completion.
+      if (isLocallyDone()) return () => {};
+
+      fetch('/api/setup')
+        .then(r => r.json())
+        .then(data => {
+          const gs = data.guideState;
+          if (!gs) return;
+          if (gs.walkthroughDismissed) {
+            try { localStorage.setItem(LS_KEY, '1'); } catch {} // sync local
+            return;
+          }
+
+          // If server says completed (step >= totalSteps), mark locally done
+          if (typeof gs.walkthroughStep === 'number' && gs.walkthroughStep >= totalSteps) {
+            try { localStorage.setItem(LS_KEY, '1'); } catch {};
+            return;
+          }
+
+          if (gs.active && !gs.dismissed && gs.walkthroughStep === undefined) {
+            if (isWelcome) {
+              set({ status: 'active', currentStep: 0 });
+            }
+          } else if (
+            typeof gs.walkthroughStep === 'number' &&
+            gs.walkthroughStep >= 0 &&
+            gs.walkthroughStep < totalSteps &&
+            !gs.walkthroughDismissed
+          ) {
+            set({ status: 'active', currentStep: gs.walkthroughStep });
+          }
+        })
+        .catch((err) => { console.warn('[walkthrough-store] guideState read failed:', err); });
+
+      return () => {};
+    },
+  };
+});
+
+/* ── Backward-compatible hook ── */
+
+export function useWalkthrough(): WalkthroughStoreState {
+  return useWalkthroughStore();
+}

package/_standalone/lib/toast.ts

@@ -0,0 +1,85 @@
+/**
+ * Global toast notification store.
+ * Uses module-level state + useSyncExternalStore (no Context/Provider needed).
+ *
+ * Usage:
+ *   import { toast } from '@/lib/toast';
+ *   toast.success('Saved!');
+ *   toast.error('Something went wrong');
+ *   toast.copy();           // "Copied" with check icon
+ *   toast('Custom message'); // info type
+ */
+
+export interface Toast {
+  id: string;
+  message: string;
+  type: 'success' | 'error' | 'info';
+  duration: number;
+  action?: { label: string; onClick: () => void };
+}
+
+type ToastInput = { message: string; type?: Toast['type']; duration?: number; action?: Toast['action'] };
+
+const DEFAULT_DURATION = 2000;
+const MAX_TOASTS = 3;
+
+let toasts: Toast[] = [];
+let listeners: Array<() => void> = [];
+let nextId = 0;
+
+function emit() {
+  for (const fn of listeners) fn();
+}
+
+export function subscribe(listener: () => void) {
+  listeners = [...listeners, listener];
+  return () => { listeners = listeners.filter((l) => l !== listener); };
+}
+
+export function getSnapshot(): Toast[] {
+  return toasts;
+}
+
+export function dismiss(id: string) {
+  toasts = toasts.filter((t) => t.id !== id);
+  emit();
+}
+
+function addToast(input: ToastInput) {
+  const id = `toast-${++nextId}`;
+  const t: Toast = {
+    id,
+    message: input.message,
+    type: input.type ?? 'info',
+    duration: input.duration ?? DEFAULT_DURATION,
+    action: input.action,
+  };
+  toasts = [...toasts, t].slice(-MAX_TOASTS);
+  emit();
+  if (t.duration > 0) {
+    setTimeout(() => dismiss(id), t.duration);
+  }
+}
+
+/** Show an info toast */
+function toast(message: string, opts?: { type?: Toast['type']; duration?: number }) {
+  addToast({ message, ...opts });
+}
+
+/** Show a success toast */
+toast.success = (message: string, duration?: number) =>
+  addToast({ message, type: 'success', duration });
+
+/** Show a toast with an undo action (5 second default) */
+toast.undo = (message: string, onUndo: () => void, opts?: { duration?: number; label?: string }) =>
+  addToast({ message, type: 'info', duration: opts?.duration ?? 5000, action: { label: opts?.label ?? 'Undo', onClick: onUndo } });
+
+/** Show an error toast */
+toast.error = (message: string, duration?: number) =>
+  addToast({ message, type: 'error', duration });
+
+/** Show a "Copied" success toast */
+toast.copy = (message = 'Copied') =>
+  addToast({ message, type: 'success', duration: 1500 });
+
+export { toast };

package/_standalone/lib/utils.ts

@@ -0,0 +1,45 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+
+/**
+ * Encode a relative file path for use in URLs.
+ * Each segment is individually URI-encoded.
+ */
+export function encodePath(filePath: string): string {
+  return filePath.split('/').map(encodeURIComponent).join('/');
+}
+
+/**
+ * Format a timestamp as a human-readable relative time string.
+ */
+export function relativeTime(mtime: number, labels: {
+  justNow: string;
+  minutesAgo: (n: number) => string;
+  hoursAgo: (n: number) => string;
+  daysAgo: (n: number) => string;
+}): string {
+  const diff = Date.now() - mtime;
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+  if (minutes < 1) return labels.justNow;
+  if (minutes < 60) return labels.minutesAgo(minutes);
+  if (hours < 24) return labels.hoursAgo(hours);
+  if (days < 7) return labels.daysAgo(days);
+  return new Date(mtime).toLocaleDateString();
+}
+
+/** Extract leading emoji from a string, e.g. "📝 Notes" → "📝" */
+export function extractEmoji(name: string): string {
+  const match = name.match(/^[\p{Emoji_Presentation}\p{Extended_Pictographic}]+/u);
+  return match?.[0] ?? '';
+}
+
+/** Strip leading emoji+space from a string, e.g. "📝 Notes" → "Notes" */
+export function stripEmoji(name: string): string {
+  return name.replace(/^[\p{Emoji_Presentation}\p{Extended_Pictographic}\s]+/u, '') || name;
+}

package/_standalone/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/_standalone/next.config.ts

@@ -0,0 +1,68 @@
+import type { NextConfig } from "next";
+import path from "path";
+
+// When MindOS is installed globally via npm, the entire project lives
+// under node_modules/@geminilight/mindos/. Next.js skips tsconfig path
+// resolution and SWC TypeScript compilation for files inside node_modules.
+// We detect this at config time and apply the necessary overrides.
+const projectDir = path.resolve(__dirname);
+const inNodeModules = projectDir.includes('node_modules');
+
+const nextConfig: NextConfig = {
+  transpilePackages: [
+    'github-slugger',
+    // Self-reference: ensures the SWC loader compiles our own TypeScript
+    // when the project is inside node_modules (global npm install).
+    ...(inNodeModules ? ['@geminilight/mindos'] : []),
+  ],
+  serverExternalPackages: [
+    'chokidar', 'openai', 'discord.js',
+    '@mariozechner/pi-ai', '@mariozechner/pi-agent-core', '@mariozechner/pi-coding-agent', 'pi-mcp-adapter',
+    // Heavy packages excluded from bundle — dynamically imported at runtime.
+    '@huggingface/transformers', 'onnxruntime-web',
+    'sharp', '@img/sharp-linux-x64', '@img/sharp-darwin-arm64', '@img/sharp-win32-x64',
+  ],
+  output: 'standalone',
+  outputFileTracingRoot: projectDir,
+  // Exclude heavy native packages from standalone trace to reduce runtime archive.
+  // @img/sharp-* (33MB) is optional for image processing.
+  outputFileTracingExcludes: {
+    '*': [
+      './node_modules/onnxruntime-node/**',
+      './node_modules/@img/**',
+      './node_modules/sharp/**',
+    ],
+  },
+  outputFileTracingIncludes: {
+    // extract-pdf.cjs is spawned at runtime (not bundled) — ensure it's
+    // copied into .next/standalone/scripts/ so standalone builds work.
+    '/api/extract-pdf': ['./scripts/extract-pdf.cjs'],
+  },
+  turbopack: {
+    root: projectDir,
+  },
+  experimental: {
+    staleTimes: {
+      dynamic: 0,
+    },
+  },
+  webpack: (config) => {
+    config.resolve = config.resolve ?? {};
+    config.resolve.alias = config.resolve.alias ?? {};
+    const alias = config.resolve.alias as Record<string, string>;
+
+    if (inNodeModules) {
+      alias['@'] = projectDir;
+    }
+
+    // Replace onnxruntime-node (355MB native binary) with onnxruntime-web (WASM).
+    // @huggingface/transformers statically imports onnxruntime-node in its Node.js
+    // entry. This alias makes it resolve to the lightweight WASM version instead,
+    // reducing the runtime archive from ~250MB to ~35MB with no code changes needed.
+    alias['onnxruntime-node'] = 'onnxruntime-web';
+
+    return config;
+  },
+};
+
+export default nextConfig;