@solazah/solazah-runtime 0.0.156

package/index.cjs

@@ -0,0 +1 @@
+"use strict";

package/index.js

@@ -0,0 +1 @@
+

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@solazah/solazah-runtime",
+  "version": "0.0.156",
+  "main": "index.cjs",
+  "module": "index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "index.cjs",
+    "index.js",
+    "types"
+  ],
+  "peerDependencies": {
+    "electron": ">=25"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/types/Account.d.ts

@@ -0,0 +1,9 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class Account {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    login: () => Promise<any>;
+    logout: () => Promise<any>;
+    getState: () => Promise<any>;
+    getUserInfo: () => Promise<any>;
+}

package/types/Copilot.d.ts

@@ -0,0 +1,97 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export interface CopilotMessage {
+    event: string | 'messages/metadata' | 'messages/partial' | 'updates' | 'values' | 'error' | 'done';
+    data?: string;
+}
+export interface CopilotMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+}
+export interface CopilotBaseOptions {
+    model?: string;
+    messages?: CopilotMessage[];
+    timeout?: number;
+    temperature?: number;
+    /**
+     * 深度思考开关（旧契约，保留作后备）：
+     * - true: 在 provider 创建 chatModel 时显式打开推理（DeepSeek 走 modelKwargs.thinking = { type: "enabled" }）
+     * - false: 显式关闭
+     * - undefined: 保持模型默认
+     * 优先级低于 reasoningEffort：provider 先看 reasoningEffort，缺省才回落到 enableThinking。
+     * quick-chat / popup 仍只传 enableThinking:false（不带 reasoningEffort）→ 关思考。
+     */
+    enableThinking?: boolean;
+    /**
+     * 深度思考「强度」——主对话输入框的 Effort 选择器下发的抽象档位（默认 max）。
+     * 各 provider 自行映射：OpenAI 兼容 → reasoning_effort(minimal/low/medium/high)；
+     * Anthropic 原生 → thinking.budget_tokens + temperature=1；DeepSeek → thinking on/off。
+     */
+    reasoningEffort?: "off" | "fast" | "balanced" | "smart" | "max" | "ultra";
+}
+export interface CopilotCompletionOptions extends CopilotBaseOptions {
+}
+export interface CopilotChatOptions extends CopilotBaseOptions {
+    requestId: string;
+    signal?: AbortSignal;
+    stream?: boolean;
+    /**
+     * 内部字段：main 进程构造，仅用于本进程内回调（不跨 IPC）。
+     * 流式调用在 catch 分支抛错时由 streaming 层调用此回调，让上层有机会回滚预占的配额。
+     */
+    onStreamError?: () => Promise<void> | void;
+}
+export interface CopilotOptions extends CopilotChatOptions {
+    mcp?: string[];
+    projectDir?: string;
+    recursionLimit?: number;
+    thread_id?: string;
+    run_id?: string;
+    streamMode?: string[];
+    plugins?: string[];
+    tools?: any[];
+    skills?: string[];
+    chatModel?: any;
+    toolCallId?: string;
+    /**
+     * 编辑历史消息后重新生成：
+     * CopilotAgent.invoke 在主流前按这个 id 在 langgraph state 里定位，
+     * 把 [该消息, end) 用 RemoveMessage 从 agent 工作记忆里摘掉，DB 按同一批 id 清理，
+     * 之后照常以新输入开 invoke。
+     */
+    editFromMessageId?: string;
+    /**
+     * 内部字段:run() 给 CopilotAgent 的"本轮入口 HumanMessage id"。
+     * 持久化时按这个 id 在 latestState.messages 里找下标,从下标开始 slice 落库。
+     * 替代原来"数 prevCount"的脆弱方案——历史 abort 留下的 cancel placeholder
+     * 是在下一轮 invoke 启动阶段才被 langgraph 补进 state 的,prevCount 算不到,
+     * 会被误并入下一轮的 saveAll 批次,导致 tool 排到 user 前面。
+     */
+    persistFromMessageId?: string;
+    /**
+     * 内部字段:resume() 给 CopilotAgent 的锚点 tool_call_id。
+     * resume 入口已经把这个 tool 消息单独写进了 DB,持久化时从 state 里找到该 tool 的下标,
+     * 从下一条开始 slice,避免重复落库 + 抗历史 placeholder 污染。
+     */
+    persistFromToolCallId?: string;
+    /**
+     * 视觉模型的图片输入。每条 image_url 直接作为 content part 拼到本轮 HumanMessage 上,
+     * 与 input 文本同一条消息。仅 run() 这条路径用得到;completion/chat 不接。
+     * 渲染层负责判定模型是否支持视觉再传,这里不再二次过滤。
+     */
+    images?: {
+        url: string;
+        mime?: string;
+    }[];
+}
+export type CopilotRunOptions = CopilotOptions;
+export default class Copilot {
+    ipcRenderer: IpcRenderer;
+    private seq;
+    constructor();
+    completion: (input: string, options: any) => Promise<any>;
+    chat: (input: string, options: CopilotRunOptions) => Promise<AsyncIterableIterator<any>>;
+    run: (input: string, options: CopilotRunOptions) => Promise<AsyncIterableIterator<any>>;
+    abort: (requestId: string) => Promise<any>;
+    resume: (response: any, options: CopilotRunOptions) => Promise<AsyncIterableIterator<any>>;
+    private invokeStream;
+}

package/types/CopilotMcpServer.d.ts

@@ -0,0 +1,29 @@
+import { default as IpcRenderer } from './IpcRenderer';
+/** agent 在对话里装好一台 MCP server 后,主进程经 copilot.mcp.installed 推来的 payload。 */
+export interface CopilotMcpInstalledMessage {
+    name: string;
+    displayName: string;
+    transport: string;
+    toolNames: string[];
+}
+export default class CopilotMcpServer {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    getServers: () => Promise<any>;
+    addServer: (data: any) => Promise<any>;
+    updateServer: (id: string, data: any) => Promise<any>;
+    removeServer: (id: string) => Promise<any>;
+    toggleServer: (id: string, enabled: boolean) => Promise<any>;
+    testConnect: (server: string) => Promise<any>;
+    /**
+     * 订阅"agent 在对话里装好了一台 MCP server"通知。渲染层据此刷新列表、把新 server 并入
+     * 当前会话的 usedServers、弹全局 Toast。返回 unsubscribe。
+     * 底层 IpcRenderer.on 对同通道 removeAllListeners 后再绑,全局只应有一个订阅者。
+     */
+    onMcpInstalled: (onInstalled: (msg: CopilotMcpInstalledMessage) => void) => (() => void);
+    /** 订阅"agent 在对话里删除/禁用了一台 MCP server"通知。渲染层据此刷新列表、把它移出 usedServers。 */
+    onMcpRemoved: (onRemoved: (msg: {
+        name: string;
+        displayName?: string;
+    }) => void) => (() => void);
+}

package/types/CopilotModel.d.ts

@@ -0,0 +1,17 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class CopilotModel {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    add: (model: any) => Promise<any>;
+    update: (modelId: string, model: any) => Promise<any>;
+    remove: (modelId: string) => Promise<any>;
+    getModels: () => Promise<any>;
+    load: (model: string) => Promise<any>;
+    eject: (model: string) => Promise<any>;
+    getTasks: () => Promise<any>;
+    download: (model: string) => Promise<any>;
+    cancelDownload: (model: string) => Promise<any>;
+    pauseDownload: (model: string) => Promise<any>;
+    resumeDownload: (model: string) => Promise<any>;
+    getEmbeddedQuota: () => Promise<any>;
+}

package/types/CopilotProvider.d.ts

@@ -0,0 +1,9 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class CopilotProvider {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    getProviders: () => Promise<any>;
+    add: (provider: any) => Promise<any>;
+    update: (providerId: string, provider: any) => Promise<any>;
+    remove: (providerId: string) => Promise<any>;
+}

package/types/CopilotSubAgent.d.ts

@@ -0,0 +1,84 @@
+export interface CopilotSubAgentRunDto {
+    id: string;
+    type: string;
+    goal: string;
+    status: string;
+    result: string | null;
+    errorMessage: string | null;
+    threadId: string | null;
+    toolCallId: string | null;
+    metadata: any;
+    startedAt: string | null;
+    finishedAt: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface CopilotSubAgentArtifactDto {
+    id: string;
+    runId: string;
+    kind: string;
+    relPath: string;
+    mime: string | null;
+    sha256: string | null;
+    sizeBytes: number | null;
+    label: string | null;
+    created_at: string;
+}
+export interface CopilotSubAgentStreamMessage {
+    event: string;
+    data?: any;
+}
+/** 异步任务完成时,主进程主动推到渲染层的通知 payload(通道 copilot.subagent.task-finished)。 */
+export interface CopilotAsyncTaskFinishedMessage {
+    taskId: string;
+    threadId: string | null;
+    status: string;
+    result: string | null;
+    errorMessage: string | null;
+    goal: string | null;
+    durationMs: number;
+}
+/**
+ * window.copilotSubagent —— 渲染层访问 subagent 的总入口。
+ * 普通查询走 invoke;subscribe 走 MessagePort,跟 window.copilot.chat 同款。
+ */
+export default class CopilotSubAgent {
+    private readonly ipcRenderer;
+    constructor();
+    list: (limit?: number, offset?: number) => Promise<CopilotSubAgentRunDto[]>;
+    listByThread: (threadId: string) => Promise<CopilotSubAgentRunDto[]>;
+    listByScheduledTask: (scheduledTaskId: string) => Promise<CopilotSubAgentRunDto[]>;
+    get: (runId: string) => Promise<CopilotSubAgentRunDto | null>;
+    getArtifacts: (runId: string) => Promise<CopilotSubAgentArtifactDto[]>;
+    readArtifact: (artifactId: string) => Promise<{
+        mime: string | null;
+        base64: string;
+    } | null>;
+    getState: (runId: string) => Promise<unknown | null>;
+    /**
+     * 历史 run 回放:返回完整事件流(从 events.jsonl 读),前端按时间顺序消费一次即可。
+     * 跟 subscribe 互补 —— 用于 toolFinished 的旧 task 详情抽屉。
+     */
+    replay: (runId: string) => Promise<any[]>;
+    abort: (runId: string) => Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * 订阅一个 run 的实时事件流。
+     * onEvent 收到 { event, data } 对象;event === "done" 表示流结束(handler 应自行 unsubscribe)。
+     * 返回 unsubscribe 函数。
+     *
+     * 主进程用 per-runId 的 channel(copilot.subagent.stream.<runId>) 把 port 推回来,
+     * 多 subagent 并发也不会串台。
+     */
+    subscribe: (runId: string, onEvent: (msg: CopilotSubAgentStreamMessage) => void) => (() => void);
+    /**
+     * 订阅"异步任务完成"通知(主进程在 async-task 跑完时主动广播)。
+     * 前端可据此弹 toast / 在对应 thread 上一键让主 agent 拿结果续轮。
+     *
+     * onFinished 收到 CopilotAsyncTaskFinishedMessage;返回 unsubscribe 函数。
+     * 注意:底层 IpcRenderer.on 对同一通道会 removeAllListeners 后再绑,故全局只应有一个订阅者
+     * (通常是顶层的任务管理器),需要分发给多个组件时自行在这层之上做扇出。
+     */
+    onTaskFinished: (onFinished: (msg: CopilotAsyncTaskFinishedMessage) => void) => (() => void);
+}

package/types/CopilotThread.d.ts

@@ -0,0 +1,12 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class CopilotThread {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    getThreads: (limit?: number, offset?: number) => Promise<any>;
+    getMessages: (threadId: string) => Promise<any>;
+    add: (thread: any) => Promise<any>;
+    update: (id: string, thread: any) => Promise<any>;
+    remove: (id: string) => Promise<any>;
+    removeAll: () => Promise<any>;
+    generateThreadTitle: (id: string) => Promise<any>;
+}

package/types/CopilotWechatBridge.d.ts

@@ -0,0 +1,43 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export interface WechatAccount {
+    accountId: string;
+    baseUrl: string;
+    cdnBaseUrl: string;
+    token?: string;
+    configured: boolean;
+    userId?: string;
+    enabled: boolean;
+}
+export interface WechatLoginStartResult {
+    qrcode: string;
+    sessionKey: string;
+    message: string;
+}
+export interface WechatLoginResult {
+    connected: boolean;
+    alreadyConnected?: boolean;
+    accountId?: string;
+    sessionKey?: string;
+    baseUrl?: string;
+    userId?: string;
+    message: string;
+}
+export interface WechatChannelStatus {
+    running: boolean;
+    account: WechatAccount;
+}
+export default class CopilotWechatBridge {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    startLogin: (params?: {
+        force?: boolean;
+    }) => Promise<WechatLoginStartResult>;
+    waitForLogin: (params: {
+        sessionKey: string;
+        timeoutMs?: number;
+    }) => Promise<WechatLoginResult>;
+    logout: () => Promise<void>;
+    status: () => Promise<WechatChannelStatus>;
+    channelStart: () => Promise<void>;
+    channelStop: () => Promise<void>;
+}

package/types/File.d.ts

@@ -0,0 +1,47 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export type WorkspaceCategory = "document" | "image" | "audio" | "video" | "resource";
+export interface FileEntry {
+    name: string;
+    path: string;
+    isDir: boolean;
+    size: number;
+    mtimeMs: number;
+}
+export interface FileStat {
+    isDir: boolean;
+    size: number;
+    mtimeMs: number;
+    ctimeMs: number;
+}
+export interface FileChange {
+    type: string;
+    path: string | null;
+}
+export interface FileListOptions {
+    recursive?: boolean;
+    workspaceId?: string | null;
+}
+/**
+ * window.file —— 工作空间分类目录(文档/图片/音频/视频/.blob)内的通用文件读写。
+ * 寻址按「分类 + 相对路径」,主进程把路径钉死在分类目录内。watch 用每订阅独立频道接收变更,
+ * 返回退订闭包(off 跨 contextBridge 失效,清理一律调返回值)。
+ */
+export default class File {
+    private transport;
+    private seq;
+    constructor(transport?: IpcRenderer);
+    read: (category: WorkspaceCategory, relPath: string, workspaceId?: string | null) => Promise<string>;
+    write: (category: WorkspaceCategory, relPath: string, content: string, workspaceId?: string | null) => Promise<void>;
+    readBinary: (category: WorkspaceCategory, relPath: string, workspaceId?: string | null) => Promise<Uint8Array>;
+    writeBinary: (category: WorkspaceCategory, relPath: string, data: Uint8Array, workspaceId?: string | null) => Promise<void>;
+    list: (category: WorkspaceCategory, relPath?: string, options?: FileListOptions) => Promise<FileEntry[]>;
+    stat: (category: WorkspaceCategory, relPath: string, workspaceId?: string | null) => Promise<FileStat | null>;
+    exists: (category: WorkspaceCategory, relPath: string, workspaceId?: string | null) => Promise<boolean>;
+    mkdir: (category: WorkspaceCategory, relPath: string, workspaceId?: string | null) => Promise<void>;
+    remove: (category: WorkspaceCategory, relPath: string, workspaceId?: string | null) => Promise<void>;
+    rename: (category: WorkspaceCategory, fromRel: string, toRel: string, workspaceId?: string | null) => Promise<void>;
+    resolve: (category: WorkspaceCategory, relPath?: string, workspaceId?: string | null) => Promise<string>;
+    fileUrl: (category: WorkspaceCategory, relPath?: string, workspaceId?: string | null) => Promise<string>;
+    relativePath: (fromCategory: WorkspaceCategory, fromRel: string, toCategory: WorkspaceCategory, toRel: string, workspaceId?: string | null) => Promise<string>;
+    watch: (category: WorkspaceCategory, onChange: (change: FileChange) => void, workspaceId?: string | null) => (() => void);
+}

package/types/Http.d.ts

@@ -0,0 +1,25 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export interface HttpRequest {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | null;
+    timeoutMs?: number;
+    maxBytes?: number;
+}
+export interface HttpResponse {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    finalUrl: string;
+    body: string;
+}
+/**
+ * window.http —— 经主进程发起的任意 http(s) 请求,绕开渲染层 CORS(用于抓取 oEmbed / 链接预览等)。
+ * 主进程仅放行 http/https、拦截内网地址,并带超时与响应体大小上限。
+ */
+export default class Http {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    fetch: (url: string, request?: HttpRequest) => Promise<HttpResponse>;
+}

package/types/IpcRenderer.d.ts

@@ -0,0 +1,12 @@
+import { ipcRenderer } from 'electron';
+export declare class IpcRendererException extends Error {
+    code: string;
+    constructor(code: string, message?: string);
+}
+export default class IpcRenderer {
+    once: (...args: Parameters<typeof ipcRenderer.on>) => Promise<Electron.IpcRenderer>;
+    on: (...args: Parameters<typeof ipcRenderer.on>) => Promise<Electron.IpcRenderer>;
+    off: (...args: Parameters<typeof ipcRenderer.off>) => Promise<Electron.IpcRenderer>;
+    send: (...args: Parameters<typeof ipcRenderer.send>) => Promise<void>;
+    invoke: (...args: Parameters<typeof ipcRenderer.invoke>) => Promise<any>;
+}

package/types/Kb.d.ts

@@ -0,0 +1,16 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export interface KbSearchHit {
+    path: string;
+    title: string;
+    chunk: string;
+    distance: number;
+}
+/** window.kb —— 笔记知识库语义检索(主进程用 provider embedding + sqlite-vec)。 */
+export default class Kb {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    search: (query: string, k?: number) => Promise<KbSearchHit[]>;
+    reindex: (force?: boolean) => Promise<{
+        ok: boolean;
+    }>;
+}

package/types/Mail.d.ts

@@ -0,0 +1,55 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export type MailFolderId = "inbox" | "sent" | "drafts" | "trash" | "junk" | "archive";
+export interface MailAccountInput {
+    email: string;
+    displayName?: string;
+    authUser?: string;
+    password: string;
+    imapHost: string;
+    imapPort: number;
+    imapSecure?: boolean;
+    smtpHost: string;
+    smtpPort: number;
+    smtpSecure?: boolean;
+}
+export interface SendMailInput {
+    to: string;
+    cc?: string;
+    bcc?: string;
+    subject: string;
+    text?: string;
+    html?: string;
+    inReplyTo?: string;
+}
+/**
+ * window.mail —— 经主进程的 IMAP(收)/ SMTP(发)。渲染层无裸 socket,协议封在主进程。
+ * 账户密码经 safeStorage 加密落库;所有调用按 accountId 复用 IMAP 连接。
+ */
+export default class Mail {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    accounts: {
+        list: () => Promise<any>;
+        get: (id: string) => Promise<any>;
+        add: (input: MailAccountInput) => Promise<any>;
+        update: (id: string, patch: Partial<MailAccountInput>) => Promise<any>;
+        remove: (id: string) => Promise<any>;
+        test: (input: MailAccountInput) => Promise<any>;
+    };
+    folders: {
+        list: (accountId: string) => Promise<any>;
+    };
+    messages: {
+        list: (accountId: string, folder: MailFolderId, limit?: number, unseenOnly?: boolean) => Promise<any>;
+        read: (accountId: string, folder: MailFolderId, uid: string) => Promise<any>;
+        flag: (accountId: string, folder: MailFolderId, uid: string, flags: {
+            seen?: boolean;
+            flagged?: boolean;
+        }) => Promise<any>;
+        move: (accountId: string, folder: MailFolderId, uid: string, target: MailFolderId) => Promise<any>;
+        delete: (accountId: string, folder: MailFolderId, uid: string) => Promise<any>;
+    };
+    send: (accountId: string, input: SendMailInput) => Promise<any>;
+    saveDraft: (accountId: string, input: SendMailInput, draftKey?: string) => Promise<any>;
+    discardDraft: (accountId: string, key: string) => Promise<any>;
+}

package/types/Plugin.d.ts

@@ -0,0 +1,32 @@
+import { default as IpcRenderer } from './IpcRenderer';
+import { ToolCall } from 'langchain';
+export interface PluginTool {
+    name: string;
+    cb: (call: ToolCall) => Promise<string>;
+    description: string;
+    schema: string;
+}
+export default class Plugin {
+    private ipcRenderer;
+    private readonly onSearchHandlers;
+    private readonly onActionHandlers;
+    private readonly tools;
+    constructor(ipcRenderer?: IpcRenderer);
+    getTools: () => {
+        name: string;
+        description: string;
+        schema: string;
+    }[];
+    tool: (name: string, description: string, schema: string, cb: any) => any;
+    onSearch: (commandName: string, handler: any) => Promise<void>;
+    onAction: (commandName: string, action: string, handler: any) => Promise<void>;
+    toggleDevTools: () => Promise<any>;
+    setHeight: (height: number) => Promise<any>;
+    floating: (options?: any) => Promise<any>;
+    hide: () => Promise<any>;
+    toggleAlwaysOnTop: () => Promise<any>;
+    info: () => Promise<any>;
+    unregisterCommands: (commands: string[]) => Promise<any>;
+    registerCommands: (commandItems: any[]) => Promise<any>;
+    setCommands: (commandItems: any[]) => Promise<any>;
+}

package/types/PluginCommand.d.ts

@@ -0,0 +1,10 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class PluginCommand {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    open: (commandName?: string, payload?: any) => Promise<any>;
+    enter: (commandName?: string, payload?: any) => Promise<any>;
+    search: (keyword: string) => Promise<any>;
+    setAlias: (name: string, alias: string[]) => Promise<any>;
+    setEnabled: (name: string, enabled: boolean) => Promise<any>;
+}

package/types/PluginManager.d.ts

@@ -0,0 +1,12 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class Plugin {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    toggleDevTools: (pluginId?: string) => Promise<any>;
+    closePlugin: (pluginId?: string) => Promise<any>;
+    getPluginInfo: (pluginId?: string) => Promise<any>;
+    setEnabled: () => Promise<any>;
+    getPlugins: () => Promise<any>;
+    reloadPlugin: (pluginId: string) => Promise<any>;
+    installPlugin: (name: string) => Promise<any>;
+}

package/types/PluginSettings.d.ts

@@ -0,0 +1,9 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class PluginSettings {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    getSettings: () => Promise<any>;
+    getSetting: (key: string) => Promise<any>;
+    saveSetting: (key: string, value: any) => Promise<any>;
+    removeSetting: (key: string) => Promise<any>;
+}

package/types/Sync.d.ts

@@ -0,0 +1,54 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export interface SyncStatusDto {
+    enabled: boolean;
+    configured: boolean;
+    transport: string | null;
+    loggedIn: boolean;
+    running: boolean;
+    lastSyncAt: number | null;
+    lastError: string | null;
+    pushedSeq: number;
+    peers: number;
+    /** 当前同步命名空间 = 账号 ID(消毒为路径安全),即 COS 分区目录名。用于核对多设备是否同一账号。 */
+    namespace: string | null;
+}
+export interface SyncCosConfig {
+    bucket: string;
+    region: string;
+    prefix?: string;
+    secretId?: string;
+    secretKey?: string;
+    sessionToken?: string;
+}
+export interface SyncConfigPatch {
+    enabled?: boolean;
+    transport?: "localdir" | "cos";
+    localDir?: string;
+    passphrase?: string;
+    cos?: SyncCosConfig;
+}
+export interface SyncAppliedPayload {
+    db?: boolean;
+    files?: boolean;
+}
+/**
+ * window.sync —— 数据库/工作空间同步的公共 API(sync.* IPC)。
+ * 状态变更通过 ipcRenderer 的 "sync.statusChanged" 事件推送(渲染层自行监听)。
+ * 同步拉到远端变更后主进程广播 "sync.applied",订阅经 onApplied(本类内部多回调分发,绕开宿主 on 的单监听)。
+ */
+export default class Sync {
+    private transport;
+    private readonly appliedCallbacks;
+    private appliedBound;
+    constructor(transport?: IpcRenderer);
+    getStatus: () => Promise<SyncStatusDto>;
+    /** 改配置(开关 / 传输方式 / 本地目录 / 端到端口令),返回最新状态。 */
+    configure: (patch: SyncConfigPatch) => Promise<SyncStatusDto>;
+    /** 立即同步一次,返回最新状态。 */
+    now: () => Promise<SyncStatusDto>;
+    /**
+     * 订阅"同步已应用"(主进程拉到远端 DB/文件变更后广播)→ 据此重拉刷新。返回退订闭包。
+     * 多订阅者共用单条 ipcRenderer 通道(宿主 on 会 removeAllListeners,故在本实例内自行分发)。
+     */
+    onApplied: (callback: (payload: SyncAppliedPayload) => void) => (() => void);
+}

package/types/System.d.ts

@@ -0,0 +1,50 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class System {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    getPlatform: () => Promise<any>;
+    openMainApp: () => Promise<any>;
+    showAbout: () => Promise<any>;
+    openSettings: () => Promise<any>;
+    checkUpdates: () => Promise<any>;
+    restartApp: () => Promise<any>;
+    quitApp: () => Promise<any>;
+    keepAwake: {
+        enable: (options?: {
+            reason?: string;
+        }) => Promise<{
+            active: boolean;
+            reason: string | null;
+        }>;
+        disable: () => Promise<{
+            active: boolean;
+        }>;
+        toggle: (options?: {
+            reason?: string;
+        }) => Promise<{
+            active: boolean;
+            reason?: string | null;
+        }>;
+        status: () => Promise<{
+            active: boolean;
+            reason: string | null;
+        }>;
+    };
+    scheduledTask: {
+        create: (input: {
+            name: string;
+            cron: string;
+            action: any;
+            enabled?: boolean;
+            timezone?: string;
+        }) => Promise<any>;
+        update: (id: string, patch: any) => Promise<any>;
+        delete: (id: string) => Promise<any>;
+        list: (filter?: {
+            pluginName?: string;
+        }) => Promise<any>;
+        toggle: (id: string, enabled: boolean) => Promise<any>;
+        runNow: (id: string) => Promise<any>;
+        validateCron: (expr: string) => Promise<boolean>;
+    };
+}

package/types/SystemAudio.d.ts

@@ -0,0 +1,8 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class SystemAudio {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    play: (soundName: string) => Promise<any>;
+    stop: () => Promise<any>;
+    list: () => Promise<string[]>;
+}

package/types/SystemBrowser.d.ts

@@ -0,0 +1,256 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export interface SystemBrowserTab {
+    id: number;
+    windowId: number;
+    index: number;
+    url?: string;
+    title?: string;
+    active: boolean;
+    pinned: boolean;
+    audible?: boolean;
+    mutedInfo?: {
+        muted: boolean;
+        reason?: string;
+    };
+    status?: string;
+    favIconUrl?: string;
+    incognito: boolean;
+    groupId?: number;
+}
+export interface SystemBrowserCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    secure: boolean;
+    httpOnly: boolean;
+    sameSite?: string;
+    session: boolean;
+    expirationDate?: number;
+    storeId?: string;
+    hostOnly?: boolean;
+}
+export interface SystemBrowserBookmark {
+    id: string;
+    parentId?: string;
+    index?: number;
+    title: string;
+    url?: string;
+    dateAdded?: number;
+    dateGroupModified?: number;
+    children?: SystemBrowserBookmark[];
+}
+export interface SystemBrowserHttpResponse {
+    status: number;
+    statusText: string;
+    ok: boolean;
+    url: string;
+    redirected: boolean;
+    headers: Record<string, string>;
+    body: string;
+}
+export type SystemBrowserKind = "chrome" | "edge" | "unknown";
+export type SystemBrowserEventName = "browser.tab.created" | "browser.tab.updated" | "browser.tab.removed" | "browser.tab.activated" | "browser.bookmark.created" | "browser.bookmark.changed" | "browser.bookmark.removed" | "browser.bookmark.moved" | "browser.bridge.hello" | "browser.bridge.status";
+export interface SystemBrowserEventEnvelope<T = any> {
+    event: SystemBrowserEventName | string;
+    payload: T;
+    ts: number;
+}
+/**
+ * 暴露给所有 renderer（含 plugin view）的浏览器桥接 API。
+ *
+ * 设计原则：
+ *   - 命名跟 main 侧 IPC 通道一一对应，零运行时翻译，方便排查
+ *   - on/off 监听器走 ipcRenderer 直连而不是 mitt eventBus，因为 plugin view
+ *     的 preload 都是同一份 contextBridge，每个 view 自己监听自己想要的事件
+ */
+export default class SystemBrowser {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    bridge: {
+        status: () => Promise<{
+            connected: boolean;
+            clients: number;
+            browsers: SystemBrowserKind[];
+        }>;
+        ping: () => Promise<{
+            pong: boolean;
+            ts: number;
+        }>;
+    };
+    tabs: {
+        list: (query?: chrome.tabs.QueryInfo & {
+            browser?: SystemBrowserKind;
+        }) => Promise<{
+            tabs: SystemBrowserTab[];
+        }>;
+        get: (tabId: number) => Promise<{
+            tab: SystemBrowserTab;
+        }>;
+        create: (params: {
+            url?: string;
+            active?: boolean;
+            windowId?: number;
+            pinned?: boolean;
+        }) => Promise<{
+            tab: SystemBrowserTab;
+        }>;
+        update: (params: {
+            tabId: number;
+            url?: string;
+            active?: boolean;
+            pinned?: boolean;
+            muted?: boolean;
+        }) => Promise<{
+            tab: SystemBrowserTab;
+        }>;
+        remove: (params: {
+            tabId?: number;
+            tabIds?: number[];
+        }) => Promise<{
+            removed: number[];
+        }>;
+        activate: (tabId: number) => Promise<{
+            tab: SystemBrowserTab;
+        }>;
+        reload: (params: {
+            tabId: number;
+            bypassCache?: boolean;
+        }) => Promise<void>;
+        duplicate: (tabId: number) => Promise<{
+            tab: SystemBrowserTab | null;
+        }>;
+        move: (params: {
+            tabId: number;
+            index: number;
+            windowId?: number;
+        }) => Promise<{
+            tab: SystemBrowserTab;
+        }>;
+    };
+    scripting: {
+        eval: (params: {
+            tabId: number;
+            expression: string;
+            world?: "MAIN" | "ISOLATED";
+            allFrames?: boolean;
+        }) => Promise<any>;
+        execute: (params: {
+            tabId: number;
+            code: string;
+            world?: "MAIN" | "ISOLATED";
+            allFrames?: boolean;
+            args?: any[];
+        }) => Promise<any>;
+        insertCSS: (params: {
+            tabId: number;
+            css: string;
+            allFrames?: boolean;
+        }) => Promise<void>;
+        removeCSS: (params: {
+            tabId: number;
+            css: string;
+            allFrames?: boolean;
+        }) => Promise<void>;
+    };
+    page: {
+        text: (params: {
+            tabId: number;
+            selector?: string;
+            allFrames?: boolean;
+        }) => Promise<any>;
+        click: (params: {
+            tabId: number;
+            selector: string;
+            allFrames?: boolean;
+        }) => Promise<any>;
+        fill: (params: {
+            tabId: number;
+            selector: string;
+            value: string;
+            allFrames?: boolean;
+        }) => Promise<any>;
+    };
+    cookies: {
+        get: (params: {
+            url: string;
+            name: string;
+        }) => Promise<{
+            cookie: SystemBrowserCookie | null;
+        }>;
+        getAll: (params?: {
+            url?: string;
+            domain?: string;
+            name?: string;
+        }) => Promise<{
+            cookies: SystemBrowserCookie[];
+        }>;
+    };
+    http: {
+        fetch: (params: {
+            url: string;
+            method?: string;
+            headers?: Record<string, string>;
+            body?: string | object | null;
+            credentials?: "include" | "same-origin" | "omit";
+            timeoutMs?: number;
+        }) => Promise<SystemBrowserHttpResponse>;
+    };
+    bookmarks: {
+        tree: (params?: {
+            browser?: SystemBrowserKind;
+        }) => Promise<{
+            tree: SystemBrowserBookmark[];
+        }>;
+        list: (params?: {
+            parentId?: string;
+            browser?: SystemBrowserKind;
+        }) => Promise<{
+            items: SystemBrowserBookmark[];
+        }>;
+        get: (id: string) => Promise<{
+            item: SystemBrowserBookmark | null;
+        }>;
+        search: (query: string | {
+            query?: string;
+            url?: string;
+            title?: string;
+            browser?: SystemBrowserKind;
+        }) => Promise<{
+            items: SystemBrowserBookmark[];
+        }>;
+        create: (params: {
+            parentId?: string;
+            title?: string;
+            url?: string;
+            index?: number;
+        }) => Promise<{
+            item: SystemBrowserBookmark;
+        }>;
+        update: (params: {
+            id: string;
+            title?: string;
+            url?: string;
+        }) => Promise<{
+            item: SystemBrowserBookmark;
+        }>;
+        move: (params: {
+            id: string;
+            parentId?: string;
+            index?: number;
+        }) => Promise<{
+            item: SystemBrowserBookmark;
+        }>;
+        remove: (id: string) => Promise<void>;
+        removeTree: (id: string) => Promise<void>;
+    };
+    /**
+     * 订阅扩展事件（tab/bookmark 生命周期 + 桥接连接状态）。返回反订阅函数。
+     *
+     *     const off = window.systemBrowser.events.on("browser.tab.updated", (e) => {...});
+     *     off();
+     */
+    events: {
+        on: <T = any>(event: SystemBrowserEventName | "*", handler: (envelope: SystemBrowserEventEnvelope<T>) => void) => (() => void);
+    };
+}

package/types/SystemClipboard.d.ts

@@ -0,0 +1,8 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class SystemClipboard {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    read: () => Promise<any>;
+    write: (content: any) => Promise<any>;
+    clear: () => Promise<any>;
+}

package/types/SystemKeyboard.d.ts

@@ -0,0 +1,7 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class SystemKeyboard {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    type: (text: string) => Promise<any>;
+    copy: () => Promise<any>;
+}

package/types/SystemMouse.d.ts

@@ -0,0 +1,13 @@
+import { default as IpcRenderer } from './IpcRenderer';
+import { Point } from '@computer-use/nut-js';
+export default class SystemMouse {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    clickText: (text: string) => Promise<any>;
+    click: (base64String: string) => Promise<any>;
+    clickAt: (point: Point) => Promise<any>;
+    move: (base64String: string) => Promise<any>;
+    moveTo: (point: Point) => Promise<any>;
+    doubleClickAt: (point: Point) => Promise<any>;
+    rightClickAt: (point: Point) => Promise<any>;
+}

package/types/SystemNotification.d.ts

@@ -0,0 +1,18 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export interface SystemNotificationOptions {
+    title: string;
+    body?: string;
+    /** 不播放系统提示音 */
+    silent?: boolean;
+    /** 副标题,仅 macOS 生效 */
+    subtitle?: string;
+}
+export default class SystemNotification {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    isSupported: () => Promise<boolean>;
+    show: (options: SystemNotificationOptions) => Promise<string | null>;
+    close: (id: string) => Promise<boolean>;
+    onClicked: (handler: (id: string) => void) => Promise<Electron.IpcRenderer>;
+    onClosed: (handler: (id: string) => void) => Promise<Electron.IpcRenderer>;
+}

package/types/SystemOCR.d.ts

@@ -0,0 +1,6 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class SystemOCR {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    recognize: (base64String: string) => Promise<any>;
+}

package/types/SystemScreen.d.ts

@@ -0,0 +1,14 @@
+import { default as IpcRenderer } from './IpcRenderer';
+import { Point } from '@computer-use/nut-js';
+export default class SystemScreen {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    captureScene: () => Promise<any>;
+    captureDisplay: (displayId?: number) => Promise<any>;
+    listDisplays: () => Promise<any>;
+    getCursorPoint: () => Promise<any>;
+    find: (base64String: string) => Promise<any>;
+    waitFor: (base64String: any) => Promise<any>;
+    waitForText: (text: string) => Promise<any>;
+    colorAt: (point: Point) => Promise<any>;
+}

package/types/SystemSetting.d.ts

@@ -0,0 +1,11 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class SystemSetting {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    getSettings: () => Promise<any>;
+    getSettingValue: (key: string) => Promise<any>;
+    saveSettings: (values: {
+        [x: string]: any;
+    }) => Promise<any>;
+    saveSetting: (settingInput: any) => Promise<any>;
+}

package/types/SystemShell.d.ts

@@ -0,0 +1,18 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class SystemShell {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    openExternal: (url: string, options?: Electron.OpenExternalOptions) => Promise<any>;
+    openPath: (path: string) => Promise<any>;
+    /** 在资源管理器/Finder 中显示并选中该文件(或文件夹) */
+    showItemInFolder: (path: string) => Promise<any>;
+    openTerminal: (options?: {
+        command?: string;
+        cwd?: string;
+    }) => Promise<any>;
+    listTerminals: () => Promise<Array<{
+        id: string;
+        label: string;
+        available: boolean;
+    }>>;
+}

package/types/SystemShortcut.d.ts

@@ -0,0 +1,8 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class SystemShortcut {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    getShortcuts: () => Promise<any>;
+    removeShortcut: (commandName: string) => Promise<any>;
+    setShortcut: (name: string, shortcut?: string) => Promise<any>;
+}

package/types/SystemWindow.d.ts

@@ -0,0 +1,15 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export default class SystemWindow {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    toast: (type: "info" | "success" | "warn" | "error", text: string) => Promise<any>;
+    hide: () => Promise<any>;
+    setHeight: (height: number) => Promise<any>;
+    goHome: () => Promise<any>;
+    open: (url: string, options?: any) => Promise<any>;
+    showOpenDialog: (options?: Electron.OpenDialogOptions) => Promise<any>;
+    saveText: (content: string, options?: {
+        defaultName?: string;
+        filters?: Electron.FileFilter[];
+    }) => Promise<string | null>;
+}

package/types/Workspace.d.ts

@@ -0,0 +1,51 @@
+import { default as IpcRenderer } from './IpcRenderer';
+export interface WorkspaceDto {
+    id: string;
+    name: string;
+    path: string;
+    kind: "local" | "cloud";
+    state: "active" | "indexing" | "stale" | "disabled";
+    isDefault: boolean;
+    includeGlobs?: string[] | null;
+    excludeGlobs?: string[] | null;
+    indexFlags: {
+        filename: boolean;
+        content: boolean;
+    };
+    embedModel?: string | null;
+    lastIndexedAt?: string | null;
+    lastOpenedAt?: string | null;
+    openedCount: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface RegisterWorkspaceInputDto {
+    name?: string;
+    path: string;
+    includeGlobs?: string[];
+    excludeGlobs?: string[];
+    indexFlags?: Partial<{
+        filename: boolean;
+        content: boolean;
+    }>;
+}
+/**
+ * window.workspace —— 宿主级工作空间公共 API(workspace.* IPC)。
+ * 所有插件(settings 面板 / copilot 反射 / 主搜索框)统一经此消费,不自持注册表。
+ */
+export default class Workspace {
+    private transport;
+    constructor(transport?: IpcRenderer);
+    list: () => Promise<WorkspaceDto[]>;
+    get: (id: string) => Promise<WorkspaceDto | null>;
+    register: (input: RegisterWorkspaceInputDto) => Promise<WorkspaceDto>;
+    update: (id: string, patch: Partial<WorkspaceDto>) => Promise<WorkspaceDto | null>;
+    /** 目录被移动/改名后重定位:只换路径,索引数据原封不动。 */
+    relocate: (id: string, newPath: string) => Promise<WorkspaceDto | null>;
+    /** 暂停(false)/恢复(true)。暂停只停监听,索引与配置保留。 */
+    toggle: (id: string, enabled: boolean) => Promise<WorkspaceDto | null>;
+    /** 注销(不删文件)。默认工作空间不可删除。 */
+    remove: (id: string) => Promise<boolean>;
+    /** 使用打点(recents 排序)。 */
+    touch: (id: string) => Promise<void>;
+}

package/types/index.d.ts

@@ -0,0 +1,67 @@
+import { default as Account } from './Account';
+import { default as Copilot } from './Copilot';
+import { default as CopilotSubAgent } from './CopilotSubAgent';
+import { default as CopilotMcpServer } from './CopilotMcpServer';
+import { default as CopilotModel } from './CopilotModel';
+import { default as CopilotThread } from './CopilotThread';
+import { default as Plugin } from './Plugin';
+import { default as PluginCommand } from './PluginCommand';
+import { default as PluginSettings } from './PluginSettings';
+import { default as System } from './System';
+import { default as SystemAudio } from './SystemAudio';
+import { default as SystemClipboard } from './SystemClipboard';
+import { default as SystemKeyboard } from './SystemKeyboard';
+import { default as SystemMouse } from './SystemMouse';
+import { default as SystemOCR } from './SystemOCR';
+import { default as SystemSetting } from './SystemSetting';
+import { default as SystemShell } from './SystemShell';
+import { default as SystemBrowser } from './SystemBrowser';
+import { default as SystemShortcut } from './SystemShortcut';
+import { default as SystemWindow } from './SystemWindow';
+import { default as CopilotWechatBridge } from './CopilotWechatBridge';
+import { default as Workspace } from './Workspace';
+import { default as File } from './File';
+import { default as Http } from './Http';
+import { default as Kb } from './Kb';
+import { default as Mail } from './Mail';
+import { default as Sync } from './Sync';
+import { default as SystemNotification } from './SystemNotification';
+import { default as IpcRenderer } from './IpcRenderer';
+declare global {
+    interface Window {
+        ipcRenderer: IpcRenderer;
+        eventBus: {
+            on(event: string, handler: (data: unknown) => void): () => void;
+            off(event: string, handler: (data: unknown) => void): void;
+            emit(event: string, data: unknown): void;
+        };
+        account: Account;
+        copilot: Copilot;
+        copilotSubagent: CopilotSubAgent;
+        copilotMcpServer: CopilotMcpServer;
+        copilotModel: CopilotModel;
+        copilotThread: CopilotThread;
+        plugin: Plugin;
+        pluginCommand: PluginCommand;
+        pluginSettings: PluginSettings;
+        system: System;
+        systemAudio: SystemAudio;
+        systemClipboard: SystemClipboard;
+        systemKeyboard: SystemKeyboard;
+        systemMouse: SystemMouse;
+        systemOCR: SystemOCR;
+        systemSetting: SystemSetting;
+        systemShell: SystemShell;
+        systemBrowser: SystemBrowser;
+        systemShortcut: SystemShortcut;
+        systemWindow: SystemWindow;
+        systemNotification: SystemNotification;
+        copilotWechatBridge: CopilotWechatBridge;
+        workspace: Workspace;
+        file: File;
+        http: Http;
+        kb: Kb;
+        mail: Mail;
+        sync: Sync;
+    }
+}