@lark-apaas/client-toolkit 1.1.21-alpha.auth.dev.0 → 1.1.21-alpha.auth.dev.10

package/lib/components/User/UserDisplay.js

@@ -1,10 +1,11 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useState } from "react";
-import { getDataloom } from "../../integrations/dataloom.js";
+import { getCachedUserProfiles, setCachedUserProfiles } from "../../utils/userProfileCache.js";
 import { clsxWithTw } from "../../utils/utils.js";
 import { UserProfile } from "./UserProfile/index.js";
 import { UserWithAvatar } from "./UserWithAvatar.js";
 import { Popover, PopoverContent, PopoverTrigger } from "../ui/popover.js";
+import { fetchWithDeduplication } from "../../utils/requestManager.js";
 const UserDisplay = ({ users, size, className, style, showLabel = true })=>{
     const normalizedIds = useMemo(()=>{
         if (!users) return [];
@@ -12,12 +13,12 @@ const UserDisplay = ({ users, size, className, style, showLabel = true })=>{
             if (0 === users.length) return [];
             const first = users[0];
             const isStringArray = 'string' == typeof first;
-            return isStringArray ? users.filter(Boolean).map((id)=>String(id)) : users.map((u)=>String(u.user_id)).filter(Boolean);
+            return isStringArray ? users.filter(Boolean).map((id)=>String(id)) : users.map((u)=>String(u?.user_id)).filter(Boolean);
         }
         return 'string' == typeof users ? [
             String(users)
         ] : [
-            String(users.user_id)
+            String(users?.user_id)
         ].filter(Boolean);
     }, [
         users
@@ -71,22 +72,20 @@ const UserDisplay = ({ users, size, className, style, showLabel = true })=>{
         const fetchProfiles = async ()=>{
             try {
                 setLoadingProfiles(true);
-                const dataloom = await getDataloom();
-                if (!dataloom) throw new Error('dataloom client is unavailable');
-                const ids = normalizedIds.map((id)=>Number(id)).filter((id)=>Number.isFinite(id));
-                if (!ids.length) {
-                    setResolvedUsers(normalizedIds.map((id)=>inputProfilesMap.get(id) ?? {
-                            user_id: id,
-                            name: '',
-                            avatar: '',
-                            email: '',
-                            status: 1
-                        }));
-                    setLoadingProfiles(false);
-                    return;
-                }
-                const response = await dataloom.service.user.getByIds(ids);
-                const fetchedList = Array.isArray(response?.data) ? response?.data : Array.isArray(response?.data?.user_list) ? response?.data?.user_list : [];
+                const { cachedProfiles, remainingIds } = getCachedUserProfiles(normalizedIds);
+                if (cachedProfiles.length > 0) setResolvedUsers((prev)=>{
+                    const updatedUsers = [
+                        ...prev
+                    ];
+                    cachedProfiles.forEach((cached)=>{
+                        const index = updatedUsers.findIndex((u)=>u.user_id === cached.user_id);
+                        if (-1 !== index) updatedUsers[index] = cached;
+                    });
+                    return updatedUsers;
+                });
+                if (0 === remainingIds.length) return void setLoadingProfiles(false);
+                const fetchedList = await fetchWithDeduplication(remainingIds);
+                if (isCancelled || !fetchedList) return;
                 const fetchedMap = new Map();
                 fetchedList.forEach((profile)=>{
                     const id = String(profile?.user_id ?? '');
@@ -99,13 +98,15 @@ const UserDisplay = ({ users, size, className, style, showLabel = true })=>{
                         status: profile?.status ?? 1
                     });
                 });
+                setCachedUserProfiles(fetchedList);
                 const mergedUsers = normalizedIds.map((id)=>{
                     const fetched = fetchedMap.get(id);
                     const given = inputProfilesMap.get(id);
-                    const name = given?.name?.trim() ? given.name : fetched?.name ?? '';
-                    const avatar = given?.avatar || fetched?.avatar || '';
-                    const email = given?.email || fetched?.email || '';
-                    const status = given?.status ?? fetched?.status ?? 1;
+                    const cached = cachedProfiles.find((p)=>p.user_id === id);
+                    const name = given?.name?.trim() || fetched?.name || cached?.name || '';
+                    const avatar = given?.avatar || fetched?.avatar || cached?.avatar || '';
+                    const email = given?.email || fetched?.email || cached?.email || '';
+                    const status = given?.status ?? fetched?.status ?? cached?.status ?? 1;
                     return {
                         user_id: id,
                         name,

package/lib/components/User/index.d.ts

@@ -1,7 +1,7 @@
 export { UserSelect } from './UserSelect';
 export type { UserSelectProps } from './UserSelect';
 export { UserDisplay } from './UserDisplay';
-export type { UserDisplayProps } from './UserDisplay';
+export type { IUserDisplayProps as UserDisplayProps } from './UserDisplay';
 export { UserWithAvatar } from './UserWithAvatar';
 export type { UserWithAvatarProps } from './type';
 export { UserProfile } from './UserProfile';

package/lib/components/ui/badge.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const badgeVariants: (props?: {
-    variant?: "default" | "secondary" | "destructive" | "outline";
+    variant?: "default" | "destructive" | "secondary" | "outline";
 } & import("class-variance-authority/dist/types").ClassProp) => string;
 declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
     asChild?: boolean;

package/lib/components/ui/button.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const buttonVariants: (props?: {
-    variant?: "default" | "link" | "secondary" | "destructive" | "outline" | "ghost";
+    variant?: "default" | "link" | "destructive" | "secondary" | "outline" | "ghost";
     size?: "default" | "icon" | "sm" | "lg" | "icon-sm" | "icon-lg";
 } & import("class-variance-authority/dist/types").ClassProp) => string;
 declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {

package/lib/hooks/useCurrentUserProfile.js

@@ -19,9 +19,9 @@ const useCurrentUserProfile = ()=>{
             (async ()=>{
                 const dataloom = await getDataloom();
                 const result = await dataloom.service.session.getUserInfo();
-                const userInfo = result?.data?.user_info;
+                const userInfo = result?.data?.userInfo;
                 setUserInfo({
-                    user_id: userInfo?.user_id?.toString(),
+                    user_id: userInfo?.userID?.toString(),
                     email: userInfo?.email,
                     name: userInfo?.name?.[0]?.text,
                     avatar: userInfo?.avatar?.image?.large,
@@ -32,9 +32,9 @@ const useCurrentUserProfile = ()=>{
             handleMetaInfoChanged = async ()=>{
                 const dataloom = await getDataloom();
                 const result = await dataloom.service.session.getUserInfo();
-                const userInfo = result?.data?.user_info;
+                const userInfo = result?.data?.userInfo;
                 const newUserInfo = {
-                    user_id: userInfo?.user_id?.toString(),
+                    user_id: userInfo?.userID?.toString(),
                     email: userInfo?.email,
                     name: userInfo?.name?.[0]?.text,
                     avatar: userInfo?.avatar?.image?.large,

package/lib/logger/selected-logs.js

@@ -71,18 +71,26 @@ async function sendSelectedLog(logWithoutID) {
             } catch (postError) {}
         }
         if (void 0 === log.meta.skipFrame) log.meta.skipFrame = 2;
-        const logJSON = JSON.stringify(log);
+        const errorReplacer = (key, value)=>{
+            if (value instanceof Error) return {
+                message: value.message,
+                stack: value.stack,
+                name: value.name
+            };
+            return value;
+        };
+        const logJSON = JSON.stringify(log, errorReplacer);
         const logForDedup = {
             ...log
         };
         delete logForDedup.id;
-        const logContentForDedup = JSON.stringify(logForDedup);
+        const logContentForDedup = JSON.stringify(logForDedup, errorReplacer);
         if (lastLogInfo && lastLogInfo.content === logContentForDedup) {
             lastLogInfo.count++;
             log.meta.isDuplicate = true;
             log.meta.duplicateCount = lastLogInfo.count;
             log.meta.duplicateOfId = lastLogInfo.id;
-            const updatedLogJSON = JSON.stringify(log);
+            const updatedLogJSON = JSON.stringify(log, errorReplacer);
             try {
                 batchLogInfo('info', updatedLogJSON);
             } catch (e) {}

package/lib/server-log/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Server Log 模块
+ *
+ * 通过 HTTP 轮询方式获取服务端日志并转发给父窗口
+ */
+export { ServerLogPoller } from './poller';
+export type { ServerLogPollerOptions } from './poller';
+export type { ServerLog, ServerLogLevel, ServerLogSource, ServerLogMeta, ServerLogPostMessage, ClientToServerMessage, ServerToClientMessage, } from './types';
+export { ServerLogPoller as default } from './poller';

package/lib/server-log/index.js

@@ -0,0 +1,2 @@
+import { ServerLogPoller } from "./poller.js";
+export { ServerLogPoller, ServerLogPoller as default };

package/lib/server-log/poller.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Server Log Poller (HTTP 轮询版本)
+ *
+ * 职责：
+ * 1. 定期轮询后端 HTTP API (/dev/logs/server-logs)
+ * 2. 获取新的服务端日志
+ * 3. 将接收到的日志通过 postMessage 转发给父窗口 (miaoda)
+ * 4. 管理连接状态并通知父窗口
+ *
+ * 与 ServerLogForwarder 的区别：
+ * - 使用 HTTP 轮询代替 WebSocket
+ * - 无需 socket.io-client 依赖
+ * - 更简单、更稳定、更易调试
+ */
+export interface ServerLogPollerOptions {
+    /**
+     * 后端服务器 URL
+     * @example 'http://localhost:3000'
+     */
+    serverUrl: string;
+    /**
+     * API 路径
+     * @default '/dev/logs/server-logs'
+     */
+    apiPath?: string;
+    /**
+     * 轮询间隔（毫秒）
+     * @default 2000
+     */
+    pollInterval?: number;
+    /**
+     * 每次获取的日志数量
+     * @default 100
+     */
+    limit?: number;
+    /**
+     * 是否启用调试日志
+     * @default false
+     */
+    debug?: boolean;
+}
+type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+export declare class ServerLogPoller {
+    private intervalId;
+    private status;
+    private lastTimestamp;
+    private options;
+    private isPolling;
+    constructor(options: ServerLogPollerOptions);
+    /**
+     * 启动轮询器
+     */
+    start(): void;
+    /**
+     * 停止轮询器
+     */
+    stop(): void;
+    /**
+     * 获取当前连接状态
+     */
+    getStatus(): ConnectionStatus;
+    /**
+     * 执行一次轮询
+     */
+    private poll;
+    /**
+     * 转发日志到父窗口
+     */
+    private forwardLog;
+    /**
+     * 更新连接状态并通知父窗口
+     */
+    private updateStatus;
+    /**
+     * 发送消息到父窗口
+     */
+    private postToParent;
+    /**
+     * 调试日志
+     */
+    private log;
+    /**
+     * 错误日志
+     */
+    private error;
+}
+export {};

package/lib/server-log/poller.js

@@ -0,0 +1,135 @@
+class ServerLogPoller {
+    intervalId = null;
+    status = 'disconnected';
+    lastTimestamp = 0;
+    options;
+    isPolling = false;
+    constructor(options){
+        this.options = {
+            serverUrl: options.serverUrl,
+            apiPath: (process.env.CLIENT_BASE_PATH || '') + (options.apiPath || '/dev/logs/server-logs'),
+            pollInterval: options.pollInterval || 2000,
+            limit: options.limit || 100,
+            debug: options.debug ?? false
+        };
+    }
+    start() {
+        if (this.isPolling) return void this.log('Poller already started');
+        this.isPolling = true;
+        this.updateStatus('connecting');
+        this.log('Starting server log poller...', {
+            serverUrl: this.options.serverUrl,
+            apiPath: this.options.apiPath,
+            pollInterval: this.options.pollInterval
+        });
+        this.poll();
+        this.intervalId = window.setInterval(()=>{
+            this.poll();
+        }, this.options.pollInterval);
+    }
+    stop() {
+        if (!this.isPolling) return void this.log('Poller not running');
+        this.log('Stopping server log poller...');
+        if (null !== this.intervalId) {
+            window.clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        this.isPolling = false;
+        this.updateStatus('disconnected');
+    }
+    getStatus() {
+        return this.status;
+    }
+    async poll() {
+        try {
+            const url = `${this.options.serverUrl}${this.options.apiPath}?limit=${this.options.limit}&sources=server,trace,server-std,client-std`;
+            this.log('Polling...', {
+                url
+            });
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    Accept: 'application/json'
+                },
+                signal: AbortSignal.timeout(5000)
+            });
+            if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            const data = await response.json();
+            this.log('Received logs', {
+                count: data.logs.length,
+                total: data.total,
+                hasMore: data.hasMore
+            });
+            const newLogs = data.logs.filter((log)=>log.timestamp > this.lastTimestamp);
+            if (newLogs.length > 0) {
+                this.lastTimestamp = Math.max(...newLogs.map((log)=>log.timestamp));
+                newLogs.sort((a, b)=>a.timestamp - b.timestamp);
+                this.log(`Forwarding ${newLogs.length} new logs`);
+                newLogs.forEach((log)=>{
+                    this.forwardLog(log);
+                });
+            }
+            if ('connected' !== this.status) {
+                this.updateStatus('connected');
+                if (0 === this.lastTimestamp && data.logs.length > 0) this.lastTimestamp = Math.max(...data.logs.map((log)=>log.timestamp));
+            }
+        } catch (error) {
+            this.error('Poll failed', error);
+            if ('error' !== this.status) {
+                this.updateStatus('error');
+                this.postToParent({
+                    type: 'SERVER_LOG_CONNECTION',
+                    status: 'error',
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+    }
+    forwardLog(log) {
+        try {
+            this.log('Forwarding log to parent window', {
+                type: 'SERVER_LOG',
+                logId: log.id,
+                level: log.level,
+                tags: log.tags
+            });
+            this.postToParent({
+                type: 'SERVER_LOG',
+                payload: JSON.stringify(log)
+            });
+            this.log('Log forwarded successfully');
+        } catch (e) {
+            this.error('Failed to forward log', e);
+        }
+    }
+    updateStatus(status) {
+        const previousStatus = this.status;
+        this.status = status;
+        if (previousStatus !== status) {
+            this.log(`Status changed: ${previousStatus} → ${status}`);
+            this.postToParent({
+                type: 'SERVER_LOG_CONNECTION',
+                status
+            });
+        }
+    }
+    postToParent(message) {
+        if (window.parent === window) return;
+        try {
+            window.parent.postMessage(message, '*');
+        } catch (e) {
+            this.error('postMessage error', e);
+        }
+    }
+    log(message, data) {
+        const enableLog = 'true' === localStorage.getItem('debug_server_log_poller');
+        if (this.options.debug && enableLog) if (data) console.log(`[ServerLogPoller] ${message}`, data);
+        else console.log(`[ServerLogPoller] ${message}`);
+    }
+    error(message, error) {
+        const enableLog = 'true' === localStorage.getItem('debug_server_log_poller');
+        if (enableLog) if (error) console.error(`[ServerLogPoller] ${message}`, error);
+        else console.error(`[ServerLogPoller] ${message}`);
+    }
+}
+export { ServerLogPoller };

package/lib/server-log/types.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Server Log Stream 类型定义
+ *
+ * 这些类型与 @lark-apaas/nestjs-logger 保持一致
+ * 用于 iframe 端的日志转发功能
+ */
+/**
+ * 后端日志级别
+ * 与 NestJS LogLevel 对齐，但增加了 fatal
+ */
+export type ServerLogLevel = 'fatal' | 'error' | 'warn' | 'log' | 'debug' | 'verbose';
+/**
+ * 日志来源
+ */
+export type ServerLogSource = 'server' | 'trace' | 'server-std' | 'client-std' | 'browser';
+/**
+ * 日志元数据
+ */
+export interface ServerLogMeta {
+    pid?: number;
+    hostname?: string;
+    service?: string;
+    path?: string;
+    method?: string;
+    statusCode?: number;
+    durationMs?: number;
+    ip?: string;
+    requestBody?: any;
+    responseBody?: any;
+    [key: string]: unknown;
+}
+/**
+ * 后端日志对象
+ * 用于实时推送给前端展示
+ */
+export interface ServerLog {
+    /**
+     * 唯一标识符（UUID）
+     * 用于前端去重和引用
+     */
+    id: string;
+    /**
+     * 日志级别
+     */
+    level: ServerLogLevel;
+    /**
+     * 时间戳（毫秒）
+     */
+    timestamp: number;
+    /**
+     * 日志消息
+     */
+    message: string;
+    /**
+     * 日志上下文（如 Controller 名称、Service 名称）
+     */
+    context?: string;
+    /**
+     * 请求追踪 ID
+     * 用于关联同一个请求的所有日志
+     */
+    traceId?: string;
+    /**
+     * 用户 ID
+     */
+    userId?: string;
+    /**
+     * 应用 ID
+     */
+    appId?: string;
+    /**
+     * 租户 ID
+     */
+    tenantId?: string;
+    /**
+     * 错误堆栈（仅 ERROR/FATAL 级别）
+     */
+    stack?: string;
+    /**
+     * 额外的元数据
+     */
+    meta?: ServerLogMeta;
+    /**
+     * 自定义标签
+     * 如 ['server', 'bootstrap'] 或 ['trace', 'http']
+     */
+    tags?: string[];
+}
+/**
+ * WebSocket 消息类型（客户端 → 服务端）
+ */
+export type ClientToServerMessage = {
+    type: 'SUBSCRIBE';
+    payload: {
+        levels?: ServerLogLevel[];
+        tags?: string[];
+        sources?: ServerLogSource[];
+    };
+} | {
+    type: 'UNSUBSCRIBE';
+} | {
+    type: 'GET_HISTORY';
+    payload: {
+        limit?: number;
+        offset?: number;
+        levels?: ServerLogLevel[];
+        sources?: ServerLogSource[];
+    };
+} | {
+    type: 'CLEAR_LOGS';
+};
+/**
+ * WebSocket 消息类型（服务端 → 客户端）
+ */
+export type ServerToClientMessage = {
+    type: 'CONNECTED';
+    payload: {
+        clientId: string;
+        timestamp: number;
+    };
+} | {
+    type: 'LOG';
+    payload: ServerLog;
+} | {
+    type: 'LOGS_BATCH';
+    payload: ServerLog[];
+} | {
+    type: 'HISTORY';
+    payload: {
+        logs: ServerLog[];
+        total: number;
+        hasMore: boolean;
+    };
+} | {
+    type: 'LOGS_CLEARED';
+} | {
+    type: 'SUBSCRIBED';
+    payload: {
+        levels?: ServerLogLevel[];
+        tags?: string[];
+        sources?: ServerLogSource[];
+    };
+} | {
+    type: 'UNSUBSCRIBED';
+} | {
+    type: 'ERROR';
+    payload: {
+        message: string;
+        code?: string;
+    };
+};
+/**
+ * PostMessage 类型（iframe → parent）
+ *
+ * iframe 端通过 postMessage 将接收到的 WebSocket 消息转发给父窗口
+ */
+export type ServerLogPostMessage = {
+    type: 'SERVER_LOG';
+    payload: string;
+} | {
+    type: 'SERVER_LOG_CONNECTION';
+    status: 'connected' | 'disconnected' | 'error' | 'connecting';
+    error?: string;
+} | {
+    type: 'SERVER_LOG_CLEARED';
+};

package/lib/types/index.d.ts

@@ -10,5 +10,6 @@ declare global {
         _IS_Spark_RUNTIME?: boolean;
         _bucket_id?: string;
         csrfToken?: string;
+        collectEvent?: (...args: any[]) => void;
     }
 }

package/lib/types/tea.d.ts

@@ -0,0 +1,7 @@
+export interface TrackParams {
+    trackKey: TrackKey;
+    trackParams?: Record<string, unknown>;
+}
+export declare enum TrackKey {
+    VIEW = "aily_agent_artifact_page_view"
+}

package/lib/types/tea.js

@@ -0,0 +1,5 @@
+var tea_TrackKey = /*#__PURE__*/ function(TrackKey) {
+    TrackKey["VIEW"] = "aily_agent_artifact_page_view";
+    return TrackKey;
+}({});
+export { tea_TrackKey as TrackKey };