@geminilight/mindos 0.6.73 → 0.6.74

package/_standalone/lib/hooks/useFocusTrap.ts

@@ -1,65 +0,0 @@
-'use client';
-
-import { useEffect, useRef } from 'react';
-
-/**
- * Focus trap hook: keeps Tab navigation within a dialog/modal.
- * Wraps focus from last focusable element back to first, and vice versa.
- */
-export function useFocusTrap(ref: React.RefObject<HTMLElement | null>, enabled = true) {
-  useEffect(() => {
-    if (!enabled || !ref.current) return;
-
-    const handleKeyDown = (e: KeyboardEvent) => {
-      if (e.key !== 'Tab') return;
-
-      const focusableElements = ref.current?.querySelectorAll(
-        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
-      ) as NodeListOf<HTMLElement>;
-
-      if (!focusableElements || focusableElements.length === 0) return;
-
-      const firstElement = focusableElements[0];
-      const lastElement = focusableElements[focusableElements.length - 1];
-      const activeElement = document.activeElement;
-
-      if (e.shiftKey) {
-        // Shift+Tab on first element -> focus last
-        if (activeElement === firstElement) {
-          e.preventDefault();
-          lastElement.focus();
-        }
-      } else {
-        // Tab on last element -> focus first
-        if (activeElement === lastElement) {
-          e.preventDefault();
-          firstElement.focus();
-        }
-      }
-    };
-
-    const container = ref.current;
-    container.addEventListener('keydown', handleKeyDown);
-    return () => container.removeEventListener('keydown', handleKeyDown);
-  }, [ref, enabled]);
-}
-
-/**
- * Return focus hook: saves reference to trigger element and restores focus on unmount
- */
-export function useReturnFocus() {
-  const triggerRef = useRef<HTMLElement | null>(null);
-
-  const saveTrigger = (el: HTMLElement | null) => {
-    triggerRef.current = el;
-  };
-
-  useEffect(() => {
-    return () => {
-      // Return focus on unmount
-      triggerRef.current?.focus();
-    };
-  }, []);
-
-  return saveTrigger;
-}

package/_standalone/lib/hooks/usePinnedFiles.ts

@@ -1,95 +0,0 @@
-'use client';
-
-import { useSyncExternalStore, useCallback } from 'react';
-
-const STORAGE_KEY = 'mindos-pinned-files';
-const EVENT_KEY = 'mindos:pins-changed';
-
-function getSnapshot(): string[] {
-  if (typeof window === 'undefined') return [];
-  try {
-    const raw = localStorage.getItem(STORAGE_KEY);
-    return raw ? JSON.parse(raw) : [];
-  } catch {
-    return [];
-  }
-}
-
-function getClientSnapshot(): string[] {
-  return cachedPins;
-}
-
-const SERVER_SNAPSHOT: string[] = [];
-function getServerSnapshot(): string[] {
-  return SERVER_SNAPSHOT;
-}
-
-// Lazy init — avoid calling getSnapshot() at module load time during SSR
-let cachedPins: string[] = [];
-let initialized = false;
-
-function ensureInit(): void {
-  if (!initialized && typeof window !== 'undefined') {
-    cachedPins = getSnapshot();
-    initialized = true;
-  }
-}
-
-function subscribe(callback: () => void): () => void {
-  ensureInit();
-  const onStorage = (e: StorageEvent) => {
-    if (e.key === STORAGE_KEY) {
-      cachedPins = getSnapshot();
-      callback();
-    }
-  };
-  const onCustom = () => {
-    cachedPins = getSnapshot();
-    callback();
-  };
-  window.addEventListener('storage', onStorage);
-  window.addEventListener(EVENT_KEY, onCustom);
-  return () => {
-    window.removeEventListener('storage', onStorage);
-    window.removeEventListener(EVENT_KEY, onCustom);
-  };
-}
-
-function writePins(pins: string[]): void {
-  cachedPins = pins;
-  try {
-    localStorage.setItem(STORAGE_KEY, JSON.stringify(pins));
-  } catch {
-    // localStorage unavailable (private browsing, quota exceeded) — memory only
-  }
-  window.dispatchEvent(new Event(EVENT_KEY));
-}
-
-export function usePinnedFiles() {
-  ensureInit();
-  const pins = useSyncExternalStore(subscribe, getClientSnapshot, getServerSnapshot);
-
-  const isPinned = useCallback((path: string) => pins.includes(path), [pins]);
-
-  const togglePin = useCallback((path: string) => {
-    const current = getSnapshot();
-    const idx = current.indexOf(path);
-    if (idx >= 0) {
-      current.splice(idx, 1);
-    } else {
-      current.unshift(path); // newest pin at top
-    }
-    writePins(current);
-  }, []);
-
-  const reorderPins = useCallback((newOrder: string[]) => {
-    writePins(newOrder);
-  }, []);
-
-  const removePin = useCallback((path: string) => {
-    const current = getSnapshot();
-    writePins(current.filter(p => p !== path));
-  }, []);
-
-  return { pinnedFiles: pins, isPinned, togglePin, reorderPins, removePin };
-}

package/_standalone/lib/i18n/_core.ts

@@ -1,22 +0,0 @@
-/**
- * Recursively widen literal string types to `string` so zh values can differ from en.
- *
- * Without Widen<T>, TypeScript would require zh strings to be the *exact* literal values from en.
- * E.g., if en has `common: { hello: "hello" as const }`, zh would be required to also have "hello".
- *
- * This type converts all string literals to generic `string`, allowing Chinese translations to use
- * completely different values while maintaining structure compatibility.
- *
- * Example:
- * ```
- * en = { msg: "Hello" as const }                // string literal "Hello"
- * zh_without = { msg: "你好" } satisfies typeof en  // ❌ ERROR: "你好" not assignable to "Hello"
- * zh_with = { msg: "你好" } satisfies Widen<typeof en>  // ✅ OK: string satisfies string
- * ```
- */
-export type Widen<T> =
-  T extends string ? string :
-  T extends readonly (infer U)[] ? readonly Widen<U>[] :
-  T extends (...args: infer A) => infer R ? (...args: A) => Widen<R> :
-  T extends object ? { [K in keyof T]: Widen<T[K]> } :
-  T;

package/_standalone/lib/im/adapters/dingtalk.ts

@@ -1,210 +0,0 @@
-// ─── DingTalk (钉钉) Adapter ──────────────────────────────────────────────────
-// Implements IMAdapter using direct HTTP API (no external SDK needed).
-// Supports two modes:
-//   1. Webhook bot (simple, one-way, group chat only, HMAC-SHA256 signing)
-//   2. App bot (full, two-way, requires client_id + client_secret)
-
-import crypto from 'crypto';
-import type { IMAdapter, IMMessage, IMSendResult, DingTalkConfig } from '../types';
-
-const SEND_TIMEOUT_MS = 10_000;
-const TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1000;
-
-export class DingTalkAdapter implements IMAdapter {
-  readonly platform = 'dingtalk' as const;
-
-  private config: DingTalkConfig;
-  private accessToken: string | null = null;
-  private tokenExpiresAt = 0;
-
-  constructor(config: DingTalkConfig) {
-    this.config = config;
-  }
-
-  async send(message: IMMessage, signal?: AbortSignal): Promise<IMSendResult> {
-    try {
-      if (this.config.webhook_url) {
-        return await this.sendViaWebhook(message, signal);
-      }
-
-      if (this.config.client_id && this.config.client_secret) {
-        return await this.sendViaApp(message, signal);
-      }
-
-      return { ok: false, error: 'DingTalk not configured: provide webhook_url or client_id + client_secret', timestamp: new Date().toISOString() };
-    } catch (err) {
-      return { ok: false, error: formatDingTalkError(err), timestamp: new Date().toISOString() };
-    }
-  }
-
-  async verify(): Promise<boolean> {
-    if (this.config.webhook_url) return true; // webhook mode has no verify
-
-    if (this.config.client_id && this.config.client_secret) {
-      try {
-        await this.ensureAccessToken();
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return false;
-  }
-
-  async dispose(): Promise<void> {
-    this.accessToken = null;
-    this.tokenExpiresAt = 0;
-  }
-
-  // ─── Webhook Mode ───────────────────────────────────────────────────────────
-
-  private async sendViaWebhook(message: IMMessage, signal?: AbortSignal): Promise<IMSendResult> {
-    let url = this.config.webhook_url!;
-
-    // Sign the webhook URL if secret is configured
-    if (this.config.webhook_secret) {
-      const timestamp = Date.now();
-      const stringToSign = `${timestamp}\n${this.config.webhook_secret}`;
-      const sign = crypto.createHmac('sha256', this.config.webhook_secret).update(stringToSign).digest('base64');
-      const sep = url.includes('?') ? '&' : '?';
-      url = `${url}${sep}timestamp=${timestamp}&sign=${encodeURIComponent(sign)}`;
-    }
-
-    // DingTalk webhook message types
-    let body: Record<string, unknown>;
-    if (message.format === 'markdown') {
-      body = {
-        msgtype: 'markdown',
-        markdown: { title: 'MindOS', text: message.text },
-      };
-    } else {
-      body = {
-        msgtype: 'text',
-        text: { content: message.text },
-      };
-    }
-
-    const res = await fetchWithTimeout(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-      signal,
-    }, SEND_TIMEOUT_MS);
-
-    const data = await res.json() as { errcode: number; errmsg: string };
-    if (data.errcode !== 0) {
-      return { ok: false, error: `DingTalk webhook error: ${data.errmsg} (code ${data.errcode})`, timestamp: new Date().toISOString() };
-    }
-    return { ok: true, timestamp: new Date().toISOString() };
-  }
-
-  // ─── App Mode ───────────────────────────────────────────────────────────────
-
-  private async sendViaApp(message: IMMessage, signal?: AbortSignal): Promise<IMSendResult> {
-    const token = await this.ensureAccessToken();
-
-    // DingTalk uses a different API for app messages
-    const url = `https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend`;
-
-    const body: Record<string, unknown> = {
-      robotCode: this.config.client_id,
-      userIds: [message.recipientId],
-      msgKey: message.format === 'markdown' ? 'sampleMarkdown' : 'sampleText',
-      msgParam: message.format === 'markdown'
-        ? JSON.stringify({ title: 'MindOS', text: message.text })
-        : JSON.stringify({ content: message.text }),
-    };
-
-    const res = await fetchWithTimeout(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-acs-dingtalk-access-token': token,
-      },
-      body: JSON.stringify(body),
-      signal,
-    }, SEND_TIMEOUT_MS);
-
-    if (!res.ok) {
-      const text = await res.text();
-      return { ok: false, error: `DingTalk API error (${res.status}): ${text}`, timestamp: new Date().toISOString() };
-    }
-
-    const data = await res.json() as { processQueryKey?: string };
-    return { ok: true, messageId: data.processQueryKey, timestamp: new Date().toISOString() };
-  }
-
-  // ─── Token Management ───────────────────────────────────────────────────────
-
-  private async ensureAccessToken(): Promise<string> {
-    if (this.accessToken && Date.now() < this.tokenExpiresAt - TOKEN_REFRESH_BUFFER_MS) {
-      return this.accessToken;
-    }
-
-    const url = 'https://api.dingtalk.com/v1.0/oauth2/accessToken';
-    const res = await fetchWithTimeout(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        appKey: this.config.client_id,
-        appSecret: this.config.client_secret,
-      }),
-    }, SEND_TIMEOUT_MS);
-
-    const data = await res.json() as { accessToken?: string; expireIn?: number; code?: string; message?: string };
-    if (!data.accessToken) {
-      throw new Error(`DingTalk token error: ${data.message ?? 'unknown'} (code ${data.code ?? 'unknown'})`);
-    }
-
-    this.accessToken = data.accessToken;
-    this.tokenExpiresAt = Date.now() + (data.expireIn ?? 7200) * 1000;
-    return this.accessToken;
-  }
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-async function fetchWithTimeout(url: string, init: RequestInit, timeoutMs: number): Promise<Response> {
-  const controller = new AbortController();
-
-  return await new Promise<Response>((resolve, reject) => {
-    if (init.signal?.aborted) {
-      reject(new DOMException('Aborted', 'AbortError'));
-      return;
-    }
-
-    const timer = setTimeout(() => {
-      controller.abort();
-      reject(new Error('Request timed out'));
-    }, timeoutMs);
-
-    const onAbort = () => {
-      clearTimeout(timer);
-      controller.abort();
-      reject(new DOMException('Aborted', 'AbortError'));
-    };
-
-    init.signal?.addEventListener('abort', onAbort, { once: true });
-
-    fetch(url, { ...init, signal: controller.signal }).then(
-      (response) => {
-        clearTimeout(timer);
-        init.signal?.removeEventListener('abort', onAbort);
-        resolve(response);
-      },
-      (error) => {
-        clearTimeout(timer);
-        init.signal?.removeEventListener('abort', onAbort);
-        reject(error);
-      },
-    );
-  });
-}
-
-function formatDingTalkError(err: unknown): string {
-  if (!(err instanceof Error)) return String(err);
-  if (err.name === 'AbortError') return 'Send cancelled';
-  const msg = err.message;
-  if (msg.includes('timed out') || msg.includes('abort')) return 'DingTalk request timed out (10s)';
-  return `DingTalk error: ${msg}`;
-}

package/_standalone/lib/im/adapters/discord.ts

@@ -1,128 +0,0 @@
-// ─── Discord Adapter ──────────────────────────────────────────────────────────
-// Implements IMAdapter using discord.js REST-only (no Gateway WebSocket).
-// Only uses REST API for sending — no persistent connection needed.
-
-import type { IMAdapter, IMMessage, IMSendResult, DiscordConfig } from '../types';
-
-const SEND_TIMEOUT_MS = 10_000;
-
-export class DiscordAdapter implements IMAdapter {
-  readonly platform = 'discord' as const;
-
-  private rest: any | null = null; // REST instance — typed as any to avoid top-level import
-  private config: DiscordConfig;
-  private botInfoCache: { id: string; username: string } | null = null;
-
-  constructor(config: DiscordConfig) {
-    this.config = config;
-  }
-
-  async send(message: IMMessage, signal?: AbortSignal): Promise<IMSendResult> {
-    const { rest, Routes } = await this.ensureRest();
-    const channelId = message.recipientId;
-
-    try {
-      const body: Record<string, unknown> = { content: message.text };
-
-      // Discord natively supports Markdown — no conversion needed
-      // Thread support: if threadId is provided, send to that thread (which is a channel)
-      const targetChannel = message.threadId ?? channelId;
-
-      const result = await callWithTimeout(
-        () => rest.post(Routes.channelMessages(targetChannel), { body }) as Promise<{ id: string }>,
-        SEND_TIMEOUT_MS,
-        signal,
-      );
-
-      return {
-        ok: true,
-        messageId: result?.id ? String(result.id) : undefined,
-        timestamp: new Date().toISOString(),
-      };
-    } catch (err) {
-      return {
-        ok: false,
-        error: formatDiscordError(err),
-        timestamp: new Date().toISOString(),
-      };
-    }
-  }
-
-  async verify(): Promise<boolean> {
-    try {
-      const { rest, Routes } = await this.ensureRest();
-      const me = await rest.get(Routes.user('@me')) as { id: string; username: string };
-      this.botInfoCache = { id: me.id, username: me.username };
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  getBotInfo(): { id: string; username: string } | null {
-    return this.botInfoCache;
-  }
-
-  async dispose(): Promise<void> {
-    this.rest = null;
-    this.botInfoCache = null;
-  }
-
-  // ─── Internal ───────────────────────────────────────────────────────────────
-
-  private async ensureRest(): Promise<{ rest: any; Routes: any }> {
-    const discordjs = await loadDiscordJS();
-    if (!this.rest) {
-      this.rest = new discordjs.REST({ version: '10' }).setToken(this.config.bot_token);
-    }
-    return { rest: this.rest, Routes: discordjs.Routes };
-  }
-}
-
-// ─── Discord.js Loader ────────────────────────────────────────────────────────
-
-let cachedDiscordJS: { REST: any; Routes: any } | null = null;
-
-async function loadDiscordJS() {
-  if (cachedDiscordJS) return cachedDiscordJS;
-  try {
-    const mod = await import('discord.js');
-    cachedDiscordJS = { REST: mod.REST, Routes: mod.Routes };
-    return cachedDiscordJS;
-  } catch (err) {
-    if (err instanceof Error && (err.message.includes('Cannot find module') || err.message.includes('MODULE_NOT_FOUND'))) {
-      throw new Error('discord.js package not installed. Run: npm install discord.js');
-    }
-    throw err;
-  }
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function callWithTimeout<T>(fn: () => Promise<T>, timeoutMs: number, signal?: AbortSignal): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    if (signal?.aborted) { reject(new DOMException('Aborted', 'AbortError')); return; }
-    const timer = setTimeout(() => reject(new Error('Send timed out')), timeoutMs);
-    const onAbort = () => { clearTimeout(timer); reject(new DOMException('Aborted', 'AbortError')); };
-    signal?.addEventListener('abort', onAbort, { once: true });
-    fn().then(
-      (val) => { clearTimeout(timer); signal?.removeEventListener('abort', onAbort); resolve(val); },
-      (err) => { clearTimeout(timer); signal?.removeEventListener('abort', onAbort); reject(err); },
-    );
-  });
-}
-
-function formatDiscordError(err: unknown): string {
-  if (!(err instanceof Error)) return String(err);
-  if (err.name === 'AbortError') return 'Send cancelled';
-  const msg = err.message;
-  // discord.js DiscordAPIError codes
-  if (msg.includes('50001') || msg.includes('Missing Access')) return 'Missing access to channel. Check bot permissions.';
-  if (msg.includes('50013') || msg.includes('Missing Permissions')) return 'Missing permissions to send messages in this channel.';
-  if (msg.includes('10003') || msg.includes('Unknown Channel')) return 'Unknown channel: check recipient_id';
-  if (msg.includes('40001') || msg.includes('Unauthorized')) return 'Unauthorized: check bot_token';
-  if (msg.includes('timed out')) return 'Send timed out (10s)';
-  if (msg.includes('discord.js package not installed')) return msg;
-  // discord.js handles 429 automatically with built-in rate limit queue
-  return `Discord error: ${msg}`;
-}