1072 lines
33 KiB
TypeScript
1072 lines
33 KiB
TypeScript
import { contextBridge, ipcRenderer, webUtils } from 'electron'
|
|
import {
|
|
type ApprovalDecision,
|
|
type AgentEvent,
|
|
type AgentQuestionAnswer,
|
|
type AgentRequest,
|
|
type AgentRuntimeDetection,
|
|
type AgentRuntimeStatus,
|
|
type AppInfo,
|
|
type BrowserLiveState,
|
|
type ContextAttachment,
|
|
type ContextFileSelectionProgress,
|
|
type DesktopApi,
|
|
type KnowledgeLibrary,
|
|
type KnowledgeSearchReference,
|
|
type KnowledgeSnapshot,
|
|
type PastedImageInput,
|
|
type RuntimeSettings,
|
|
type RuntimeSettingsInput,
|
|
type RuntimeConfigActionInput,
|
|
type RuntimeFileSelectionKind,
|
|
type WindowCaptureOption
|
|
} from '../shared/contracts'
|
|
import { ipcChannels } from '../shared/ipc-channels'
|
|
import type {
|
|
BrowserProfileCreateInput,
|
|
BrowserProfileRenameInput,
|
|
CapabilityDiagnosticReport,
|
|
CapabilitySnapshot,
|
|
ComputerCapabilityId,
|
|
McpServerTestResult,
|
|
WebSearchTestResult
|
|
} from '../shared/capability-contracts'
|
|
import type {
|
|
AssistantProject,
|
|
AssistantArtifact,
|
|
AssistantMemory,
|
|
AssistantSchedule,
|
|
AssistantHeartbeatConfig,
|
|
AssistantHeartbeatEntry,
|
|
AssistantHeartbeatRun,
|
|
AssistantExpert,
|
|
AssistantTask,
|
|
TokenUsageSummary,
|
|
ConversationSnapshot,
|
|
WorkspaceChanges,
|
|
WorkspaceDirectoryListing,
|
|
WorkspaceFilePreview,
|
|
ProjectCreateInput,
|
|
MemoryCreateInput,
|
|
ScheduleCreateInput,
|
|
HeartbeatCreateInput,
|
|
HeartbeatUpdateInput,
|
|
ExpertCreateInput,
|
|
ExpertUpdateInput
|
|
} from '../shared/assistant-contracts'
|
|
import type {
|
|
ChannelConnectionTestResult,
|
|
ChannelSettingsApply,
|
|
ChannelSettingsSnapshot,
|
|
CredentialChannel,
|
|
DingTalkChannelSettingsInput,
|
|
WeComChannelSettingsInput
|
|
} from '../shared/channel-settings-contracts'
|
|
import type {
|
|
ApplicationSettings,
|
|
ApplicationSettingsUpdate,
|
|
VersionCheckResult
|
|
} from '../shared/application-settings-contracts'
|
|
import type { ReleaseNotesSnapshot } from '../shared/release-notes-contracts'
|
|
import type {
|
|
SpeechModelSnapshot,
|
|
SpeechTranscriptionInput,
|
|
SpeechTranscriptionResult
|
|
} from '../shared/speech-model-contracts'
|
|
import type {
|
|
EmbeddingDiagnosticResult,
|
|
EmbeddingIndexStatus,
|
|
EmbeddingSettingsSnapshot
|
|
} from '../shared/embedding-contracts'
|
|
import type {
|
|
DocumentOcrAssets,
|
|
DocumentOcrFailure,
|
|
DocumentOcrRequest,
|
|
DocumentOcrResult,
|
|
DocumentParsingDiagnostic,
|
|
DocumentParsingSettings,
|
|
DocumentParsingSnapshot
|
|
} from '../shared/document-parsing-contracts'
|
|
import type { AgentRuntimeSelection } from '../shared/runtime-selection-contracts'
|
|
import type { WeixinBindingSnapshot } from '../shared/weixin-channel-contracts'
|
|
import type { RemoteChannelActivity } from '../shared/remote-channel-contracts'
|
|
import type {
|
|
MagicNoteAnalysisStreamEvent,
|
|
MagicNoteDraftAnalysis,
|
|
MagicNoteDetail,
|
|
MagicNotesSnapshot,
|
|
MagicTodoItem,
|
|
MagicTodosSnapshot
|
|
} from '../shared/magic-notes-contracts'
|
|
|
|
const desktopApi: DesktopApi = {
|
|
app: {
|
|
getInfo: () => ipcRenderer.invoke(ipcChannels.appInfo) as Promise<AppInfo>,
|
|
show: async () => {
|
|
await ipcRenderer.invoke(ipcChannels.appShow)
|
|
},
|
|
hide: async () => {
|
|
await ipcRenderer.invoke(ipcChannels.appHide)
|
|
},
|
|
minimize: async () => {
|
|
await ipcRenderer.invoke(ipcChannels.windowMinimize)
|
|
},
|
|
toggleMaximize: async () => {
|
|
await ipcRenderer.invoke(ipcChannels.windowToggleMaximize)
|
|
},
|
|
close: async () => {
|
|
await ipcRenderer.invoke(ipcChannels.windowClose)
|
|
},
|
|
isMaximized: () =>
|
|
ipcRenderer.invoke(ipcChannels.windowIsMaximized) as Promise<boolean>,
|
|
onMaximizedChanged: (listener) => {
|
|
const handler = (
|
|
_event: Electron.IpcRendererEvent,
|
|
maximized: boolean
|
|
): void => listener(maximized)
|
|
ipcRenderer.on(ipcChannels.windowMaximizedChanged, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(
|
|
ipcChannels.windowMaximizedChanged,
|
|
handler
|
|
)
|
|
},
|
|
clearLocalData: async () => {
|
|
await ipcRenderer.invoke(ipcChannels.appClearLocalData)
|
|
},
|
|
onNewConversation: (listener) => {
|
|
const handler = (): void => listener()
|
|
ipcRenderer.on(ipcChannels.conversationNew, handler)
|
|
return () => ipcRenderer.removeListener(ipcChannels.conversationNew, handler)
|
|
},
|
|
onOpenSettings: (listener) => {
|
|
const handler = (): void => listener()
|
|
ipcRenderer.on(ipcChannels.settingsOpen, handler)
|
|
return () => ipcRenderer.removeListener(ipcChannels.settingsOpen, handler)
|
|
}
|
|
},
|
|
agent: {
|
|
getStatus: (selection) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.agentStatus,
|
|
selection
|
|
) as Promise<AgentRuntimeStatus>,
|
|
run: async (request: AgentRequest) => {
|
|
await ipcRenderer.invoke(ipcChannels.agentRun, request)
|
|
},
|
|
cancel: async (requestId: string) => {
|
|
await ipcRenderer.invoke(ipcChannels.agentCancel, requestId)
|
|
},
|
|
respondApproval: async (
|
|
approvalId: string,
|
|
decision: ApprovalDecision
|
|
) => {
|
|
await ipcRenderer.invoke(ipcChannels.agentApprovalRespond, {
|
|
approvalId,
|
|
decision
|
|
})
|
|
},
|
|
respondQuestion: async (
|
|
questionId: string,
|
|
answers?: AgentQuestionAnswer[]
|
|
) => {
|
|
await ipcRenderer.invoke(ipcChannels.agentQuestionRespond, {
|
|
questionId,
|
|
answers: answers ?? []
|
|
})
|
|
},
|
|
onEvent: (listener) => {
|
|
const handler = (_event: Electron.IpcRendererEvent, payload: AgentEvent): void =>
|
|
listener(payload)
|
|
ipcRenderer.on(ipcChannels.agentEvent, handler)
|
|
return () => ipcRenderer.removeListener(ipcChannels.agentEvent, handler)
|
|
}
|
|
},
|
|
browser: {
|
|
interact: async (conversationId: string) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.browserInteract,
|
|
{ conversationId }
|
|
)
|
|
},
|
|
stop: async (conversationId: string) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.browserStop,
|
|
{ conversationId }
|
|
)
|
|
},
|
|
onState: (listener) => {
|
|
const handler = (
|
|
_event: Electron.IpcRendererEvent,
|
|
payload: BrowserLiveState
|
|
): void => listener(payload)
|
|
ipcRenderer.on(ipcChannels.browserState, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(ipcChannels.browserState, handler)
|
|
}
|
|
},
|
|
settings: {
|
|
getRuntime: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.runtimeSettingsGet
|
|
) as Promise<RuntimeSettings>,
|
|
updateRuntime: (input: RuntimeSettingsInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.runtimeSettingsUpdate,
|
|
input
|
|
) as Promise<RuntimeSettings>,
|
|
selectWorkspace: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.runtimeSettingsSelectWorkspace
|
|
) as Promise<string | undefined>,
|
|
detectAgentRuntimes: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.runtimeSettingsDetect
|
|
) as Promise<AgentRuntimeDetection>,
|
|
selectRuntimeFile: (kind: RuntimeFileSelectionKind) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.runtimeSettingsSelectFile,
|
|
kind
|
|
) as Promise<string | undefined>,
|
|
openRuntimeConfig: async (input: RuntimeConfigActionInput) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.runtimeSettingsOpenConfig,
|
|
input
|
|
)
|
|
},
|
|
testModelConnection: (profileId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.runtimeSettingsTestModel,
|
|
profileId
|
|
) as Promise<AgentRuntimeStatus>,
|
|
testRuntime: (selection: AgentRuntimeSelection) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.runtimeSettingsTest,
|
|
selection
|
|
) as Promise<AgentRuntimeStatus>
|
|
},
|
|
channels: {
|
|
getSnapshot: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.channelSettingsGet
|
|
) as Promise<ChannelSettingsSnapshot>,
|
|
apply: (input: ChannelSettingsApply) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.channelSettingsApply,
|
|
input
|
|
) as Promise<ChannelSettingsSnapshot>,
|
|
testConnection: (
|
|
channel: CredentialChannel,
|
|
settings?: WeComChannelSettingsInput | DingTalkChannelSettingsInput
|
|
) =>
|
|
ipcRenderer.invoke(ipcChannels.channelSettingsTest, {
|
|
channel,
|
|
settings
|
|
}) as Promise<ChannelConnectionTestResult>,
|
|
getWeixinBinding: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.weixinBindingGet
|
|
) as Promise<WeixinBindingSnapshot>,
|
|
startWeixinBinding: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.weixinBindingStart
|
|
) as Promise<WeixinBindingSnapshot>,
|
|
submitWeixinVerification: (code: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.weixinBindingVerify,
|
|
{ code }
|
|
) as Promise<WeixinBindingSnapshot>,
|
|
disconnectWeixin: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.weixinBindingDisconnect
|
|
) as Promise<WeixinBindingSnapshot>,
|
|
onWeixinBindingChanged: (listener) => {
|
|
const handler = (
|
|
_event: Electron.IpcRendererEvent,
|
|
snapshot: WeixinBindingSnapshot
|
|
): void => listener(snapshot)
|
|
ipcRenderer.on(ipcChannels.weixinBindingChanged, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(
|
|
ipcChannels.weixinBindingChanged,
|
|
handler
|
|
)
|
|
},
|
|
onRemoteActivity: (listener) => {
|
|
const handler = (
|
|
_event: Electron.IpcRendererEvent,
|
|
activity: RemoteChannelActivity
|
|
): void => listener(activity)
|
|
ipcRenderer.on(ipcChannels.remoteChannelActivity, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(
|
|
ipcChannels.remoteChannelActivity,
|
|
handler
|
|
)
|
|
}
|
|
},
|
|
updates: {
|
|
getSettings: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.applicationSettingsGet
|
|
) as Promise<ApplicationSettings>,
|
|
updateSettings: (input: ApplicationSettingsUpdate) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.applicationSettingsUpdate,
|
|
input
|
|
) as Promise<ApplicationSettings>,
|
|
check: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.versionCheck
|
|
) as Promise<VersionCheckResult>,
|
|
openReleasePage: async () => {
|
|
await ipcRenderer.invoke(ipcChannels.versionOpenReleasePage)
|
|
},
|
|
onResult: (listener) => {
|
|
const handler = (
|
|
_event: Electron.IpcRendererEvent,
|
|
result: VersionCheckResult
|
|
): void => listener(result)
|
|
ipcRenderer.on(ipcChannels.versionCheckResult, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(ipcChannels.versionCheckResult, handler)
|
|
}
|
|
},
|
|
releaseNotes: {
|
|
getPending: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.releaseNotesGetPending
|
|
) as Promise<ReleaseNotesSnapshot>,
|
|
acknowledge: async (version: string) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.releaseNotesAcknowledge,
|
|
{ version }
|
|
)
|
|
}
|
|
},
|
|
speechModels: {
|
|
getSnapshot: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.speechModelsGet
|
|
) as Promise<SpeechModelSnapshot>,
|
|
install: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.speechModelsInstall,
|
|
{ modelId }
|
|
) as Promise<SpeechModelSnapshot>,
|
|
cancel: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.speechModelsCancel,
|
|
{ modelId }
|
|
) as Promise<boolean>,
|
|
remove: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.speechModelsRemove,
|
|
{ modelId }
|
|
) as Promise<SpeechModelSnapshot>,
|
|
select: (modelId: string | null) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.speechModelsSelect,
|
|
{ modelId }
|
|
) as Promise<SpeechModelSnapshot>,
|
|
importArchive: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.speechModelsImportArchive,
|
|
{ modelId }
|
|
) as Promise<SpeechModelSnapshot | undefined>,
|
|
exportArchive: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.speechModelsExportArchive,
|
|
{ modelId }
|
|
) as Promise<SpeechModelSnapshot | undefined>,
|
|
openRepository: async (modelId: string) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.speechModelsOpenRepository,
|
|
{ modelId }
|
|
)
|
|
},
|
|
openModelsDirectory: async () => {
|
|
await ipcRenderer.invoke(ipcChannels.speechModelsOpenDirectory)
|
|
}
|
|
},
|
|
speech: {
|
|
transcribe: (input: SpeechTranscriptionInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.speechTranscribe,
|
|
input
|
|
) as Promise<SpeechTranscriptionResult>,
|
|
cancel: (requestId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.speechTranscriptionCancel,
|
|
requestId
|
|
) as Promise<boolean>
|
|
},
|
|
embeddings: {
|
|
getSnapshot: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.embeddingSettingsGet
|
|
) as Promise<EmbeddingSettingsSnapshot>,
|
|
diagnose: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.embeddingDiagnose
|
|
) as Promise<EmbeddingDiagnosticResult>,
|
|
rebuild: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.embeddingIndexRebuild
|
|
) as Promise<EmbeddingIndexStatus>,
|
|
cancel: (jobId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.embeddingIndexCancel,
|
|
{ jobId }
|
|
) as Promise<boolean>,
|
|
onStatus: (listener) => {
|
|
const handler = (
|
|
_event: Electron.IpcRendererEvent,
|
|
status: EmbeddingIndexStatus
|
|
): void => listener(status)
|
|
ipcRenderer.on(ipcChannels.embeddingIndexStatusChanged, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(
|
|
ipcChannels.embeddingIndexStatusChanged,
|
|
handler
|
|
)
|
|
}
|
|
},
|
|
documentParsing: {
|
|
getSnapshot: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.documentParsingGet
|
|
) as Promise<DocumentParsingSnapshot>,
|
|
update: (input: DocumentParsingSettings) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.documentParsingUpdate,
|
|
input
|
|
) as Promise<DocumentParsingSnapshot>,
|
|
test: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.documentParsingTest
|
|
) as Promise<DocumentParsingDiagnostic | undefined>,
|
|
installOcrModel: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.documentOcrModelsInstall,
|
|
{ modelId }
|
|
) as Promise<DocumentParsingSnapshot>,
|
|
cancelOcrModelOperation: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.documentOcrModelsCancel,
|
|
{ modelId }
|
|
) as Promise<boolean>,
|
|
removeOcrModel: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.documentOcrModelsRemove,
|
|
{ modelId }
|
|
) as Promise<DocumentParsingSnapshot>,
|
|
importOcrModelArchive: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.documentOcrModelsImportArchive,
|
|
{ modelId }
|
|
) as Promise<DocumentParsingSnapshot | undefined>,
|
|
exportOcrModelArchive: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.documentOcrModelsExportArchive,
|
|
{ modelId }
|
|
) as Promise<DocumentParsingSnapshot | undefined>,
|
|
openOcrModelRepository: async (modelId: string) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.documentOcrModelsOpenRepository,
|
|
{ modelId }
|
|
)
|
|
},
|
|
openOcrModelsDirectory: async () => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.documentOcrModelsOpenDirectory
|
|
)
|
|
},
|
|
getOcrAssets: (modelId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.documentParsingOcrAssets,
|
|
{ modelId }
|
|
) as Promise<DocumentOcrAssets>,
|
|
respondOcr: async (
|
|
response: DocumentOcrResult | DocumentOcrFailure
|
|
) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.documentParsingOcrRespond,
|
|
response
|
|
)
|
|
},
|
|
onOcrRequest: (listener) => {
|
|
const handler = (
|
|
_event: Electron.IpcRendererEvent,
|
|
request: DocumentOcrRequest
|
|
): void => listener(request)
|
|
ipcRenderer.on(ipcChannels.documentParsingOcrRequest, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(
|
|
ipcChannels.documentParsingOcrRequest,
|
|
handler
|
|
)
|
|
},
|
|
onOcrCancel: (listener) => {
|
|
const handler = (
|
|
_event: Electron.IpcRendererEvent,
|
|
requestId: string
|
|
): void => listener(requestId)
|
|
ipcRenderer.on(ipcChannels.documentParsingOcrCancel, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(
|
|
ipcChannels.documentParsingOcrCancel,
|
|
handler
|
|
)
|
|
}
|
|
},
|
|
projects: {
|
|
list: (includeArchived = false) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.projectsList,
|
|
includeArchived
|
|
) as Promise<AssistantProject[]>,
|
|
create: (input: ProjectCreateInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.projectsCreate,
|
|
input
|
|
) as Promise<AssistantProject>,
|
|
update: (projectId: string, input: ProjectCreateInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.projectsUpdate,
|
|
{ projectId, input }
|
|
) as Promise<AssistantProject>,
|
|
setArchived: async (projectId: string, archived: boolean) => {
|
|
await ipcRenderer.invoke(ipcChannels.projectsSetArchived, {
|
|
projectId,
|
|
archived
|
|
})
|
|
},
|
|
delete: async (projectId: string, confirmation: string) => {
|
|
await ipcRenderer.invoke(ipcChannels.projectsDelete, {
|
|
projectId,
|
|
confirmation
|
|
})
|
|
}
|
|
},
|
|
conversations: {
|
|
list: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.conversationsList
|
|
) as Promise<ConversationSnapshot[]>,
|
|
replace: async (conversations: ConversationSnapshot[]) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.conversationsReplace,
|
|
conversations
|
|
)
|
|
},
|
|
onChanged: (listener) => {
|
|
const handler = (): void => listener()
|
|
ipcRenderer.on(ipcChannels.conversationsChanged, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(
|
|
ipcChannels.conversationsChanged,
|
|
handler
|
|
)
|
|
}
|
|
},
|
|
workspace: {
|
|
getChanges: (projectId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.workspaceChangesGet,
|
|
projectId
|
|
) as Promise<WorkspaceChanges>,
|
|
listDirectory: (projectId: string, path: string) =>
|
|
ipcRenderer.invoke(ipcChannels.workspaceDirectoryList, {
|
|
projectId,
|
|
path
|
|
}) as Promise<WorkspaceDirectoryListing>,
|
|
readFile: (projectId: string, path: string) =>
|
|
ipcRenderer.invoke(ipcChannels.workspaceFileRead, {
|
|
projectId,
|
|
path
|
|
}) as Promise<WorkspaceFilePreview>,
|
|
openPath: async (
|
|
projectId: string,
|
|
path: string,
|
|
type: 'file' | 'directory'
|
|
) => {
|
|
await ipcRenderer.invoke(ipcChannels.workspacePathOpen, {
|
|
projectId,
|
|
path,
|
|
type
|
|
})
|
|
}
|
|
},
|
|
tasks: {
|
|
list: () =>
|
|
ipcRenderer.invoke(ipcChannels.tasksList) as Promise<AssistantTask[]>,
|
|
setStatus: async (
|
|
taskId: string,
|
|
status: 'completed' | 'cancelled'
|
|
) => {
|
|
await ipcRenderer.invoke(ipcChannels.tasksSetStatus, {
|
|
taskId,
|
|
status
|
|
})
|
|
}
|
|
},
|
|
usage: {
|
|
getTokenSummary: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.tokenUsageSummary
|
|
) as Promise<TokenUsageSummary>
|
|
},
|
|
artifacts: {
|
|
list: (projectId?: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.artifactsList,
|
|
projectId
|
|
) as Promise<AssistantArtifact[]>,
|
|
get: (artifactId: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.artifactsGet,
|
|
artifactId
|
|
) as Promise<AssistantArtifact>,
|
|
importFiles: (projectId?: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.artifactsImportFiles,
|
|
projectId
|
|
) as Promise<AssistantArtifact[]>
|
|
},
|
|
memory: {
|
|
list: (scopeId?: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.memoryList,
|
|
scopeId
|
|
) as Promise<AssistantMemory[]>,
|
|
create: (input: MemoryCreateInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.memoryCreate,
|
|
input
|
|
) as Promise<AssistantMemory>,
|
|
setStatus: async (
|
|
memoryId: string,
|
|
status: AssistantMemory['status']
|
|
) => {
|
|
await ipcRenderer.invoke(ipcChannels.memorySetStatus, {
|
|
memoryId,
|
|
status
|
|
})
|
|
},
|
|
remove: async (memoryId: string) => {
|
|
await ipcRenderer.invoke(ipcChannels.memoryRemove, memoryId)
|
|
}
|
|
},
|
|
schedules: {
|
|
list: (projectId?: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.schedulesList,
|
|
projectId
|
|
) as Promise<AssistantSchedule[]>,
|
|
create: (input: ScheduleCreateInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.schedulesCreate,
|
|
input
|
|
) as Promise<AssistantSchedule>,
|
|
setEnabled: async (scheduleId: string, enabled: boolean) => {
|
|
await ipcRenderer.invoke(ipcChannels.schedulesSetEnabled, {
|
|
scheduleId,
|
|
enabled
|
|
})
|
|
},
|
|
remove: async (scheduleId: string) => {
|
|
await ipcRenderer.invoke(ipcChannels.schedulesRemove, scheduleId)
|
|
},
|
|
runNow: async (scheduleId: string) => {
|
|
await ipcRenderer.invoke(ipcChannels.schedulesRunNow, scheduleId)
|
|
}
|
|
},
|
|
heartbeats: {
|
|
list: (projectId?: string) =>
|
|
ipcRenderer.invoke(ipcChannels.heartbeatsList, {
|
|
projectId
|
|
}) as Promise<AssistantHeartbeatConfig[]>,
|
|
create: (input: HeartbeatCreateInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.heartbeatsCreate,
|
|
input
|
|
) as Promise<AssistantHeartbeatConfig>,
|
|
update: (heartbeatId: string, input: HeartbeatUpdateInput) =>
|
|
ipcRenderer.invoke(ipcChannels.heartbeatsUpdate, {
|
|
id: heartbeatId,
|
|
config: input
|
|
}) as Promise<AssistantHeartbeatConfig>,
|
|
setPaused: async (heartbeatId: string, paused: boolean) => {
|
|
await ipcRenderer.invoke(ipcChannels.heartbeatsSetPaused, {
|
|
id: heartbeatId,
|
|
paused
|
|
})
|
|
},
|
|
remove: async (heartbeatId: string) => {
|
|
await ipcRenderer.invoke(ipcChannels.heartbeatsRemove, {
|
|
id: heartbeatId
|
|
})
|
|
},
|
|
runNow: (heartbeatId: string) =>
|
|
ipcRenderer.invoke(ipcChannels.heartbeatsRunNow, {
|
|
id: heartbeatId,
|
|
idempotencyKey: crypto.randomUUID()
|
|
}) as Promise<AssistantHeartbeatRun>,
|
|
history: (heartbeatId?: string) =>
|
|
ipcRenderer.invoke(ipcChannels.heartbeatsHistory, {
|
|
configId: heartbeatId,
|
|
limit: 200
|
|
}) as Promise<{
|
|
runs: AssistantHeartbeatRun[]
|
|
entries: AssistantHeartbeatEntry[]
|
|
}>
|
|
},
|
|
experts: {
|
|
list: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.expertsList
|
|
) as Promise<AssistantExpert[]>,
|
|
create: (input: ExpertCreateInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.expertsCreate,
|
|
input
|
|
) as Promise<AssistantExpert>,
|
|
update: (expertId: string, input: ExpertUpdateInput) =>
|
|
ipcRenderer.invoke(ipcChannels.expertsUpdate, {
|
|
expertId,
|
|
input
|
|
}) as Promise<AssistantExpert>,
|
|
remove: async (expertId: string) => {
|
|
await ipcRenderer.invoke(ipcChannels.expertsRemove, expertId)
|
|
}
|
|
},
|
|
capabilities: {
|
|
getSnapshot: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.capabilitiesSnapshot
|
|
) as Promise<CapabilitySnapshot>,
|
|
importSkill: (kind) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.capabilitiesImportSkill,
|
|
kind
|
|
) as Promise<CapabilitySnapshot>,
|
|
removeSkill: (skillId) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.capabilitiesRemoveSkill,
|
|
skillId
|
|
) as Promise<CapabilitySnapshot>,
|
|
setSkillEnabled: (skillId, enabled) =>
|
|
ipcRenderer.invoke(ipcChannels.capabilitiesToggleSkill, {
|
|
skillId,
|
|
enabled
|
|
}) as Promise<CapabilitySnapshot>,
|
|
setSkillAssignments: (skillId, assignments) =>
|
|
ipcRenderer.invoke(ipcChannels.capabilitiesAssignSkill, {
|
|
skillId,
|
|
assignments
|
|
}) as Promise<CapabilitySnapshot>,
|
|
saveMcpServer: (serverId, input) =>
|
|
ipcRenderer.invoke(ipcChannels.capabilitiesSaveMcp, {
|
|
serverId,
|
|
input
|
|
}) as Promise<CapabilitySnapshot>,
|
|
removeMcpServer: (serverId) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.capabilitiesRemoveMcp,
|
|
serverId
|
|
) as Promise<CapabilitySnapshot>,
|
|
testMcpServer: (serverId) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.capabilitiesTestMcp,
|
|
serverId
|
|
) as Promise<McpServerTestResult>,
|
|
setWebSearchEnabled: (enabled: boolean) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.capabilitiesToggleWebSearch,
|
|
enabled
|
|
) as Promise<CapabilitySnapshot>,
|
|
testWebSearch: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.capabilitiesTestWebSearch
|
|
) as Promise<WebSearchTestResult>,
|
|
setComputerCapabilityEnabled: (
|
|
capabilityId: ComputerCapabilityId,
|
|
enabled: boolean
|
|
) =>
|
|
ipcRenderer.invoke(ipcChannels.capabilitiesToggleComputer, {
|
|
capabilityId,
|
|
enabled
|
|
}) as Promise<CapabilitySnapshot>,
|
|
setComputerCapabilityBrowserProfile: (
|
|
capabilityId: ComputerCapabilityId,
|
|
browserProfileId: string | null
|
|
) =>
|
|
ipcRenderer.invoke(ipcChannels.capabilitiesConfigureComputer, {
|
|
capabilityId,
|
|
browserProfileId
|
|
}) as Promise<CapabilitySnapshot>,
|
|
diagnoseComputerCapability: (capabilityId: ComputerCapabilityId) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.capabilitiesDiagnoseComputer,
|
|
capabilityId
|
|
) as Promise<CapabilityDiagnosticReport>,
|
|
createBrowserProfile: (input: BrowserProfileCreateInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.capabilitiesCreateBrowserProfile,
|
|
input
|
|
) as Promise<CapabilitySnapshot>,
|
|
renameBrowserProfile: (input: BrowserProfileRenameInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.capabilitiesRenameBrowserProfile,
|
|
input
|
|
) as Promise<CapabilitySnapshot>,
|
|
setDefaultBrowserProfile: (profileId: string) =>
|
|
ipcRenderer.invoke(ipcChannels.capabilitiesDefaultBrowserProfile, {
|
|
profileId
|
|
}) as Promise<CapabilitySnapshot>,
|
|
removeBrowserProfile: (profileId: string) =>
|
|
ipcRenderer.invoke(ipcChannels.capabilitiesRemoveBrowserProfile, {
|
|
profileId
|
|
}) as Promise<CapabilitySnapshot>
|
|
},
|
|
context: {
|
|
selectFiles: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.contextSelectFiles
|
|
) as Promise<ContextAttachment[]>,
|
|
onFileSelectionProgress: (listener) => {
|
|
const handler = (
|
|
_event: Electron.IpcRendererEvent,
|
|
progress: ContextFileSelectionProgress
|
|
): void => listener(progress)
|
|
ipcRenderer.on(ipcChannels.contextFileSelectionProgress, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(
|
|
ipcChannels.contextFileSelectionProgress,
|
|
handler
|
|
)
|
|
},
|
|
addPastedImage: (input: PastedImageInput) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.contextAddPastedImage,
|
|
input
|
|
) as Promise<ContextAttachment>,
|
|
captureScreen: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.contextCaptureScreen
|
|
) as Promise<ContextAttachment>,
|
|
listWindows: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.contextListWindows
|
|
) as Promise<WindowCaptureOption[]>,
|
|
captureWindow: (sourceId) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.contextCaptureWindow,
|
|
{ sourceId }
|
|
) as Promise<ContextAttachment>,
|
|
readClipboard: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.contextReadClipboard
|
|
) as Promise<ContextAttachment>,
|
|
remove: async (contextId: string) => {
|
|
await ipcRenderer.invoke(ipcChannels.contextRemove, contextId)
|
|
}
|
|
},
|
|
magicNotes: {
|
|
list: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.magicNotesList
|
|
) as Promise<MagicNotesSnapshot>,
|
|
get: (noteId: string) =>
|
|
ipcRenderer.invoke(ipcChannels.magicNotesGet, {
|
|
noteId
|
|
}) as Promise<MagicNoteDetail>,
|
|
create: (input) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.magicNotesCreate,
|
|
input
|
|
) as Promise<MagicNoteDetail>,
|
|
update: (input) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.magicNotesUpdate,
|
|
input
|
|
) as Promise<MagicNoteDetail>,
|
|
remove: async (noteId: string) => {
|
|
await ipcRenderer.invoke(ipcChannels.magicNotesDelete, { noteId })
|
|
},
|
|
createEntry: (input) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.magicNotesCreateEntry,
|
|
input
|
|
) as Promise<MagicNoteDetail>,
|
|
updateEntry: (input) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.magicNotesUpdateEntry,
|
|
input
|
|
) as Promise<MagicNoteDetail>,
|
|
removeEntry: (entryId: string) =>
|
|
ipcRenderer.invoke(ipcChannels.magicNotesDeleteEntry, {
|
|
entryId
|
|
}) as Promise<MagicNoteDetail>,
|
|
analyze: (entryId, options) =>
|
|
ipcRenderer.invoke(ipcChannels.magicNotesAnalyze, {
|
|
entryId,
|
|
...options
|
|
}) as Promise<MagicNoteDetail>,
|
|
analyzeDraft: (content, options) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.magicNotesAnalyzeDraft,
|
|
{ content, ...options }
|
|
) as Promise<MagicNoteDraftAnalysis>,
|
|
listTodos: () =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.magicTodosList
|
|
) as Promise<MagicTodosSnapshot>,
|
|
updateTodo: (input) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.magicTodosUpdate,
|
|
input
|
|
) as Promise<MagicTodoItem>,
|
|
analyzeTodo: (todoId, options) =>
|
|
ipcRenderer.invoke(ipcChannels.magicTodosAnalyze, {
|
|
todoId,
|
|
...options
|
|
}) as Promise<MagicTodoItem>,
|
|
onAnalysisEvent: (listener) => {
|
|
const handler = (
|
|
_event: Electron.IpcRendererEvent,
|
|
payload: MagicNoteAnalysisStreamEvent
|
|
): void => listener(payload)
|
|
ipcRenderer.on(ipcChannels.magicNotesAnalysisEvent, handler)
|
|
return () =>
|
|
ipcRenderer.removeListener(
|
|
ipcChannels.magicNotesAnalysisEvent,
|
|
handler
|
|
)
|
|
}
|
|
},
|
|
knowledge: {
|
|
getSnapshot: (libraryId?: string) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.knowledgeSnapshot,
|
|
libraryId
|
|
) as Promise<KnowledgeSnapshot>,
|
|
createLibrary: (input) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.knowledgeCreateLibrary,
|
|
input
|
|
) as Promise<KnowledgeLibrary>,
|
|
updateLibrary: async (libraryId, update) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeUpdateLibrary, {
|
|
libraryId,
|
|
...update
|
|
})
|
|
},
|
|
deleteLibrary: async (libraryId) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.knowledgeDeleteLibrary,
|
|
libraryId
|
|
)
|
|
},
|
|
reextractGraph: (libraryId) =>
|
|
ipcRenderer.invoke(
|
|
ipcChannels.knowledgeReextractGraph,
|
|
libraryId
|
|
) as Promise<void>,
|
|
selectFiles: async (libraryId, graphStrategy) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeSelectFiles, {
|
|
libraryId,
|
|
graphStrategy
|
|
})
|
|
},
|
|
selectDirectory: async (libraryId, graphStrategy) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.knowledgeSelectDirectory,
|
|
{ libraryId, graphStrategy }
|
|
)
|
|
},
|
|
importDroppedFiles: async (libraryId, files, graphStrategy) => {
|
|
const paths = files
|
|
.map((file) => webUtils.getPathForFile(file))
|
|
.filter(Boolean)
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeImportPaths, {
|
|
libraryId,
|
|
paths,
|
|
graphStrategy
|
|
})
|
|
},
|
|
importUrl: async (libraryId, url, graphStrategy) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeImportUrl, {
|
|
libraryId,
|
|
url,
|
|
graphStrategy
|
|
})
|
|
},
|
|
syncSource: async (sourceId) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeSyncSource, sourceId)
|
|
},
|
|
pauseSource: async (sourceId) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgePauseSource, sourceId)
|
|
},
|
|
retrySource: async (sourceId) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeRetrySource, sourceId)
|
|
},
|
|
removeSource: async (sourceId) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeRemoveSource, sourceId)
|
|
},
|
|
search: (libraryIds, query) =>
|
|
ipcRenderer.invoke(ipcChannels.knowledgeSearch, {
|
|
libraryIds,
|
|
query
|
|
}) as Promise<KnowledgeSearchReference[]>,
|
|
createEntity: async (libraryId, input) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeCreateEntity, {
|
|
libraryId,
|
|
input
|
|
})
|
|
},
|
|
updateEntity: async (entityId, update) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeUpdateEntity, {
|
|
entityId,
|
|
update
|
|
})
|
|
},
|
|
moveEntity: async (entityId, position) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeMoveEntity, {
|
|
entityId,
|
|
position
|
|
})
|
|
},
|
|
deleteEntity: async (entityId) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeDeleteEntity, entityId)
|
|
},
|
|
mergeEntities: async (sourceEntityId, targetEntityId) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeMergeEntities, {
|
|
sourceEntityId,
|
|
targetEntityId
|
|
})
|
|
},
|
|
createRelation: async (libraryId, input) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeCreateRelation, {
|
|
libraryId,
|
|
input
|
|
})
|
|
},
|
|
updateRelation: async (relationId, input) => {
|
|
await ipcRenderer.invoke(ipcChannels.knowledgeUpdateRelation, {
|
|
relationId,
|
|
input
|
|
})
|
|
},
|
|
deleteRelation: async (relationId) => {
|
|
await ipcRenderer.invoke(
|
|
ipcChannels.knowledgeDeleteRelation,
|
|
relationId
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
contextBridge.exposeInMainWorld('goodbuddy', desktopApi)
|