zn-ai/global.d.ts

import { IPC_EVENTS } from '@runtime/lib/constants'
import type { ConfigKeys } from '@runtime/lib/types'
import type { AutomationScript, ScriptSaveInput, ScriptExecutionResult } from '@runtime/lib/script-types'

declare global {
  // 定义每个通道的参数和返回值类型
  interface IPCTypings {
    // 同步通信
    [IPC_EVENTS.APP_MINIMIZE]: {
      params: [window: number]
      return: {success: boolean, error?: string}
    }
    [IPC_EVENTS.APP_MAXIMIZE]: {
      params: [window: number]
      return: {success: boolean, error?: string}
    }
    // 异步通信
    [IPC_EVENTS.FILE_READ]: {
      params: [filePath: string]
      return: Promise<{success: boolean, data?: string, error?: string}>
    }
    [IPC_EVENTS.FILE_WRITE]: {
      params: [filePath: string, content: string]
      return: Promise<{success: boolean, error?: string}>
    }

    // 事件通信
    [IPC_EVENTS.TIME_UPDATE]: {
      params: [time: string]
      return: void
    }
    [IPC_EVENTS.RENDERER_IS_READY]: {
      params: []
      return: void
    }
    [IPC_EVENTS.CUSTOM_EVENT]: {
      params: [message: string]
      return: void
    }
    // Gateway 事件
    [IPC_EVENTS.GATEWAY_EVENT]: {
      params: [event: any]
      return: void
    }

    // 任务事件
    [IPC_EVENTS.TASK_PROGRESS]: { params: [payload: any]; return: void; }
    [IPC_EVENTS.TASK_STARTED]: { params: [payload: any]; return: void; }
    [IPC_EVENTS.TASK_COMPLETED]: { params: [payload: any]; return: void; }

    // 主题事件
    [IPC_EVENTS.THEME_MODE_UPDATED]: {
      params: [isDark: boolean]
      return: void
    }
    [IPC_EVENTS.SET_THEME_MODE]: {
      params: [theme: ThemeMode]
      return: Promise<boolean>  // 返回 isDark
    }
    [IPC_EVENTS.GET_THEME_MODE]: {
      params: []
      return: Promise<ThemeMode>
    }

    // 配置
    [IPC_EVENTS.GET_CONFIG]: {
      params: [key: ConfigKeys]
      return: Promise<any>
    }
    [IPC_EVENTS.SET_CONFIG]: {
      params: [key: ConfigKeys, value: any]
      return: Promise<{ success: boolean }>
    }

    // 脚本管理
    [IPC_EVENTS.SCRIPT_LIST]: {
      params: []
      return: Promise<AutomationScript[]>
    }
    [IPC_EVENTS.SCRIPT_GET]: {
      params: [id: string]
      return: Promise<AutomationScript | null>
    }
    [IPC_EVENTS.SCRIPT_SAVE]: {
      params: [input: ScriptSaveInput]
      return: Promise<AutomationScript>
    }
    [IPC_EVENTS.SCRIPT_DELETE]: {
      params: [id: string]
      return: Promise<boolean>
    }
    [IPC_EVENTS.SCRIPT_TOGGLE]: {
      params: [id: string, enabled: boolean]
      return: Promise<boolean>
    }
    [IPC_EVENTS.SCRIPT_RUN]: {
      params: [id: string]
      return: Promise<ScriptExecutionResult>
    }
    [IPC_EVENTS.SCRIPT_RECORD_START]: {
      params: [url?: string]
      return: Promise<{ success: boolean; code?: string; error?: string }>
    }
    [IPC_EVENTS.SCRIPT_RECORD_STOP]: {
      params: []
      return: Promise<{ success: boolean; code?: string; error?: string }>
    }
    [IPC_EVENTS.SCRIPT_CODEGEN]: {
      params: [id: string, url?: string]
      return: Promise<{ success: boolean; code?: string; error?: string }>
    }

    // Gateway RPC (对齐 ClawX)
    [IPC_EVENTS.GATEWAY_RPC]: {
      params: [method: string, params?: any]
      return: Promise<any>
    }
  }

  type TabId = string
  interface TabInfo {
    id: TabId
    url: string
    title: string
    isLoading: boolean
    canGoBack: boolean
    canGoForward: boolean
  }

  // 定义IPC API 接口
  interface WindowApi {
    invoke<T extends keyof IPCTypings>(channel: T, ...args: IPCTypings[T]['params']): IPCTypings[T]['return'],
    invokeAsync<T extends keyof IPCTypings>(channel: T, ...args: IPCTypings[T]['params']): IPCTypings[T]['return'],
    on<T extends keyof IPCTypings>(channel: T, callback: (...args: IPCTypings[T]['params']) => void): () => void
    send<T extends keyof IPCTypings>(channel: T, ...args: IPCTypings[T]['params']): void,
    versions: NodeJS.ProcessVersions,
    external: {
      open: (url: string) => Promise<void>
    },
    platform: string;
    windowMinimize: () => void;
    windowMaximize: () => void;
    windowClose: () => void;
    windowIsMaximized: () => Promise<boolean>;
    viewIsReady: () => void;
    app: {
      setFrameless: (route?: string) => Promise<void>,
      loadPage: (page: string) => Promise<void>
    },
    readFile: (filePath: string) => Promise<{success: boolean, data?: string, error?: string}>,
    logger: {
      debug: (message: string, ...meta?: any[]) => void;
      info: (message: string, ...meta?: any[]) => void;
      warn: (message: string, ...meta?: any[]) => void;
      error: (message: string, ...meta?: any[]) => void;
    },
    // 执行脚本
    executeScript: (options: any) => Promise<{success: boolean, error?: string}>,
    // 任务事件
    onTaskProgress: (cb: (payload: any) => void) => () => void;
    onTaskStarted: (cb: (payload: any) => void) => () => void;
    onTaskCompleted: (cb: (payload: any) => void) => () => void;
    // 打开渠道
    openChannel: (channels: any) => Promise<{success: boolean, error?: string}>,
    // 脚本管理
    scriptApi: {
      list: () => Promise<AutomationScript[]>,
      get: (id: string) => Promise<AutomationScript | null>,
      save: (input: ScriptSaveInput) => Promise<AutomationScript>,
      delete: (id: string) => Promise<boolean>,
      toggle: (id: string, enabled: boolean) => Promise<boolean>,
      run: (id: string) => Promise<ScriptExecutionResult>,
      startRecording: (url?: string) => Promise<{ success: boolean; code?: string; error?: string }>,
      stopRecording: () => Promise<{ success: boolean; code?: string; error?: string }>,
      codegen: (id: string, url?: string) => Promise<{ success: boolean; code?: string; error?: string }>,
    },
  }

  interface Window {
    api: WindowApi;
  }

  type ThemeMode = 'dark' | 'light' | 'system';

  // form 表单数据类型声明
  interface LoginForm {
    username: string;
    password: string;
    randomStr: string;
    code: string;
    grant_type: string;
    scope: string;
  }

  // 弹窗类型定义
  interface CreateDialogProps {
    winId?: string;
    title?: string;
    content: string;
    confirmText?: string;
    cancelText?: string;
    isModal?: boolean;
    onConfirm?: () => void;
    onCancel?: () => void;
  }

  interface CreateDialogueProps {
    messages: DialogueMessageProps[];
    providerName: string;
    selectedModel: string;
    messageId: number;
    conversationId: number;
  }

  interface UniversalChunk {
    isEnd: boolean;
    result: string;
    usage?: any;
  }

  interface DialogueBackStream {
    messageId: number;
    data: UniversalChunk & { isError?: boolean };
  }

  interface DialogueMessageProps {
    role: DialogueMessageRole;
    content: string;
  }
}