@geminilight/mindos 0.6.72 → 0.6.73

package/_standalone/lib/hooks/useFocusTrap.ts

@@ -0,0 +1,65 @@
+'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

@@ -0,0 +1,95 @@
+'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

@@ -0,0 +1,22 @@
+/**
+ * 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

@@ -0,0 +1,210 @@
+// ─── 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

@@ -0,0 +1,128 @@
+// ─── 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}`;
+}