@aiscene/shared 1.6.0

package/dist/types/mcp/types.d.ts

@@ -0,0 +1,103 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { z } from 'zod';
+/**
+ * Default timeout constants for app loading verification
+ */
+export declare const defaultAppLoadingTimeoutMs = 10000;
+export declare const defaultAppLoadingCheckIntervalMs = 2000;
+/**
+ * Content item types for tool results (MCP compatible)
+ */
+export type ToolResultContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+    mimeType: string;
+} | {
+    type: 'audio';
+    data: string;
+    mimeType: string;
+} | {
+    type: 'resource';
+    resource: {
+        text: string;
+        uri: string;
+        mimeType?: string;
+    } | {
+        uri: string;
+        blob: string;
+        mimeType?: string;
+    };
+};
+/**
+ * Result type for tool execution (MCP compatible)
+ */
+export interface ToolResult {
+    [x: string]: unknown;
+    content: ToolResultContent[];
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+}
+/**
+ * Tool handler function type
+ * Takes parsed arguments and returns a tool result
+ */
+export type ToolHandler<T = Record<string, unknown>> = (args: T) => Promise<ToolResult>;
+/**
+ * Tool schema type using Zod
+ */
+export type ToolSchema = Record<string, z.ZodTypeAny>;
+/**
+ * Tool definition for MCP server
+ */
+export interface ToolDefinition<T = Record<string, unknown>> {
+    name: string;
+    description: string;
+    schema: ToolSchema;
+    handler: ToolHandler<T>;
+}
+/**
+ * Tool type for mcpKitForAgent return value
+ */
+export type Tool = ToolDefinition;
+/**
+ * Action space item definition
+ * Note: Intentionally no index signature to maintain compatibility with DeviceAction
+ */
+export interface ActionSpaceItem {
+    name: string;
+    description?: string;
+    args?: Record<string, unknown>;
+    paramSchema?: z.ZodTypeAny;
+}
+/**
+ * Base agent interface
+ * Represents a platform-specific agent (Android, iOS, Web)
+ * Note: Return types use `unknown` for compatibility with platform-specific implementations
+ */
+export interface BaseAgent {
+    getActionSpace(): Promise<ActionSpaceItem[]>;
+    destroy?(): Promise<void>;
+    page?: {
+        screenshotBase64(): Promise<string>;
+    };
+    aiAction?: (description: string, params?: Record<string, unknown>) => Promise<unknown>;
+    aiWaitFor?: (assertion: string, options: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Base device interface for temporary device instances
+ */
+export interface BaseDevice {
+    actionSpace(): ActionSpaceItem[];
+    destroy?(): Promise<void>;
+}
+/**
+ * Interface for platform-specific MCP tools manager
+ */
+export interface IMidsceneTools {
+    attachToServer(server: McpServer): void;
+    initTools(): Promise<void>;
+    destroy?(): Promise<void>;
+}

package/dist/types/node/fs.d.ts

@@ -0,0 +1,15 @@
+interface PkgInfo {
+    name: string;
+    version: string;
+    dir: string;
+}
+export declare function getRunningPkgInfo(dir?: string): PkgInfo | null;
+/**
+ * Find the nearest package.json file recursively
+ * @param {string} dir - Home directory
+ * @returns {string|null} - The most recent package.json file path or null
+ */
+export declare function findNearestPackageJson(dir: string): string | null;
+export declare function getElementInfosScriptContent(): string;
+export declare function getExtraReturnLogic(tree?: boolean): Promise<string | null>;
+export {};

package/dist/types/node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fs';
+export * from './port';

package/dist/types/node/port.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if a port is available
+ */
+export declare function isPortAvailable(port: number): Promise<boolean>;
+/**
+ * Find an available port starting from the given port
+ */
+export declare function findAvailablePort(startPort: number, maxAttempts?: number): Promise<number>;

package/dist/types/polyfills/async-hooks.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Browser polyfill for Node.js async_hooks module
+ * Provides empty implementation for browser environments where async_hooks is not available
+ */
+declare const AsyncLocalStorage: {};
+export { AsyncLocalStorage };

package/dist/types/polyfills/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Polyfills for Node.js modules in browser environments
+ */
+export * from './async-hooks';

package/dist/types/types/index.d.ts

@@ -0,0 +1,34 @@
+import type { NodeType } from '../constants';
+import type { ElementInfo } from '../extractor';
+export interface Point {
+    left: number;
+    top: number;
+}
+export interface Size {
+    width: number;
+    height: number;
+}
+export type Rect = Point & Size;
+export declare abstract class BaseElement {
+    abstract id: string;
+    abstract attributes: {
+        nodeType: NodeType;
+        [key: string]: string;
+    };
+    abstract content: string;
+    abstract rect: Rect;
+    abstract center: [number, number];
+    abstract isVisible: boolean;
+}
+export interface ElementTreeNode<ElementType extends BaseElement = BaseElement> {
+    node: ElementType | null;
+    children: ElementTreeNode<ElementType>[];
+}
+export interface WebElementInfo extends ElementInfo {
+    zoom: number;
+}
+export type LocateResultElement = {
+    description: string;
+    center: [number, number];
+    rect: Rect;
+};

package/dist/types/us-keyboard-layout.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @internal
+ */
+export interface KeyDefinition {
+    keyCode?: number;
+    shiftKeyCode?: number;
+    key?: string;
+    shiftKey?: string;
+    code?: string;
+    text?: string;
+    shiftText?: string;
+    location?: number;
+}
+/**
+ * All the valid keys that can be passed to functions that take user input, such
+ * as {@link Keyboard.press | keyboard.press }
+ *
+ * @public
+ */
+export type KeyInput = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'Power' | 'Eject' | 'Abort' | 'Help' | 'Backspace' | 'Tab' | 'Numpad5' | 'NumpadEnter' | 'Enter' | '\r' | '\n' | 'ShiftLeft' | 'ShiftRight' | 'ControlLeft' | 'ControlRight' | 'AltLeft' | 'AltRight' | 'Pause' | 'CapsLock' | 'Escape' | 'Convert' | 'NonConvert' | 'Space' | 'Numpad9' | 'PageUp' | 'Numpad3' | 'PageDown' | 'End' | 'Numpad1' | 'Home' | 'Numpad7' | 'ArrowLeft' | 'Numpad4' | 'Numpad8' | 'ArrowUp' | 'ArrowRight' | 'Numpad6' | 'Numpad2' | 'ArrowDown' | 'Select' | 'Open' | 'PrintScreen' | 'Insert' | 'Numpad0' | 'Delete' | 'NumpadDecimal' | 'Digit0' | 'Digit1' | 'Digit2' | 'Digit3' | 'Digit4' | 'Digit5' | 'Digit6' | 'Digit7' | 'Digit8' | 'Digit9' | 'KeyA' | 'KeyB' | 'KeyC' | 'KeyD' | 'KeyE' | 'KeyF' | 'KeyG' | 'KeyH' | 'KeyI' | 'KeyJ' | 'KeyK' | 'KeyL' | 'KeyM' | 'KeyN' | 'KeyO' | 'KeyP' | 'KeyQ' | 'KeyR' | 'KeyS' | 'KeyT' | 'KeyU' | 'KeyV' | 'KeyW' | 'KeyX' | 'KeyY' | 'KeyZ' | 'MetaLeft' | 'MetaRight' | 'ContextMenu' | 'NumpadMultiply' | 'NumpadAdd' | 'NumpadSubtract' | 'NumpadDivide' | 'F1' | 'F2' | 'F3' | 'F4' | 'F5' | 'F6' | 'F7' | 'F8' | 'F9' | 'F10' | 'F11' | 'F12' | 'F13' | 'F14' | 'F15' | 'F16' | 'F17' | 'F18' | 'F19' | 'F20' | 'F21' | 'F22' | 'F23' | 'F24' | 'NumLock' | 'ScrollLock' | 'AudioVolumeMute' | 'AudioVolumeDown' | 'AudioVolumeUp' | 'MediaTrackNext' | 'MediaTrackPrevious' | 'MediaStop' | 'MediaPlayPause' | 'Semicolon' | 'Equal' | 'NumpadEqual' | 'Comma' | 'Minus' | 'Period' | 'Slash' | 'Backquote' | 'BracketLeft' | 'Backslash' | 'BracketRight' | 'Quote' | 'AltGraph' | 'Props' | 'Cancel' | 'Clear' | 'Shift' | 'Control' | 'Alt' | 'Accept' | 'ModeChange' | ' ' | 'Print' | 'Execute' | '\u0000' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | 'Meta' | '*' | '+' | '-' | '/' | ';' | '=' | ',' | '.' | '`' | '[' | '\\' | ']' | "'" | 'Attn' | 'CrSel' | 'ExSel' | 'EraseEof' | 'Play' | 'ZoomOut' | ')' | '!' | '@' | '#' | '$' | '%' | '^' | '&' | '(' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | ':' | '<' | '_' | '>' | '?' | '~' | '{' | '|' | '}' | '"' | 'SoftLeft' | 'SoftRight' | 'Camera' | 'Call' | 'EndCall' | 'VolumeDown' | 'VolumeUp';
+/**
+ * @internal
+ */
+export declare const _keyDefinitions: Readonly<Record<KeyInput, KeyDefinition>>;
+export declare const getKeyDefinition: (key: string) => KeyInput;
+export declare const isMac: boolean;
+export declare function transformHotkeyInput(keyInput: string): string[];

package/dist/types/utils.d.ts

@@ -0,0 +1,37 @@
+export declare const ifInBrowser: boolean;
+export declare const ifInWorker: boolean;
+export declare const ifInNode: string | false;
+export declare function uuid(): string;
+export declare function generateHashId(rect: any, content?: string): string;
+/**
+ * A utility function that asserts a condition and throws an error with a message if the condition is false.
+ *
+ * @param condition - The condition to assert
+ * @param message - The error message to throw if the condition is false
+ * @throws Error with the provided message if the condition is false
+ */
+export declare function assert(condition: any, message?: string): asserts condition;
+type GlobalScope = typeof window | typeof globalThis | typeof self | undefined;
+export declare function getGlobalScope(): GlobalScope;
+export declare function setIsMcp(value: boolean): void;
+export declare function logMsg(...message: Parameters<typeof console.log>): void;
+export declare function repeat(times: number, fn: (index: number) => Promise<void>): Promise<void>;
+export declare const escapeScriptTag: (html: string) => string;
+export declare const antiEscapeScriptTag: (html: string) => string;
+export declare function replaceIllegalPathCharsAndSpace(str: string): string;
+/**
+ * Check if a value is a plain object (not null, not array, not other types)
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, any>;
+/**
+ * Normalize string for comparison: lowercase and remove spaces, dashes, and underscores.
+ * Useful for flexible app name matching.
+ */
+export declare function normalizeForComparison(str: string): string;
+/**
+ * Merge and normalize app name mappings.
+ * Keys are normalized (lowercase, no spaces/dashes/underscores) for flexible matching.
+ * User-provided mapping takes precedence over default mapping.
+ */
+export declare function mergeAndNormalizeAppNameMapping(defaultMapping: Record<string, string>, userMapping?: Record<string, string>): Record<string, string>;
+export {};

package/dist/types/zod-schema-utils.d.ts

@@ -0,0 +1,23 @@
+import type { z } from 'zod';
+/**
+ * Recursively unwrap optional, nullable, default, and effects wrapper types
+ * to get the actual inner Zod type
+ */
+export declare function unwrapZodField(field: unknown): unknown;
+/**
+ * Check if a field is a Midscene locator field
+ * Checks for either:
+ * 1. midscene_location_field_flag in shape (result schema)
+ * 2. prompt field in shape (input schema)
+ */
+export declare function isMidsceneLocatorField(field: unknown): boolean;
+/**
+ * Get type name string from a Zod schema field
+ * @param field - Zod schema field
+ * @param locatorTypeDescription - Optional description for MidsceneLocation fields (used by core)
+ */
+export declare function getZodTypeName(field: unknown, locatorTypeDescription?: string): string;
+/**
+ * Get description from a Zod schema field
+ */
+export declare function getZodDescription(field: z.ZodTypeAny): string | null;

package/package.json

@@ -0,0 +1,121 @@
+{
+  "name": "@aiscene/shared",
+  "version": "1.6.0",
+  "repository": "https://github.com/web-infra-dev/midscene",
+  "homepage": "https://midscenejs.com/",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/lib/index.js",
+  "module": "./dist/es/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/es/index.mjs",
+      "require": "./dist/lib/index.js"
+    },
+    "./constants": {
+      "types": "./dist/types/constants/index.d.ts",
+      "import": "./dist/es/constants/index.mjs",
+      "require": "./dist/lib/constants/index.js"
+    },
+    "./extractor": {
+      "types": "./dist/types/extractor/index.d.ts",
+      "import": "./dist/es/extractor/index.mjs",
+      "require": "./dist/lib/extractor/index.js"
+    },
+    "./img": {
+      "types": "./dist/types/img/index.d.ts",
+      "import": "./dist/es/img/index.mjs",
+      "require": "./dist/lib/img/index.js"
+    },
+    "./node": {
+      "types": "./dist/types/node/index.d.ts",
+      "import": "./dist/es/node/index.mjs",
+      "require": "./dist/lib/node/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/types/index.d.ts",
+      "import": "./dist/es/types/index.mjs",
+      "require": "./dist/lib/types/index.js"
+    },
+    "./env": {
+      "types": "./dist/types/env/index.d.ts",
+      "import": "./dist/es/env/index.mjs",
+      "require": "./dist/lib/env/index.js"
+    },
+    "./polyfills": {
+      "types": "./dist/types/polyfills/index.d.ts",
+      "import": "./dist/es/polyfills/index.mjs",
+      "require": "./dist/lib/polyfills/index.js"
+    },
+    "./utils": {
+      "types": "./dist/types/utils.d.ts",
+      "import": "./dist/es/utils.mjs",
+      "require": "./dist/lib/utils.js"
+    },
+    "./common": {
+      "types": "./dist/types/common.d.ts",
+      "import": "./dist/es/common.mjs",
+      "require": "./dist/lib/common.js"
+    },
+    "./mcp": {
+      "types": "./dist/types/mcp/index.d.ts",
+      "import": "./dist/es/mcp/index.mjs",
+      "require": "./dist/lib/mcp/index.js"
+    },
+    "./cli": {
+      "types": "./dist/types/cli/index.d.ts",
+      "import": "./dist/es/cli/index.mjs",
+      "require": "./dist/lib/cli/index.js"
+    },
+    "./logger": {
+      "types": "./dist/types/logger.d.ts",
+      "import": "./dist/es/logger.mjs",
+      "require": "./dist/lib/logger.js"
+    },
+    "./*": {
+      "types": "./dist/types/*.d.ts",
+      "import": "./dist/es/*.mjs",
+      "require": "./dist/lib/*.js"
+    }
+  },
+  "files": ["dist", "src", "README.md"],
+  "scripts": {
+    "dev": "npm run build:watch",
+    "build": "npm run build:script && npm run build:pkg",
+    "build:pkg": "rslib build",
+    "build:script": "rslib build -c ./rslib.inspect.config.ts",
+    "build:watch": "npm run build:script && rslib build --watch --no-clean",
+    "reset": "rimraf ./**/node_modules",
+    "test": "vitest --run",
+    "test:u": "vitest --run -u"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.10.2",
+    "@silvia-odwyer/photon": "0.3.3",
+    "@silvia-odwyer/photon-node": "0.3.3",
+    "debug": "4.4.0",
+    "express": "^4.21.2",
+    "js-sha256": "0.11.0",
+    "sharp": "^0.34.3",
+    "dotenv": "^16.4.5",
+    "uuid": "11.1.0",
+    "zod": "3.24.3"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.18.3",
+    "@types/debug": "4.1.12",
+    "@types/express": "^4.17.21",
+    "@types/node": "^18.0.0",
+    "@ui-tars/shared": "1.2.0",
+    "openai": "6.3.0",
+    "rimraf": "~3.0.2",
+    "typescript": "^5.8.3",
+    "vitest": "3.0.5"
+  },
+  "sideEffects": [],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "MIT"
+}

package/src/baseDB.ts

@@ -0,0 +1,158 @@
+// Generic database operations class
+export class IndexedDBManager {
+  private dbPromise: Promise<IDBDatabase>;
+  private dbName: string;
+  private version: number;
+  private storeConfigs: Array<{ name: string; keyPath: string }>;
+
+  constructor(
+    dbName: string,
+    version: number,
+    storeConfigs: Array<{ name: string; keyPath: string }>,
+  ) {
+    this.dbName = dbName;
+    this.version = version;
+    this.storeConfigs = storeConfigs;
+    this.dbPromise = this.initDB();
+  }
+
+  private initDB(): Promise<IDBDatabase> {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.version);
+
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+
+      request.onupgradeneeded = (event) => {
+        const db = (event.target as IDBOpenDBRequest).result;
+
+        // Create stores if they don't exist
+        this.storeConfigs.forEach(({ name, keyPath }) => {
+          if (!db.objectStoreNames.contains(name)) {
+            const store = db.createObjectStore(name, { keyPath });
+            store.createIndex('timestamp', 'timestamp', { unique: false });
+          }
+        });
+      };
+    });
+  }
+
+  private async withTransaction<T>(
+    storeNames: string | string[],
+    mode: IDBTransactionMode,
+    operation: (stores: IDBObjectStore | IDBObjectStore[]) => Promise<T>,
+  ): Promise<T> {
+    const db = await this.dbPromise;
+    const transaction = db.transaction(storeNames, mode);
+
+    const stores = Array.isArray(storeNames)
+      ? storeNames.map((name) => transaction.objectStore(name))
+      : transaction.objectStore(storeNames);
+
+    return operation(stores);
+  }
+
+  private promisifyRequest<T>(request: IDBRequest<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async put<T>(storeName: string, data: T): Promise<void> {
+    await this.withTransaction(storeName, 'readwrite', async (store) => {
+      await this.promisifyRequest((store as IDBObjectStore).put(data));
+    });
+  }
+
+  async get<T>(storeName: string, key: string): Promise<T | undefined> {
+    return this.withTransaction(storeName, 'readonly', async (store) => {
+      return this.promisifyRequest((store as IDBObjectStore).get(key));
+    });
+  }
+
+  async getAll<T>(storeName: string, sortByTimestamp = true): Promise<T[]> {
+    return this.withTransaction(storeName, 'readonly', async (store) => {
+      const objectStore = store as IDBObjectStore;
+      const results = sortByTimestamp
+        ? await this.promisifyRequest(objectStore.index('timestamp').getAll())
+        : await this.promisifyRequest(objectStore.getAll());
+
+      return sortByTimestamp
+        ? results.sort((a: any, b: any) => a.timestamp - b.timestamp)
+        : results;
+    });
+  }
+
+  async clear(storeName: string): Promise<void> {
+    await this.withTransaction(storeName, 'readwrite', async (store) => {
+      await this.promisifyRequest((store as IDBObjectStore).clear());
+    });
+  }
+
+  async delete(storeName: string, key: string): Promise<void> {
+    await this.withTransaction(storeName, 'readwrite', async (store) => {
+      await this.promisifyRequest((store as IDBObjectStore).delete(key));
+    });
+  }
+
+  async count(storeName: string): Promise<number> {
+    return this.withTransaction(storeName, 'readonly', async (store) => {
+      return this.promisifyRequest((store as IDBObjectStore).count());
+    });
+  }
+
+  getDBPromise(): Promise<IDBDatabase> {
+    return this.dbPromise;
+  }
+}
+
+// Generic error handler wrapper
+export const withErrorHandling = async <T>(
+  operation: () => Promise<T>,
+  errorMessage: string,
+  defaultValue?: T,
+  onQuotaExceeded?: () => Promise<void>,
+): Promise<T | undefined> => {
+  try {
+    return await operation();
+  } catch (e) {
+    console.error(errorMessage, e);
+    if (
+      e instanceof Error &&
+      e.name === 'QuotaExceededError' &&
+      onQuotaExceeded
+    ) {
+      console.log('Storage quota exceeded, running cleanup...');
+      await onQuotaExceeded();
+    }
+    return defaultValue;
+  }
+};
+
+// Base cleanup function for managing storage space
+export const createCleanupFunction = <
+  T extends { id: string; timestamp: number },
+>(
+  dbManager: IndexedDBManager,
+  storeName: string,
+  maxItems: number,
+) => {
+  return async (): Promise<void> => {
+    try {
+      const results = await dbManager.getAll<T>(storeName);
+
+      if (results.length > maxItems) {
+        const toDelete = results
+          .sort((a, b) => a.timestamp - b.timestamp)
+          .slice(0, results.length - maxItems);
+
+        await Promise.all(
+          toDelete.map((item) => dbManager.delete(storeName, item.id)),
+        );
+      }
+    } catch (e) {
+      console.error(`Failed to cleanup ${storeName}:`, e);
+    }
+  };
+};

package/src/build/copy-static.ts

@@ -0,0 +1,68 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export interface CopyStaticOptions {
+  /** Source directory to copy from */
+  srcDir: string;
+  /** Destination directory to copy to */
+  destDir: string;
+  /** Optional favicon source path (relative to directory containing srcDir) */
+  faviconPath?: string;
+  /** Name for the rsbuild plugin */
+  pluginName?: string;
+}
+
+/**
+ * Creates an rsbuild plugin that copies static files after build
+ * @param options Configuration options for copying static files
+ * @returns Rsbuild plugin object
+ */
+export const createCopyStaticPlugin = (options: CopyStaticOptions) => ({
+  name: options.pluginName || 'copy-static',
+  setup(api: any) {
+    api.onAfterBuild(async () => {
+      const { srcDir, destDir, faviconPath } = options;
+
+      // Remove symlink left by dev mode before copying
+      const stat = await fs.promises.lstat(destDir).catch(() => null);
+      if (stat?.isSymbolicLink()) {
+        await fs.promises.unlink(destDir);
+      }
+
+      await fs.promises.mkdir(destDir, { recursive: true });
+
+      // Copy directory contents recursively
+      await fs.promises.cp(srcDir, destDir, { recursive: true });
+      console.log(`Copied build artifacts from ${srcDir} to ${destDir}`);
+
+      // Copy favicon if specified
+      if (faviconPath) {
+        const faviconDest = path.join(destDir, 'favicon.ico');
+        await fs.promises.copyFile(faviconPath, faviconDest);
+        console.log(`Copied favicon from ${faviconPath} to ${faviconDest}`);
+      }
+    });
+  },
+});
+
+/**
+ * Helper function to create a copy static plugin for playground builds
+ * @param srcDir Source directory (usually dist directory)
+ * @param destDir Destination directory
+ * @param pluginName Optional plugin name
+ * @param faviconSrc Optional favicon source path
+ * @returns Rsbuild plugin
+ */
+export const createPlaygroundCopyPlugin = (
+  srcDir: string,
+  destDir: string,
+  pluginName?: string,
+  faviconSrc?: string,
+) => {
+  return createCopyStaticPlugin({
+    srcDir,
+    destDir,
+    faviconPath: faviconSrc,
+    pluginName,
+  });
+};

package/src/build/rspack-config.ts

@@ -0,0 +1,12 @@
+/**
+ * Common Rspack configuration helpers for rsbuild projects
+ */
+
+/**
+ * Common warning patterns to ignore in Rspack builds.
+ * These warnings are typically from optional dependencies or known non-critical issues.
+ */
+export const commonIgnoreWarnings = [
+  // Ignore dynamic import warnings from langsmith/langfuse optional dependencies
+  /Critical dependency: the request of a dependency is an expression/,
+];