mulby-cli 1.1.5

package/dist/commands/create/templates/react.js

@@ -0,0 +1,1888 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildReactManifest = buildReactManifest;
+exports.buildReactPackageJson = buildReactPackageJson;
+exports.buildTsConfig = buildTsConfig;
+exports.buildViteConfig = buildViteConfig;
+exports.buildPostcssConfig = buildPostcssConfig;
+exports.buildTailwindConfig = buildTailwindConfig;
+exports.buildBackendMain = buildBackendMain;
+exports.buildIndexHtml = buildIndexHtml;
+exports.buildMainTsx = buildMainTsx;
+exports.buildAppTsx = buildAppTsx;
+exports.buildStylesCss = buildStylesCss;
+exports.buildUseIntools = buildUseIntools;
+exports.buildGitignore = buildGitignore;
+exports.buildReactReadme = buildReactReadme;
+exports.buildIntoolsTypes = buildIntoolsTypes;
+function buildReactManifest(name) {
+    return {
+        id: name,
+        name,
+        version: '1.0.0',
+        author: 'intools',
+        displayName: name,
+        description: '插件描述',
+        main: 'dist/main.js',
+        ui: 'ui/index.html',
+        icon: 'icon.png',
+        window: {
+            width: 800, // 默认宽度
+            height: 600, // 默认高度
+            minWidth: 400, // 最小宽度
+            minHeight: 300, // 最小高度
+            maxWidth: 1200, // 最大宽度
+            maxHeight: 900 // 最大高度
+        },
+        features: [
+            {
+                code: 'main',
+                explain: '主功能',
+                cmds: [{ type: 'keyword', value: name }]
+            }
+        ]
+    };
+}
+function buildReactPackageJson(name) {
+    return {
+        name,
+        version: '1.0.0',
+        type: 'module',
+        scripts: {
+            dev: 'intools dev',
+            build: 'npm run build:backend && npm run build:ui',
+            'build:backend': 'esbuild src/main.ts --bundle --platform=node --outfile=dist/main.js',
+            'build:ui': 'vite build',
+            pack: 'intools pack'
+        },
+        dependencies: {
+            react: '^18.3.1',
+            'react-dom': '^18.3.1',
+            'lucide-react': '^0.562.0'
+        },
+        devDependencies: {
+            '@types/react': '^18.3.3',
+            '@types/react-dom': '^18.3.0',
+            '@vitejs/plugin-react': '^4.3.1',
+            autoprefixer: '^10.4.19',
+            postcss: '^8.4.38',
+            tailwindcss: '^3.4.4',
+            typescript: '^5.2.2',
+            vite: '^5.3.1'
+        }
+    };
+}
+function buildTsConfig() {
+    return {
+        compilerOptions: {
+            target: 'ES2020',
+            useDefineForClassFields: true,
+            lib: ['ES2020', 'DOM', 'DOM.Iterable'],
+            module: 'ESNext',
+            skipLibCheck: true,
+            moduleResolution: 'bundler',
+            allowImportingTsExtensions: true,
+            resolveJsonModule: true,
+            isolatedModules: true,
+            noEmit: true,
+            jsx: 'react-jsx',
+            strict: true,
+            noUnusedLocals: true,
+            noUnusedParameters: true,
+            noFallthroughCasesInSwitch: true
+        },
+        include: ['src']
+    };
+}
+function buildViteConfig() {
+    return `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import path from 'path'
+
+export default defineConfig({
+  plugins: [react()],
+  root: 'src/ui',
+  base: './',
+  build: {
+    outDir: '../../ui',
+    emptyOutDir: true
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, 'src')
+    }
+  }
+})
+`;
+}
+function buildPostcssConfig() {
+    return `export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}
+`;
+}
+function buildTailwindConfig() {
+    return `/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./src/ui/index.html",
+    "./src/ui/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
+`;
+}
+function buildBackendMain(name) {
+    return `interface PluginContext {
+  api: {
+    clipboard: {
+      readText: () => string
+      writeText: (text: string) => Promise<void>
+      readImage: () => ArrayBuffer | null
+      getFormat: () => string
+    }
+    clipboardHistory: {
+      query: (options?: {
+        type?: 'text' | 'image' | 'files'
+        search?: string
+        favorite?: boolean
+        limit?: number
+        offset?: number
+      }) => Promise<any[]>
+      get: (id: string) => Promise<any>
+      copy: (id: string) => Promise<{ success: boolean; error?: string }>
+      toggleFavorite: (id: string) => Promise<{ success: boolean }>
+      delete: (id: string) => Promise<{ success: boolean }>
+      clear: () => Promise<{ success: boolean }>
+      stats: () => Promise<{ total: number; text: number; image: number; files: number; favorite: number }>
+    }
+    notification: {
+      show: (message: string, type?: string) => void
+    }
+    messaging: {
+      send: (targetPluginId: string, type: string, payload: unknown) => Promise<void>
+      broadcast: (type: string, payload: unknown) => Promise<void>
+      on: (handler: (message: { id: string; from: string; to?: string; type: string; payload: unknown; timestamp: number }) => void | Promise<void>) => void
+      off: (handler?: (message: any) => void) => void
+    }
+    scheduler: {
+      schedule: (task: {
+        name: string
+        type: 'once' | 'repeat' | 'delay'
+        callback: string
+        time?: number
+        cron?: string
+        delay?: number
+        payload?: any
+        maxRetries?: number
+        retryDelay?: number
+        timeout?: number
+      }) => Promise<any>
+      cancelTask: (taskId: string) => Promise<void>
+      pauseTask: (taskId: string) => Promise<void>
+      resumeTask: (taskId: string) => Promise<void>
+      listTasks: (filter?: { status?: string; type?: string; limit?: number; offset?: number }) => Promise<any[]>
+      getTaskCount: (filter?: { status?: string; type?: string }) => Promise<number>
+      getTask: (taskId: string) => Promise<any>
+      deleteTasks: (taskIds: string[]) => Promise<{ success: boolean; deletedCount: number }>
+      cleanupTasks: (olderThan?: number) => Promise<{ success: boolean; deletedCount: number }>
+      getExecutions: (taskId: string, limit?: number) => Promise<any[]>
+      validateCron: (expression: string) => boolean
+      getNextCronTime: (expression: string, after?: Date) => Date
+      describeCron: (expression: string) => string
+    }
+    ai: {
+      call: (option: {
+        model?: string
+        messages: Array<{ role: 'system' | 'user' | 'assistant'; content?: string | Array<any> }>
+        tools?: Array<{ type: 'function'; function: { name: string; description?: string; parameters?: object } }>
+        params?: any
+      }, onChunk?: (chunk: any) => void) => Promise<{ role: 'assistant'; content?: string }>
+      allModels: () => Promise<any[]>
+      tokens: {
+        estimate: (input: { model?: string; messages: Array<any> }) => Promise<{ inputTokens: number; outputTokens: number }>
+      }
+      attachments: {
+        upload: (input: { filePath?: string; buffer?: ArrayBuffer; mimeType: string; purpose?: string }) => Promise<any>
+        get: (attachmentId: string) => Promise<any>
+        delete: (attachmentId: string) => Promise<void>
+      }
+      images: {
+        generate: (input: { model: string; prompt: string; size?: string; count?: number }) => Promise<{ images: string[] }>
+        edit: (input: { model: string; imageAttachmentId: string; prompt: string }) => Promise<{ images: string[] }>
+      }
+      videos: {
+        generate: (input: { model: string; prompt: string; duration?: number; size?: string }) => Promise<void>
+      }
+    }
+    features?: {
+      getFeatures: (codes?: string[]) => Array<{ code: string }>
+      setFeature: (feature: {
+        code: string
+        explain?: string
+        icon?: string
+        platform?: string | string[]
+        mode?: 'ui' | 'silent' | 'detached'
+        route?: string
+        mainHide?: boolean
+        mainPush?: boolean
+        cmds: Array<
+          | string
+          | { type: 'keyword'; value: string; explain?: string }
+          | { type: 'regex'; match: string; explain?: string; label?: string; minLength?: number; maxLength?: number }
+          | { type: 'files'; exts?: string[]; fileType?: 'file' | 'directory' | 'any'; match?: string; minLength?: number; maxLength?: number }
+          | { type: 'img'; exts?: string[] }
+          | { type: 'over'; label?: string; exclude?: string; minLength?: number; maxLength?: number }
+        >
+      }) => void
+      removeFeature: (code: string) => boolean
+      redirectHotKeySetting: (cmdLabel: string, autocopy?: boolean) => void
+      redirectAiModelsSetting: () => void
+    }
+  }
+  input?: string
+  featureCode?: string
+}
+
+export function onLoad() {
+  console.log('[${name}] 插件已加载')
+}
+
+export function onUnload() {
+  console.log('[${name}] 插件已卸载')
+}
+
+export function onEnable() {
+  console.log('[${name}] 插件已启用')
+}
+
+export function onDisable() {
+  console.log('[${name}] 插件已禁用')
+}
+
+export async function run(context: PluginContext) {
+  const { notification } = context.api
+  notification.show('插件已启动')
+}
+
+// 导出 host 方法供 UI 调用
+// 支持三种导出方式（按优先级）：
+// 1. 直接导出函数: export async function myMethod(context, ...args) {}
+// 2. host 对象（推荐）: export const host = { myMethod(context, ...args) {} }
+// 3. 其他对象: export const api = { myMethod(context, ...args) {} }
+
+export const host = {
+  // 示例方法：处理数据
+  async processData(context: PluginContext, data: any) {
+    const { notification } = context.api
+    notification.show('处理数据中...')
+
+    // 处理逻辑
+    const result = {
+      ...data,
+      processed: true,
+      timestamp: Date.now()
+    }
+
+    return result
+  },
+
+  // 示例方法：获取配置
+  async getConfig(context: PluginContext) {
+    // 可以使用 context.api 中的所有 API
+    return {
+      version: '1.0.0',
+      settings: {}
+    }
+  }
+}
+
+const plugin = { onLoad, onUnload, onEnable, onDisable, run, host }
+export default plugin
+`;
+}
+function buildIndexHtml(name) {
+    return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${name}</title>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="./main.tsx"></script>
+</body>
+</html>
+`;
+}
+function buildMainTsx() {
+    return `import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import App from './App'
+import './styles.css'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>
+)
+`;
+}
+function buildAppTsx(name) {
+    return `import { useEffect, useState } from 'react'
+import { FileText, Image } from 'lucide-react'
+import { useIntools } from './hooks/useIntools'
+
+// 附件类型定义
+interface Attachment {
+  id: string
+  name: string
+  size: number
+  kind: 'file' | 'image'
+  mime?: string
+  ext?: string
+  path?: string
+  dataUrl?: string
+}
+
+interface PluginInitData {
+  pluginName: string
+  featureCode: string
+  input: string
+  mode?: string
+  route?: string
+  attachments?: Attachment[]
+}
+
+export default function App() {
+  const [input, setInput] = useState('')
+  const [output, setOutput] = useState('')
+  const [theme, setTheme] = useState<'light' | 'dark'>('light')
+  const [attachments, setAttachments] = useState<Attachment[]>([])
+  const { clipboard, notification, host } = useIntools('${name}')
+
+  useEffect(() => {
+    // 获取初始主题（从 URL 参数）
+    const params = new URLSearchParams(window.location.search)
+    const initialTheme = (params.get('theme') as 'light' | 'dark') || 'light'
+    setTheme(initialTheme)
+    document.documentElement.classList.toggle('dark', initialTheme === 'dark')
+
+    // 监听主题变化
+    window.intools?.onThemeChange?.((newTheme: 'light' | 'dark') => {
+      setTheme(newTheme)
+      document.documentElement.classList.toggle('dark', newTheme === 'dark')
+    })
+
+    // 接收插件初始化数据
+    window.intools?.onPluginInit?.((data: PluginInitData) => {
+      if (data.input) {
+        setInput(data.input)
+      }
+      // 接收附件数据
+      if (data.attachments) {
+        setAttachments(data.attachments)
+      }
+    })
+  }, [])
+
+  const handleProcess = async () => {
+    // 示例：将输入转为大写
+    const result = input.toUpperCase()
+    setOutput(result)
+
+    // 复制到剪贴板并通知
+    await clipboard.writeText(result)
+    notification.show('已复制到剪贴板')
+  }
+
+  // 示例：调用后端 host 方法
+  const handleCallHost = async () => {
+    try {
+      const result = await host.call('processData', { value: input })
+      console.log('Host返回:', result.data)
+      notification.show('后端处理成功')
+    } catch (err: any) {
+      notification.show(\`错误: \${err.message}\`, 'error')
+    }
+  }
+
+  // 格式化文件大小
+  const formatSize = (bytes: number) => {
+    if (bytes < 1024) return \`\${bytes} B\`
+    if (bytes < 1024 * 1024) return \`\${(bytes / 1024).toFixed(1)} KB\`
+    return \`\${(bytes / 1024 / 1024).toFixed(1)} MB\`
+  }
+
+  return (
+    <div className="app">
+
+      <div className="container">
+        {/* 附件展示区域 */}
+        {attachments.length > 0 && (
+          <div className="field">
+            <label>附件 ({attachments.length})</label>
+            <div className="attachments-list">
+              {attachments.map((item, index) => (
+                <div key={item.id || index} className="attachment-item">
+                  <span className="attachment-icon">
+                    {item.kind === 'image' ? <Image size={20} /> : <FileText size={20} />}
+                  </span>
+                  <div className="attachment-info">
+                    <div className="attachment-name">{item.name}</div>
+                    <div className="attachment-meta">{formatSize(item.size)}</div>
+                  </div>
+                  {item.kind === 'image' && (item.dataUrl || item.path) && (
+                    <img
+                      src={item.dataUrl || \`file://\${item.path}\`}
+                      alt={item.name}
+                      className="attachment-preview"
+                    />
+                  )}
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        <div className="field">
+          <label>输入</label>
+          <textarea
+            value={input}
+            onChange={(e) => setInput(e.target.value)}
+            placeholder="请输入内容..."
+          />
+        </div>
+        <div className="actions">
+          <button className="btn-primary" onClick={handleProcess}>
+            处理
+          </button>
+          <button className="btn-secondary" onClick={handleCallHost}>
+            调用后端
+          </button>
+        </div>
+        <div className="field">
+          <label>输出</label>
+          <textarea
+            value={output}
+            readOnly
+            placeholder="结果将显示在这里..."
+          />
+        </div>
+      </div>
+    </div>
+  )
+}
+`;
+}
+function buildStylesCss() {
+    return `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+/* CSS 变量 - 亮色主题 */
+:root {
+  --bg-primary: #ffffff;
+  --bg-secondary: #f5f5f5;
+  --bg-tertiary: #ebebeb;
+  --text-primary: #1e1e1e;
+  --text-secondary: #666666;
+  --text-tertiary: #999999;
+  --border-color: #e0e0e0;
+  --accent-color: #0078d4;
+  --accent-hover: #1084d8;
+}
+
+/* CSS 变量 - 暗色主题 */
+:root.dark {
+  --bg-primary: #1e1e1e;
+  --bg-secondary: #2d2d2d;
+  --bg-tertiary: #3d3d3d;
+  --text-primary: #e0e0e0;
+  --text-secondary: #999999;
+  --text-tertiary: #666666;
+  --border-color: #3d3d3d;
+  --accent-color: #0078d4;
+  --accent-hover: #1084d8;
+}
+
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  min-height: 100vh;
+  transition: background-color 0.2s, color 0.2s;
+}
+
+.app {
+  display: flex;
+  flex-direction: column;
+  height: 100vh;
+}
+
+
+
+.container {
+  flex: 1;
+  padding: 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  overflow: auto;
+}
+
+.field {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  flex: 1;
+  min-height: 0;
+}
+
+.field label {
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+.field textarea {
+  flex: 1;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border-color);
+  border-radius: 6px;
+  padding: 12px;
+  color: var(--text-primary);
+  font-family: 'Monaco', 'Consolas', monospace;
+  font-size: 13px;
+  resize: none;
+  outline: none;
+  min-height: 80px;
+  transition: background-color 0.2s, border-color 0.2s, color 0.2s;
+}
+
+.field textarea:focus {
+  border-color: var(--accent-color);
+}
+
+.field textarea::placeholder {
+  color: var(--text-tertiary);
+}
+
+.actions {
+  display: flex;
+  gap: 12px;
+  justify-content: center;
+}
+
+button {
+  padding: 8px 24px;
+  border: none;
+  border-radius: 4px;
+  font-size: 14px;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.btn-primary {
+  background: var(--accent-color);
+  color: #fff;
+}
+
+.btn-primary:hover {
+  background: var(--accent-hover);
+}
+
+.btn-secondary {
+  background: var(--bg-tertiary);
+  color: var(--text-primary);
+}
+
+.btn-secondary:hover {
+  background: var(--bg-secondary);
+}
+
+/* 附件列表样式 */
+.attachments-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  max-height: 200px;
+  overflow-y: auto;
+}
+
+.attachment-item {
+  display: flex;
+  align-items: center;
+  padding: 10px 12px;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border-color);
+  border-radius: 6px;
+  gap: 10px;
+}
+
+.attachment-icon {
+  font-size: 20px;
+}
+
+.attachment-info {
+  flex: 1;
+  min-width: 0;
+}
+
+.attachment-name {
+  font-size: 13px;
+  font-weight: 500;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.attachment-meta {
+  font-size: 11px;
+  color: var(--text-tertiary);
+  margin-top: 2px;
+}
+
+.attachment-preview {
+  width: 40px;
+  height: 40px;
+  border-radius: 4px;
+  object-fit: cover;
+}
+`;
+}
+function buildUseIntools() {
+    return `import { useMemo } from 'react'
+
+export function useIntools(pluginId?: string) {
+  return useMemo(() => ({
+    // Clipboard API
+    clipboard: {
+      readText: () => window.intools?.clipboard?.readText(),
+      writeText: (text: string) => window.intools?.clipboard?.writeText(text),
+      readImage: () => window.intools?.clipboard?.readImage(),
+      writeImage: (image: string | ArrayBuffer) => window.intools?.clipboard?.writeImage(image),
+      readFiles: () => window.intools?.clipboard?.readFiles(),
+      writeFiles: (files: string | string[]) => window.intools?.clipboard?.writeFiles(files),
+      getFormat: () => window.intools?.clipboard?.getFormat(),
+    },
+
+    // Clipboard History API
+    clipboardHistory: {
+      query: (options?: {
+        type?: 'text' | 'image' | 'files'
+        search?: string
+        favorite?: boolean
+        limit?: number
+        offset?: number
+      }) => window.intools?.clipboardHistory?.query(options),
+      get: (id: string) => window.intools?.clipboardHistory?.get(id),
+      copy: (id: string) => window.intools?.clipboardHistory?.copy(id),
+      toggleFavorite: (id: string) => window.intools?.clipboardHistory?.toggleFavorite(id),
+      delete: (id: string) => window.intools?.clipboardHistory?.delete(id),
+      clear: () => window.intools?.clipboardHistory?.clear(),
+      stats: () => window.intools?.clipboardHistory?.stats(),
+    },
+
+    // Input API
+    input: {
+      hideMainWindowPasteText: (text: string) => window.intools?.input?.hideMainWindowPasteText(text),
+      hideMainWindowPasteImage: (image: string | ArrayBuffer) => window.intools?.input?.hideMainWindowPasteImage(image),
+      hideMainWindowPasteFile: (filePaths: string | string[]) => window.intools?.input?.hideMainWindowPasteFile(filePaths),
+      hideMainWindowTypeString: (text: string) => window.intools?.input?.hideMainWindowTypeString(text),
+      restoreWindows: () => window.intools?.input?.restoreWindows(),
+      simulateKeyboardTap: (key: string, ...modifiers: string[]) =>
+        window.intools?.input?.simulateKeyboardTap(key, ...modifiers),
+      simulateMouseMove: (x: number, y: number) => window.intools?.input?.simulateMouseMove(x, y),
+      simulateMouseClick: (x: number, y: number) => window.intools?.input?.simulateMouseClick(x, y),
+      simulateMouseDoubleClick: (x: number, y: number) => window.intools?.input?.simulateMouseDoubleClick(x, y),
+      simulateMouseRightClick: (x: number, y: number) => window.intools?.input?.simulateMouseRightClick(x, y),
+    },
+
+    // Storage API
+    storage: {
+      get: (key: string) => window.intools?.storage?.get(key, pluginId),
+      set: (key: string, value: unknown) => window.intools?.storage?.set(key, value, pluginId),
+      remove: (key: string) => window.intools?.storage?.remove(key, pluginId),
+    },
+
+    // AI API
+    ai: {
+      call: (option: any, onChunk?: (chunk: any) => void) => window.intools?.ai?.call(option, onChunk),
+      allModels: () => window.intools?.ai?.allModels?.(),
+      tokens: {
+        estimate: (input: any) => window.intools?.ai?.tokens?.estimate(input),
+      },
+      attachments: {
+        upload: (input: any) => window.intools?.ai?.attachments?.upload(input),
+        get: (attachmentId: string) => window.intools?.ai?.attachments?.get(attachmentId),
+        delete: (attachmentId: string) => window.intools?.ai?.attachments?.delete(attachmentId),
+      },
+      images: {
+        generate: (input: any) => window.intools?.ai?.images?.generate(input),
+        edit: (input: any) => window.intools?.ai?.images?.edit(input),
+      },
+      videos: {
+        generate: (input: any) => window.intools?.ai?.videos?.generate(input),
+      },
+      models: {
+        fetch: (input: any) => window.intools?.ai?.models?.fetch(input),
+      },
+      testConnection: (input?: any) => window.intools?.ai?.testConnection?.(input),
+      testConnectionStream: (input: any, onChunk: (chunk: any) => void) =>
+        window.intools?.ai?.testConnectionStream?.(input, onChunk),
+      settings: {
+        get: () => window.intools?.ai?.settings?.get(),
+        update: (next: any) => window.intools?.ai?.settings?.update(next),
+      },
+    },
+
+    // Messaging API
+    messaging: {
+      send: (targetPluginId: string, type: string, payload: unknown) =>
+        window.intools?.messaging?.send(targetPluginId, type, payload),
+      broadcast: (type: string, payload: unknown) =>
+        window.intools?.messaging?.broadcast(type, payload),
+      on: (callback: (message: {
+        id: string
+        from: string
+        to?: string
+        type: string
+        payload: unknown
+        timestamp: number
+      }) => void | Promise<void>) => window.intools?.messaging?.on(callback),
+      off: (callback?: (message: any) => void) => window.intools?.messaging?.off(callback),
+    },
+
+    // Scheduler API
+    scheduler: {
+      schedule: (task: {
+        name: string
+        type: 'once' | 'repeat' | 'delay'
+        callback: string
+        time?: number
+        cron?: string
+        delay?: number
+        payload?: any
+        maxRetries?: number
+        retryDelay?: number
+        timeout?: number
+      }) => window.intools?.scheduler?.schedule(task),
+      cancelTask: (taskId: string) => window.intools?.scheduler?.cancelTask(taskId),
+      pauseTask: (taskId: string) => window.intools?.scheduler?.pauseTask(taskId),
+      resumeTask: (taskId: string) => window.intools?.scheduler?.resumeTask(taskId),
+      listTasks: (filter?: { status?: string; type?: string; limit?: number; offset?: number }) => window.intools?.scheduler?.listTasks(filter),
+      getTaskCount: (filter?: { status?: string; type?: string }) => window.intools?.scheduler?.getTaskCount(filter),
+      getTask: (taskId: string) => window.intools?.scheduler?.getTask(taskId),
+      deleteTasks: (taskIds: string[]) => window.intools?.scheduler?.deleteTasks(taskIds),
+      cleanupTasks: (olderThan?: number) => window.intools?.scheduler?.cleanupTasks(olderThan),
+      getExecutions: (taskId: string, limit?: number) => window.intools?.scheduler?.getExecutions(taskId, limit),
+      validateCron: (expression: string) => window.intools?.scheduler?.validateCron(expression),
+      getNextCronTime: (expression: string, after?: Date) => window.intools?.scheduler?.getNextCronTime(expression, after),
+      describeCron: (expression: string) => window.intools?.scheduler?.describeCron(expression),
+    },
+
+    // Notification API
+    notification: {
+      show: (message: string, type?: 'info' | 'success' | 'warning' | 'error') =>
+        window.intools?.notification?.show(message, type),
+    },
+
+    // Window API
+    window: {
+      setSize: (width: number, height: number) => window.intools?.window?.setSize(width, height),
+      setExpendHeight: (height: number) => window.intools?.window?.setExpendHeight?.(height),
+      center: () => window.intools?.window?.center?.(),
+      hide: (isRestorePreWindow?: boolean) => window.intools?.window?.hide?.(isRestorePreWindow),
+      show: () => window.intools?.window?.show(),
+      close: () => window.intools?.window?.close(),
+      create: (url: string, options?: { width?: number; height?: number; title?: string }) =>
+        window.intools?.window?.create(url, options),
+      detach: () => window.intools?.window?.detach?.(),
+      setAlwaysOnTop: (flag: boolean) => window.intools?.window?.setAlwaysOnTop?.(flag),
+      getMode: () => window.intools?.window?.getMode?.(),
+      getWindowType: () => window.intools?.window?.getWindowType?.(),
+      minimize: () => window.intools?.window?.minimize?.(),
+      maximize: () => window.intools?.window?.maximize?.(),
+      getState: () => window.intools?.window?.getState?.(),
+      reload: () => window.intools?.window?.reload?.(),
+      sendToParent: (channel: string, ...args: unknown[]) =>
+        window.intools?.window?.sendToParent?.(channel, ...args),
+      onChildMessage: (callback: (channel: string, ...args: unknown[]) => void) =>
+        window.intools?.window?.onChildMessage?.(callback),
+      findInPage: (text: string, options?: { forward?: boolean; findNext?: boolean; matchCase?: boolean }) =>
+        window.intools?.window?.findInPage?.(text, options),
+      stopFindInPage: (action?: 'clearSelection' | 'keepSelection' | 'activateSelection') =>
+        window.intools?.window?.stopFindInPage?.(action),
+      startDrag: (filePath: string | string[]) => window.intools?.window?.startDrag?.(filePath),
+    },
+
+    // SubInput API
+    subInput: {
+      set: (placeholder?: string, isFocus?: boolean) => window.intools?.subInput?.set?.(placeholder, isFocus),
+      remove: () => window.intools?.subInput?.remove?.(),
+      setValue: (text: string) => window.intools?.subInput?.setValue?.(text),
+      focus: () => window.intools?.subInput?.focus?.(),
+      blur: () => window.intools?.subInput?.blur?.(),
+      select: () => window.intools?.subInput?.select?.(),
+      onChange: (callback: (data: { text: string }) => void) => window.intools?.subInput?.onChange?.(callback),
+    },
+
+    // Plugin API
+    plugin: {
+      getAll: () => window.intools?.plugin?.getAll?.(),
+      search: (query: string) => window.intools?.plugin?.search?.(query),
+      run: (name: string, featureCode: string, input?: string) => window.intools?.plugin?.run?.(name, featureCode, input),
+      install: (filePath: string) => window.intools?.plugin?.install?.(filePath),
+      uninstall: (name: string) => window.intools?.plugin?.uninstall?.(name),
+      getReadme: (name: string) => window.intools?.plugin?.getReadme?.(name),
+      redirect: (label: string | [string, string], payload?: unknown) =>
+        window.intools?.plugin?.redirect?.(label, payload),
+      outPlugin: (isKill?: boolean) => window.intools?.plugin?.outPlugin?.(isKill),
+      enable: (name: string) => window.intools?.plugin?.enable?.(name),
+      disable: (name: string) => window.intools?.plugin?.disable?.(name),
+      listBackground: () => window.intools?.plugin?.listBackground?.(),
+      startBackground: (pluginId: string) => window.intools?.plugin?.startBackground?.(pluginId),
+      stopBackground: (pluginId: string) => window.intools?.plugin?.stopBackground?.(pluginId),
+      getBackgroundInfo: (pluginId: string) => window.intools?.plugin?.getBackgroundInfo?.(pluginId),
+      stopPlugin: (pluginId: string) => window.intools?.plugin?.stopPlugin?.(pluginId),
+    },
+
+    // HTTP API
+    http: {
+      request: (options: {
+        url: string
+        method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD'
+        headers?: Record<string, string>
+        body?: unknown
+        timeout?: number
+      }) => window.intools?.http?.request(options),
+      get: (url: string, headers?: Record<string, string>) => window.intools?.http?.get(url, headers),
+      post: (url: string, body?: unknown, headers?: Record<string, string>) =>
+        window.intools?.http?.post(url, body, headers),
+      put: (url: string, body?: unknown, headers?: Record<string, string>) =>
+        window.intools?.http?.put(url, body, headers),
+      delete: (url: string, headers?: Record<string, string>) => window.intools?.http?.delete(url, headers),
+    },
+
+    // Filesystem API
+    filesystem: {
+      readFile: (path: string, encoding?: 'utf-8' | 'base64') => window.intools?.filesystem?.readFile(path, encoding),
+      writeFile: (path: string, data: string | ArrayBuffer, encoding?: 'utf-8' | 'base64') =>
+        window.intools?.filesystem?.writeFile(path, data, encoding),
+      exists: (path: string) => window.intools?.filesystem?.exists(path),
+      readdir: (path: string) => window.intools?.filesystem?.readdir(path),
+      mkdir: (path: string) => window.intools?.filesystem?.mkdir(path),
+      stat: (path: string) => window.intools?.filesystem?.stat(path),
+      copy: (src: string, dest: string) => window.intools?.filesystem?.copy(src, dest),
+      move: (src: string, dest: string) => window.intools?.filesystem?.move(src, dest),
+      unlink: (path: string) => window.intools?.filesystem?.unlink(path),
+    },
+
+    // Screen API
+    screen: {
+      getAllDisplays: () => window.intools?.screen?.getAllDisplays(),
+      getPrimaryDisplay: () => window.intools?.screen?.getPrimaryDisplay(),
+      getCursorScreenPoint: () => window.intools?.screen?.getCursorScreenPoint(),
+      getDisplayNearestPoint: (point: { x: number; y: number }) =>
+        window.intools?.screen?.getDisplayNearestPoint?.(point),
+      getDisplayMatching: (rect: { x: number; y: number; width: number; height: number }) =>
+        window.intools?.screen?.getDisplayMatching?.(rect),
+      getSources: (options?: { types?: ('screen' | 'window')[]; thumbnailSize?: { width: number; height: number } }) =>
+        window.intools?.screen?.getSources(options),
+      capture: (options?: { sourceId?: string; format?: 'png' | 'jpeg'; quality?: number }) =>
+        window.intools?.screen?.capture(options),
+      captureRegion: (region: { x: number; y: number; width: number; height: number }, options?: { format?: 'png' | 'jpeg'; quality?: number }) =>
+        window.intools?.screen?.captureRegion(region, options),
+      screenCapture: () => window.intools?.screen?.screenCapture(),
+      colorPick: () => window.intools?.screen?.colorPick?.(),
+    },
+
+    // Shell API
+    shell: {
+      openPath: (path: string) => window.intools?.shell?.openPath(path),
+      openExternal: (url: string) => window.intools?.shell?.openExternal(url),
+      showItemInFolder: (path: string) => window.intools?.shell?.showItemInFolder(path),
+      openFolder: (path: string) => window.intools?.shell?.openFolder(path),
+      trashItem: (path: string) => window.intools?.shell?.trashItem(path),
+      beep: () => window.intools?.shell?.beep(),
+    },
+
+    // Dialog API
+    dialog: {
+      showOpenDialog: (options?: {
+        title?: string
+        defaultPath?: string
+        filters?: { name: string; extensions: string[] }[]
+        properties?: ('openFile' | 'openDirectory' | 'multiSelections' | 'showHiddenFiles')[]
+      }) => window.intools?.dialog?.showOpenDialog(options),
+      showSaveDialog: (options?: {
+        title?: string
+        defaultPath?: string
+        filters?: { name: string; extensions: string[] }[]
+      }) => window.intools?.dialog?.showSaveDialog(options),
+      showMessageBox: (options: {
+        type?: 'none' | 'info' | 'error' | 'question' | 'warning'
+        title?: string
+        message: string
+        detail?: string
+        buttons?: string[]
+      }) => window.intools?.dialog?.showMessageBox(options),
+    },
+
+    // System API
+    system: {
+      getSystemInfo: () => window.intools?.system?.getSystemInfo(),
+      getAppInfo: () => window.intools?.system?.getAppInfo(),
+      getPath: (name: string) => window.intools?.system?.getPath(name as any),
+      getEnv: (name: string) => window.intools?.system?.getEnv(name),
+      getIdleTime: () => window.intools?.system?.getIdleTime(),
+      getFileIcon: (filePath: string) => window.intools?.system?.getFileIcon?.(filePath),
+      getNativeId: () => window.intools?.system?.getNativeId?.(),
+      isDev: () => window.intools?.system?.isDev?.(),
+      isMacOS: () => window.intools?.system?.isMacOS?.(),
+      isWindows: () => window.intools?.system?.isWindows?.(),
+      isLinux: () => window.intools?.system?.isLinux?.(),
+    },
+
+    // Permission API
+    permission: {
+      getStatus: (type: 'geolocation' | 'camera' | 'microphone' | 'notifications' | 'screen' | 'accessibility' | 'contacts' | 'calendar') =>
+        window.intools?.permission?.getStatus(type),
+      request: (type: 'geolocation' | 'camera' | 'microphone' | 'notifications' | 'screen' | 'accessibility' | 'contacts' | 'calendar') =>
+        window.intools?.permission?.request(type),
+      canRequest: (type: 'geolocation' | 'camera' | 'microphone' | 'notifications' | 'screen' | 'accessibility' | 'contacts' | 'calendar') =>
+        window.intools?.permission?.canRequest(type),
+      openSystemSettings: (type: 'geolocation' | 'camera' | 'microphone' | 'notifications' | 'screen' | 'accessibility' | 'contacts' | 'calendar') =>
+        window.intools?.permission?.openSystemSettings(type),
+      isAccessibilityTrusted: () => window.intools?.permission?.isAccessibilityTrusted()
+    },
+
+    // Power API
+    power: {
+      getSystemIdleTime: () => window.intools?.power?.getSystemIdleTime(),
+      getSystemIdleState: (threshold: number) => window.intools?.power?.getSystemIdleState(threshold),
+      isOnBatteryPower: () => window.intools?.power?.isOnBatteryPower(),
+      getCurrentThermalState: () => window.intools?.power?.getCurrentThermalState(),
+    },
+
+    // Network API
+    network: {
+      isOnline: () => window.intools?.network?.isOnline(),
+    },
+
+    // Geolocation API
+    geolocation: {
+      getAccessStatus: () => window.intools?.geolocation?.getAccessStatus(),
+      requestAccess: () => window.intools?.geolocation?.requestAccess(),
+      canGetPosition: () => window.intools?.geolocation?.canGetPosition(),
+      openSettings: () => window.intools?.geolocation?.openSettings(),
+      getCurrentPosition: () => window.intools?.geolocation?.getCurrentPosition(),
+    },
+
+    // TTS API
+    tts: {
+      speak: (text: string, options?: { lang?: string; rate?: number; pitch?: number; volume?: number }) =>
+        window.intools?.tts?.speak(text, options),
+      stop: () => window.intools?.tts?.stop(),
+      pause: () => window.intools?.tts?.pause(),
+      resume: () => window.intools?.tts?.resume(),
+      getVoices: () => window.intools?.tts?.getVoices(),
+      isSpeaking: () => window.intools?.tts?.isSpeaking(),
+    },
+
+    // Media API
+    media: {
+      getAccessStatus: (type: 'camera' | 'microphone') => window.intools?.media?.getAccessStatus(type),
+      askForAccess: (type: 'camera' | 'microphone') => window.intools?.media?.askForAccess(type),
+      hasCameraAccess: () => window.intools?.media?.hasCameraAccess(),
+      hasMicrophoneAccess: () => window.intools?.media?.hasMicrophoneAccess(),
+    },
+
+    // Shortcut API
+    shortcut: {
+      register: (accelerator: string) => window.intools?.shortcut?.register(accelerator),
+      unregister: (accelerator: string) => window.intools?.shortcut?.unregister(accelerator),
+      unregisterAll: () => window.intools?.shortcut?.unregisterAll(),
+      isRegistered: (accelerator: string) => window.intools?.shortcut?.isRegistered(accelerator),
+    },
+
+    // Security API
+    security: {
+      isEncryptionAvailable: () => window.intools?.security?.isEncryptionAvailable(),
+      encryptString: (text: string) => window.intools?.security?.encryptString(text),
+      decryptString: (data: ArrayBuffer) => window.intools?.security?.decryptString(data),
+    },
+
+    // Tray API
+    tray: {
+      create: (options: { icon: string; tooltip?: string; title?: string }) =>
+        window.intools?.tray?.create(options),
+      destroy: () => window.intools?.tray?.destroy(),
+      setIcon: (icon: string) => window.intools?.tray?.setIcon(icon),
+      setTooltip: (tooltip: string) => window.intools?.tray?.setTooltip(tooltip),
+      setTitle: (title: string) => window.intools?.tray?.setTitle(title),
+      exists: () => window.intools?.tray?.exists(),
+    },
+
+    // Menu API
+    menu: {
+      showContextMenu: (items: {
+        label?: string
+        type?: 'normal' | 'separator' | 'checkbox' | 'radio'
+        checked?: boolean
+        enabled?: boolean
+        id?: string
+        submenu?: unknown[]
+      }[]) => window.intools?.menu?.showContextMenu(items as Parameters<typeof window.intools.menu.showContextMenu>[0]),
+    },
+
+    // Theme API
+    theme: {
+      get: () => window.intools?.theme?.get(),
+      set: (mode: 'light' | 'dark' | 'system') => window.intools?.theme?.set(mode),
+      getActual: () => window.intools?.theme?.getActual(),
+    },
+
+    // Host API
+    host: {
+      invoke: (method: string, ...args: unknown[]) =>
+        window.intools?.host?.invoke(pluginId || '', method, ...args),
+      call: (method: string, ...args: unknown[]) =>
+        window.intools?.host?.call?.(pluginId || '', method, ...args),
+      status: () => window.intools?.host?.status(pluginId || ''),
+      restart: () => window.intools?.host?.restart(pluginId || ''),
+    },
+
+    // InBrowser API
+    inbrowser: window.intools?.inbrowser,
+
+    // Sharp API
+    sharp: window.intools?.sharp,
+    getSharpVersion: () => window.intools?.getSharpVersion?.(),
+
+    // FFmpeg API
+    ffmpeg: window.intools?.ffmpeg,
+  }), [pluginId])
+}
+`;
+}
+function buildGitignore() {
+    return `node_modules
+dist
+/ui/
+.DS_Store
+*.log
+`;
+}
+function buildReactReadme(name) {
+    return `# ${name}
+
+插件描述
+
+## 功能特性
+
+- 功能 1
+- 功能 2
+- 功能 3
+
+## 触发方式
+
+- \`${name}\` - 主功能
+
+## 开发
+
+### 安装依赖
+
+\`\`\`bash
+npm install
+\`\`\`
+
+### 开发模式
+
+\`\`\`bash
+npm run dev
+\`\`\`
+
+### 构建
+
+\`\`\`bash
+npm run build
+\`\`\`
+
+### 打包
+
+\`\`\`bash
+npm run pack
+\`\`\`
+
+## 项目结构
+
+\`\`\`
+${name}/
+├── manifest.json              # 插件配置
+├── package.json
+├── src/
+│   ├── main.ts                # 后端入口
+│   ├── ui/
+│   │   ├── App.tsx            # 主应用
+│   │   ├── main.tsx           # UI 入口
+│   │   ├── index.html         # HTML 模板
+│   │   ├── styles.css         # 全局样式
+│   │   ├── hooks/
+│   │   │   └── useIntools.ts  # InTools API Hook
+│   │   └── types/
+│   │       └── intools.d.ts   # 类型定义
+├── dist/                      # 后端构建输出
+├── ui/                        # UI 构建输出
+└── icon.png                   # 插件图标
+\`\`\`
+
+## 许可证
+
+MIT License
+`;
+}
+function buildIntoolsTypes() {
+    return `// InTools API 类型定义
+
+interface ClipboardFileInfo {
+  path: string
+  name: string
+  size: number
+  isDirectory: boolean
+}
+
+interface IntoolsClipboard {
+  readText(): Promise<string>
+  writeText(text: string): Promise<void>
+  readImage(): Promise<ArrayBuffer | null>
+  writeImage(image: string | ArrayBuffer): Promise<void>
+  readFiles(): Promise<ClipboardFileInfo[]>
+  writeFiles(files: string | string[]): Promise<boolean>
+  getFormat(): Promise<'text' | 'image' | 'files' | 'empty'>
+}
+
+interface ClipboardHistoryItem {
+  id: string
+  type: 'text' | 'image' | 'files'
+  content: string
+  plainText?: string
+  files?: string[]
+  timestamp: number
+  size: number
+  favorite: boolean
+  tags?: string[]
+}
+
+interface ClipboardHistoryStats {
+  total: number
+  text: number
+  image: number
+  files: number
+  favorite: number
+}
+
+interface IntoolsClipboardHistory {
+  query(options?: {
+    type?: 'text' | 'image' | 'files'
+    search?: string
+    favorite?: boolean
+    limit?: number
+    offset?: number
+  }): Promise<ClipboardHistoryItem[]>
+  get(id: string): Promise<ClipboardHistoryItem | null>
+  copy(id: string): Promise<{ success: boolean; error?: string }>
+  toggleFavorite(id: string): Promise<{ success: boolean }>
+  delete(id: string): Promise<{ success: boolean }>
+  clear(): Promise<{ success: boolean }>
+  stats(): Promise<ClipboardHistoryStats>
+}
+
+interface IntoolsInput {
+  hideMainWindowPasteText(text: string): Promise<boolean>
+  hideMainWindowPasteImage(image: string | ArrayBuffer): Promise<boolean>
+  hideMainWindowPasteFile(filePaths: string | string[]): Promise<boolean>
+  hideMainWindowTypeString(text: string): Promise<boolean>
+  restoreWindows(): Promise<boolean>
+  simulateKeyboardTap(key: string, ...modifiers: string[]): Promise<boolean>
+  simulateMouseMove(x: number, y: number): Promise<boolean>
+  simulateMouseClick(x: number, y: number): Promise<boolean>
+  simulateMouseDoubleClick(x: number, y: number): Promise<boolean>
+  simulateMouseRightClick(x: number, y: number): Promise<boolean>
+}
+
+interface IntoolsNotification {
+  show(message: string, type?: 'info' | 'success' | 'warning' | 'error'): void
+}
+
+interface BrowserWindowProxy {
+  id: number
+  show(): Promise<void>
+  hide(): Promise<void>
+  close(): Promise<void>
+  focus(): Promise<void>
+  setTitle(title: string): Promise<void>
+  setSize(width: number, height: number): Promise<void>
+  setPosition(x: number, y: number): Promise<void>
+  postMessage(channel: string, ...args: unknown[]): Promise<void>
+}
+
+interface IntoolsWindow {
+  hide(isRestorePreWindow?: boolean): void
+  show(): void
+  setSize(width: number, height: number): void
+  setExpendHeight(height: number): void
+  center(): void
+  create(url: string, options?: { width?: number; height?: number; title?: string }): Promise<BrowserWindowProxy | null>
+  close(): void
+  detach(): void
+  setAlwaysOnTop(flag: boolean): void
+  getMode(): Promise<'attached' | 'detached'>
+  getWindowType(): Promise<'main' | 'detach'>
+  minimize(): void
+  maximize(): void
+  getState(): Promise<{ isMaximized: boolean; isAlwaysOnTop: boolean }>
+  reload(): void
+  sendToParent(channel: string, ...args: unknown[]): void
+  onChildMessage(callback: (channel: string, ...args: unknown[]) => void): void
+  findInPage(text: string, options?: { forward?: boolean; findNext?: boolean; matchCase?: boolean }): Promise<number>
+  stopFindInPage(action?: 'clearSelection' | 'keepSelection' | 'activateSelection'): void
+  startDrag(filePath: string | string[]): void
+}
+
+interface IntoolsSubInput {
+  set(placeholder?: string, isFocus?: boolean): Promise<boolean>
+  remove(): Promise<boolean>
+  setValue(text: string): void
+  focus(): void
+  blur(): void
+  select(): void
+  onChange(callback: (data: { text: string }) => void): void
+}
+
+interface IntoolsTheme {
+  get(): Promise<{ mode: 'light' | 'dark' | 'system'; actual: 'light' | 'dark' }>
+  set(mode: 'light' | 'dark' | 'system'): Promise<{ mode: 'light' | 'dark' | 'system'; actual: 'light' | 'dark' }>
+  getActual(): Promise<'light' | 'dark'>
+}
+
+interface PluginInfo {
+  id: string
+  name: string
+  displayName: string
+  description?: string
+  features: Array<{ code: string; explain?: string }>
+  enabled: boolean
+}
+
+interface PluginSearchResult {
+  pluginId: string
+  pluginName: string
+  displayName: string
+  featureCode: string
+  featureExplain?: string
+  matchType: 'keyword' | 'regex' | 'prefix' | 'exact' | string
+  icon?: string
+}
+
+interface BackgroundPluginInfo {
+  pluginId: string
+  pluginName: string
+  displayName: string
+  runMode: 'background' | 'active'
+  startedAt?: number
+  uptime?: number
+  memoryUsage?: number
+  cpuUsage?: number
+  requestCount?: number
+  errorCount?: number
+  healthy?: boolean
+  lastHeartbeat?: number
+  missedHeartbeats?: number
+}
+
+interface IntoolsPlugin {
+  getAll(): Promise<PluginInfo[]>
+  search(query: string): Promise<PluginSearchResult[]>
+  run(name: string, featureCode: string, input?: string): Promise<{ success: boolean; hasUI?: boolean; error?: string }>
+  install(filePath: string): Promise<{ success: boolean; pluginName?: string; error?: string }>
+  enable(name: string): Promise<{ success: boolean; error?: string }>
+  disable(name: string): Promise<{ success: boolean; error?: string }>
+  uninstall(name: string): Promise<{ success: boolean; error?: string }>
+  getReadme(name: string): Promise<string | null>
+  redirect(label: string | [string, string], payload?: unknown): Promise<boolean | { candidates: { name: string; displayName: string }[] }>
+  outPlugin(isKill?: boolean): Promise<boolean>
+  listBackground(): Promise<BackgroundPluginInfo[]>
+  startBackground(pluginId: string): Promise<{ success: boolean; error?: string }>
+  stopBackground(pluginId: string): Promise<{ success: boolean }>
+  getBackgroundInfo(pluginId: string): Promise<BackgroundPluginInfo>
+  stopPlugin(pluginId: string): Promise<void>
+}
+
+interface DisplayInfo {
+  id: number
+  label: string
+  bounds: { x: number; y: number; width: number; height: number }
+  workArea: { x: number; y: number; width: number; height: number }
+  scaleFactor: number
+  rotation: number
+  isPrimary: boolean
+}
+
+interface CaptureSource {
+  id: string
+  name: string
+  thumbnailDataUrl: string
+  displayId?: string
+  appIconDataUrl?: string
+}
+
+interface ColorPickResult {
+  hex: string
+  rgb: string
+  r: number
+  g: number
+  b: number
+}
+
+interface IntoolsScreen {
+  getAllDisplays(): Promise<DisplayInfo[]>
+  getPrimaryDisplay(): Promise<DisplayInfo>
+  getDisplayNearestPoint(point: { x: number; y: number }): Promise<DisplayInfo>
+  getDisplayMatching(rect: { x: number; y: number; width: number; height: number }): Promise<DisplayInfo>
+  getCursorScreenPoint(): Promise<{ x: number; y: number }>
+  getSources(options?: { types?: ('screen' | 'window')[]; thumbnailSize?: { width: number; height: number } }): Promise<CaptureSource[]>
+  capture(options?: { sourceId?: string; format?: 'png' | 'jpeg'; quality?: number }): Promise<ArrayBuffer>
+  captureRegion(region: { x: number; y: number; width: number; height: number }, options?: { format?: 'png' | 'jpeg'; quality?: number }): Promise<ArrayBuffer>
+  getMediaStreamConstraints(options: { sourceId: string; audio?: boolean; frameRate?: number }): Promise<object>
+  screenCapture(): Promise<string | null>
+  colorPick(): Promise<ColorPickResult | null>
+}
+
+interface IntoolsShell {
+  openPath(path: string): Promise<string>
+  openExternal(url: string): Promise<void>
+  showItemInFolder(path: string): Promise<void>
+  openFolder(path: string): Promise<string>
+  trashItem(path: string): Promise<void>
+  beep(): Promise<void>
+}
+
+interface IntoolsDialog {
+  showOpenDialog(options?: {
+    title?: string
+    defaultPath?: string
+    buttonLabel?: string
+    filters?: { name: string; extensions: string[] }[]
+    properties?: ('openFile' | 'openDirectory' | 'multiSelections' | 'showHiddenFiles')[]
+  }): Promise<string[]>
+  showSaveDialog(options?: {
+    title?: string
+    defaultPath?: string
+    buttonLabel?: string
+    filters?: { name: string; extensions: string[] }[]
+  }): Promise<string | null>
+  showMessageBox(options: {
+    type?: 'none' | 'info' | 'error' | 'question' | 'warning'
+    title?: string
+    message: string
+    detail?: string
+    buttons?: string[]
+    defaultId?: number
+    cancelId?: number
+  }): Promise<{ response: number; checkboxChecked: boolean }>
+  showErrorBox(title: string, content: string): Promise<void>
+}
+
+interface SystemInfo {
+  platform: string
+  arch: string
+  hostname: string
+  username: string
+  homedir: string
+  tmpdir: string
+  cpus: number
+  totalmem: number
+  freemem: number
+  uptime: number
+  osVersion: string
+  osRelease: string
+}
+
+interface AppInfo {
+  name: string
+  version: string
+  locale: string
+  isPackaged: boolean
+  userDataPath: string
+}
+
+interface IntoolsSystem {
+  getSystemInfo(): Promise<SystemInfo>
+  getAppInfo(): Promise<AppInfo>
+  getPath(name: 'home' | 'appData' | 'userData' | 'temp' | 'exe' | 'desktop' | 'documents' | 'downloads' | 'music' | 'pictures' | 'videos' | 'logs'): Promise<string>
+  getEnv(name: string): Promise<string | undefined>
+  getIdleTime(): Promise<number>
+  getFileIcon(filePath: string): Promise<string>
+  getNativeId(): Promise<string>
+  isDev(): Promise<boolean>
+  isMacOS(): Promise<boolean>
+  isWindows(): Promise<boolean>
+  isLinux(): Promise<boolean>
+}
+
+interface IntoolsPermission {
+  getStatus(type: 'geolocation' | 'camera' | 'microphone' | 'notifications' | 'screen' | 'accessibility' | 'contacts' | 'calendar'): Promise<'authorized' | 'granted' | 'denied' | 'not-determined' | 'restricted' | 'limited' | 'unknown'>
+  request(type: 'geolocation' | 'camera' | 'microphone' | 'notifications' | 'screen' | 'accessibility' | 'contacts' | 'calendar'): Promise<'authorized' | 'granted' | 'denied' | 'not-determined' | 'restricted' | 'limited' | 'unknown'>
+  canRequest(type: 'geolocation' | 'camera' | 'microphone' | 'notifications' | 'screen' | 'accessibility' | 'contacts' | 'calendar'): Promise<boolean>
+  openSystemSettings(type: 'geolocation' | 'camera' | 'microphone' | 'notifications' | 'screen' | 'accessibility' | 'contacts' | 'calendar'): Promise<boolean>
+  isAccessibilityTrusted(): Promise<boolean>
+}
+
+interface IntoolsShortcut {
+  register(accelerator: string): Promise<boolean>
+  unregister(accelerator: string): Promise<void>
+  unregisterAll(): Promise<void>
+  isRegistered(accelerator: string): Promise<boolean>
+  onTriggered(callback: (accelerator: string) => void): void
+}
+
+interface IntoolsSecurity {
+  isEncryptionAvailable(): Promise<boolean>
+  encryptString(plainText: string): Promise<ArrayBuffer>
+  decryptString(encrypted: ArrayBuffer): Promise<string>
+}
+
+interface IntoolsMedia {
+  getAccessStatus(mediaType: 'microphone' | 'camera'): Promise<'not-determined' | 'granted' | 'denied' | 'restricted' | 'unknown'>
+  askForAccess(mediaType: 'microphone' | 'camera'): Promise<boolean>
+  hasCameraAccess(): Promise<boolean>
+  hasMicrophoneAccess(): Promise<boolean>
+}
+
+interface IntoolsPower {
+  getSystemIdleTime(): Promise<number>
+  getSystemIdleState(idleThreshold: number): Promise<'active' | 'idle' | 'locked' | 'unknown'>
+  isOnBatteryPower(): Promise<boolean>
+  getCurrentThermalState(): Promise<'unknown' | 'nominal' | 'fair' | 'serious' | 'critical'>
+  onSuspend(callback: () => void): void
+  onResume(callback: () => void): void
+  onAC(callback: () => void): void
+  onBattery(callback: () => void): void
+  onLockScreen(callback: () => void): void
+  onUnlockScreen(callback: () => void): void
+}
+
+interface IntoolsTray {
+  create(options: { icon: string; tooltip?: string; title?: string }): Promise<boolean>
+  destroy(): Promise<void>
+  setIcon(icon: string): Promise<void>
+  setTooltip(tooltip: string): Promise<void>
+  setTitle(title: string): Promise<void>
+  exists(): Promise<boolean>
+}
+
+interface IntoolsNetwork {
+  isOnline(): Promise<boolean>
+}
+
+interface IntoolsMenu {
+  showContextMenu(items: {
+    label: string
+    type?: 'normal' | 'separator' | 'checkbox' | 'radio'
+    checked?: boolean
+    enabled?: boolean
+    id?: string
+    submenu?: any[]
+  }[]): Promise<string | null>
+}
+
+interface IntoolsGeolocation {
+  getAccessStatus(): Promise<'not-determined' | 'granted' | 'denied' | 'restricted' | 'unknown'>
+  requestAccess(): Promise<'not-determined' | 'granted' | 'denied' | 'restricted' | 'unknown'>
+  canGetPosition(): Promise<boolean>
+  openSettings(): Promise<void>
+  getCurrentPosition(): Promise<{
+    latitude: number
+    longitude: number
+    accuracy: number
+    altitude?: number | null
+    altitudeAccuracy?: number | null
+    heading?: number | null
+    speed?: number | null
+    timestamp: number
+  }>
+}
+
+interface IntoolsTTS {
+  speak(text: string, options?: { lang?: string; rate?: number; pitch?: number; volume?: number }): Promise<void>
+  stop(): void
+  pause(): void
+  resume(): void
+  getVoices(): { name: string; lang: string; default: boolean; localService: boolean }[]
+  isSpeaking(): boolean
+}
+
+interface IntoolsStorage {
+  get(key: string, namespace?: string): Promise<unknown>
+  set(key: string, value: unknown, namespace?: string): Promise<void>
+  remove(key: string, namespace?: string): Promise<void>
+}
+
+interface IntoolsMessaging {
+  send(targetPluginId: string, type: string, payload: unknown): Promise<void>
+  broadcast(type: string, payload: unknown): Promise<void>
+  on(handler: (message: {
+    id: string
+    from: string
+    to?: string
+    type: string
+    payload: unknown
+    timestamp: number
+  }) => void | Promise<void>): void
+  off(handler?: (message: any) => void): void
+}
+
+interface IntoolsScheduler {
+  schedule(task: {
+    name: string
+    type: 'once' | 'repeat' | 'delay'
+    callback: string
+    time?: number
+    cron?: string
+    delay?: number
+    payload?: any
+    maxRetries?: number
+    retryDelay?: number
+    timeout?: number
+    description?: string
+    endTime?: number
+    maxExecutions?: number
+  }): Promise<any>
+  cancelTask(taskId: string): Promise<void>
+  pauseTask(taskId: string): Promise<void>
+  resumeTask(taskId: string): Promise<void>
+  listTasks(filter?: { status?: string; type?: string; limit?: number; offset?: number }): Promise<any[]>
+  getTaskCount(filter?: { status?: string; type?: string }): Promise<number>
+  getTask(taskId: string): Promise<any>
+  deleteTasks(taskIds: string[]): Promise<{ success: boolean; deletedCount: number }>
+  cleanupTasks(olderThan?: number): Promise<{ success: boolean; deletedCount: number }>
+  getExecutions(taskId: string, limit?: number): Promise<any[]>
+  validateCron(expression: string): boolean
+  getNextCronTime(expression: string, after?: Date): Date
+  describeCron(expression: string): string
+}
+
+interface HttpResponse {
+  status: number
+  statusText: string
+  headers: Record<string, string>
+  data: string
+}
+
+interface IntoolsHttp {
+  request(options: {
+    url: string
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD'
+    headers?: Record<string, string>
+    body?: unknown
+    timeout?: number
+  }): Promise<HttpResponse>
+  get(url: string, headers?: Record<string, string>): Promise<HttpResponse>
+  post(url: string, body?: unknown, headers?: Record<string, string>): Promise<HttpResponse>
+  put(url: string, body?: unknown, headers?: Record<string, string>): Promise<HttpResponse>
+  delete(url: string, headers?: Record<string, string>): Promise<HttpResponse>
+}
+
+type AiMessage = { role: 'system' | 'user' | 'assistant'; content?: string | AiMessageContent[]; reasoning_content?: string }
+type AiMessageContent =
+  | { type: 'text'; text: string }
+  | { type: 'image'; attachmentId: string; mimeType?: string }
+  | { type: 'file'; attachmentId: string; mimeType?: string; filename?: string }
+type AiTool = { type: 'function'; function: { name: string; description?: string; parameters?: object } }
+type AiModelParameters = {
+  contextWindow?: number
+  temperatureEnabled?: boolean
+  topPEnabled?: boolean
+  maxOutputTokensEnabled?: boolean
+  temperature?: number
+  topP?: number
+  topK?: number
+  maxOutputTokens?: number
+  presencePenalty?: number
+  frequencyPenalty?: number
+  stopSequences?: string[]
+  seed?: number
+}
+type AiOption = { model?: string; messages: AiMessage[]; tools?: AiTool[]; params?: AiModelParameters }
+type AiModel = { id: string; label: string; description: string; icon?: string; providerLabel?: string; params?: AiModelParameters }
+type AiProviderConfig = {
+  id: string
+  label?: string
+  enabled: boolean
+  apiKey?: string
+  baseURL?: string
+  headers?: Record<string, string>
+  defaultModel?: string
+  defaultParams?: AiModelParameters
+}
+type AiSettings = { providers: AiProviderConfig[]; models?: AiModel[]; defaultParams?: AiModelParameters }
+type AiAttachmentRef = { attachmentId: string; mimeType: string; size: number; filename?: string; expiresAt?: string; purpose?: string }
+type AiTokenBreakdown = { inputTokens?: number; outputTokens?: number; totalTokens?: number }
+
+interface IntoolsAi {
+  call(option: AiOption, onChunk?: (chunk: AiMessage) => void): Promise<AiMessage>
+  allModels(): Promise<AiModel[]>
+  tokens: {
+    estimate(input: { model?: string; messages: AiMessage[] }): Promise<{ inputTokens: number; outputTokens: number }>
+  }
+  attachments: {
+    upload(input: { filePath?: string; buffer?: ArrayBuffer; mimeType: string; purpose?: string }): Promise<AiAttachmentRef>
+    get(attachmentId: string): Promise<AiAttachmentRef | null>
+    delete(attachmentId: string): Promise<void>
+  }
+  images: {
+    generate(input: { model: string; prompt: string; size?: string; count?: number }): Promise<{ images: string[]; tokens: AiTokenBreakdown }>
+    edit(input: { model: string; imageAttachmentId: string; prompt: string }): Promise<{ images: string[]; tokens: AiTokenBreakdown }>
+  }
+  videos: {
+    generate(input: { model: string; prompt: string; duration?: number; size?: string }): Promise<void>
+  }
+  models: {
+    fetch(input: { providerId: string; baseURL?: string; apiKey?: string }): Promise<{ models: AiModel[]; message?: string }>
+  }
+  testConnection(input?: { providerId?: string; model?: string; baseURL?: string; apiKey?: string }): Promise<{ success: boolean; message?: string }>
+  testConnectionStream(
+    input: { providerId?: string; model?: string; baseURL?: string; apiKey?: string },
+    onChunk: (chunk: { type: 'reasoning' | 'content'; text: string }) => void
+  ): Promise<{ success: boolean; message?: string; reasoning?: string }>
+  settings: {
+    get(): Promise<AiSettings>
+    update(next: Partial<AiSettings>): Promise<AiSettings>
+  }
+}
+
+interface FileStat {
+  name: string
+  path: string
+  size: number
+  isFile: boolean
+  isDirectory: boolean
+  createdAt: number
+  modifiedAt: number
+}
+
+interface IntoolsFilesystem {
+  readFile(path: string, encoding?: 'utf-8' | 'base64'): Promise<string | ArrayBuffer>
+  writeFile(path: string, data: string | ArrayBuffer, encoding?: 'utf-8' | 'base64'): Promise<void>
+  exists(path: string): Promise<boolean>
+  unlink(path: string): Promise<void>
+  readdir(path: string): Promise<string[]>
+  mkdir(path: string): Promise<void>
+  stat(path: string): Promise<FileStat | null>
+  copy(src: string, dest: string): Promise<void>
+  move(src: string, dest: string): Promise<void>
+}
+
+interface IntoolsHost {
+  invoke(pluginName: string, method: string, ...args: unknown[]): Promise<unknown>
+  call(pluginName: string, method: string, ...args: unknown[]): Promise<{ data: any }>
+  status(pluginName: string): Promise<{ ready: boolean; active: boolean }>
+  restart(pluginName: string): Promise<boolean>
+}
+
+interface FFmpegRunProgress {
+  bitrate: string
+  fps: number
+  frame: number
+  percent?: number
+  q: number | string
+  size: string
+  speed: string
+  time: string
+}
+
+interface FFmpegDownloadProgress {
+  phase: 'downloading' | 'extracting' | 'done'
+  percent: number
+  downloaded?: number
+  total?: number
+}
+
+interface FFmpegTask {
+  promise: Promise<void>
+  kill(): void
+  quit(): void
+}
+
+interface IntoolsFFmpeg {
+  isAvailable(): Promise<boolean>
+  getVersion(): Promise<string | null>
+  getPath(): Promise<string | null>
+  download(onProgress?: (progress: FFmpegDownloadProgress) => void): Promise<{ success: boolean; error?: string }>
+  run(args: string[], onProgress?: (progress: FFmpegRunProgress) => void): FFmpegTask
+}
+
+interface Attachment {
+  id: string
+  name: string
+  size: number
+  kind: 'file' | 'image'
+  mime?: string
+  ext?: string
+  path?: string
+  dataUrl?: string
+}
+
+interface PluginInitData {
+  pluginName: string
+  featureCode: string
+  feature?: string
+  input: string
+  mode?: string
+  route?: string
+  attachments?: Attachment[]
+}
+
+interface IntoolsAPI {
+  clipboard: IntoolsClipboard
+  clipboardHistory: IntoolsClipboardHistory
+  input: IntoolsInput
+  notification: IntoolsNotification
+  window: IntoolsWindow
+  subInput: IntoolsSubInput
+  plugin: IntoolsPlugin
+  theme?: IntoolsTheme
+  ai: IntoolsAi
+  screen: IntoolsScreen
+  shell: IntoolsShell
+  dialog: IntoolsDialog
+  system: IntoolsSystem
+  permission: IntoolsPermission
+  shortcut: IntoolsShortcut
+  security: IntoolsSecurity
+  media: IntoolsMedia
+  power: IntoolsPower
+  tray: IntoolsTray
+  network: IntoolsNetwork
+  menu: IntoolsMenu
+  geolocation: IntoolsGeolocation
+  tts: IntoolsTTS
+  storage: IntoolsStorage
+  http: IntoolsHttp
+  filesystem: IntoolsFilesystem
+  messaging: IntoolsMessaging
+  scheduler: IntoolsScheduler
+  host?: IntoolsHost
+  onPluginInit(callback: (data: PluginInitData) => void): void
+  onPluginAttach?(callback: (data: { pluginName: string; displayName: string; featureCode: string; input: string; uiPath: string; preloadPath: string }) => void): void
+  onPluginDetached?(callback: () => void): void
+  onThemeChange?(callback: (theme: 'light' | 'dark') => void): void
+  onWindowStateChange?(callback: (state: { isMaximized: boolean }) => void): void
+  inbrowser: {
+    goto: (url: string, headers?: Record<string, string>, timeout?: number) => any
+    useragent: (ua: string) => any
+    device: (name: string) => any
+    viewport: (width: number, height: number) => any
+    show: () => any
+    hide: () => any
+    evaluate: (func: string | Function, ...params: any[]) => any
+    wait: (msOrSelector: number | string) => any
+    click: (selector: string) => any
+    mousedown: (selector: string) => any
+    mouseup: (selector: string) => any
+    scroll: (selector: string | number, y?: number) => any
+    devTools: (mode?: 'right' | 'bottom' | 'undocked' | 'detach') => any
+    paste: (text: string) => any
+    file: (selector: string, payload: string | string[]) => any
+    end: () => any
+    type: (selector: string, text: string) => any
+    press: (key: string, modifiers?: string[]) => any
+    check: (selector: string, checked: boolean) => any
+    value: (selector: string, val: string) => any
+    focus: (selector: string) => any
+    when: (selector: string | Function, ...params: any[]) => any
+    css: (css: string) => any
+    pdf: (options?: any, savePath?: string) => any
+    cookies: (nameOrFilter?: string | any) => any
+    clearCookies: (url?: string) => any
+    input: (selectorOrText: string, text?: string) => any
+    dblclick: (selector: string) => any
+    hover: (selector: string) => any
+    screenshot: (target?: any, savePath?: string) => any
+    drop: (selector: string, payload: any) => any
+    download: (urlOrFunc: string | Function, savePath?: string, ...params: any[]) => any
+    removeCookies: (name: string) => any
+    setCookies: (nameOrCookies: any, value?: string) => any
+    markdown: (selector?: string) => any
+    getIdleInBrowsers: () => Promise<any[]>
+    setInBrowserProxy: (config: any) => Promise<boolean>
+    clearInBrowserCache: () => Promise<boolean>
+    run: (idOrOptions?: number | any, options?: any) => Promise<any[]>
+  }
+  sharp: IntoolsSharpFunction
+  getSharpVersion: () => Promise<{ sharp: Record<string, string>; format: Record<string, any> }>
+  ffmpeg: IntoolsFFmpeg
+}
+
+interface IntoolsSharpProxy {
+  resize(width?: number, height?: number, options?: object): IntoolsSharpProxy
+  extend(options: object): IntoolsSharpProxy
+  extract(options: { left: number; top: number; width: number; height: number }): IntoolsSharpProxy
+  trim(options?: object): IntoolsSharpProxy
+  rotate(angle?: number, options?: object): IntoolsSharpProxy
+  flip(): IntoolsSharpProxy
+  flop(): IntoolsSharpProxy
+  blur(sigma?: number): IntoolsSharpProxy
+  sharpen(options?: object): IntoolsSharpProxy
+  flatten(options?: object): IntoolsSharpProxy
+  gamma(gamma?: number): IntoolsSharpProxy
+  negate(options?: object): IntoolsSharpProxy
+  normalize(options?: object): IntoolsSharpProxy
+  threshold(threshold?: number, options?: object): IntoolsSharpProxy
+  modulate(options?: object): IntoolsSharpProxy
+  tint(color: string | object): IntoolsSharpProxy
+  greyscale(greyscale?: boolean): IntoolsSharpProxy
+  grayscale(grayscale?: boolean): IntoolsSharpProxy
+  composite(images: object[]): IntoolsSharpProxy
+  png(options?: object): IntoolsSharpProxy
+  jpeg(options?: object): IntoolsSharpProxy
+  webp(options?: object): IntoolsSharpProxy
+  gif(options?: object): IntoolsSharpProxy
+  tiff(options?: object): IntoolsSharpProxy
+  avif(options?: object): IntoolsSharpProxy
+  withMetadata(options?: object): IntoolsSharpProxy
+  clone(): IntoolsSharpProxy
+  toBuffer(options?: object): Promise<ArrayBuffer>
+  toFile(fileOut: string): Promise<{ format: string; width: number; height: number; channels: number; size: number }>
+  metadata(): Promise<{ format?: string; width?: number; height?: number; channels?: number; space?: string; depth?: string; density?: number; hasAlpha?: boolean; orientation?: number }>
+  stats(): Promise<object>
+}
+
+type IntoolsSharpFunction = (
+  input?: string | ArrayBuffer | Uint8Array | object | any[],
+  options?: object
+) => IntoolsSharpProxy
+
+declare global {
+  interface Window {
+    intools: IntoolsAPI
+  }
+}
+
+export {}
+`;
+}