import { SKILLS_LIST_METHOD, SKILLS_CHANGED_METHOD, skillsListParamsSchema, skillsListResultSchema, skillsChangedParamsSchema, type SkillsListParams, type SkillsListResult, type SkillsChangedParams, DELEGATION_READ_METHOD, delegationReadParamsSchema, type DelegationReadParams, REMOTE_SSH_SETUP_METHOD, remoteSshSetupResultSchema, remoteSshSetupParamsSchema, type RemoteSshSetupParams, type RemoteSshSetupResult, RUNTIME_STATUS_METHOD, REMOTE_UPDATE_METHOD, runtimeStatusSchema, type RuntimeStatus, } from "@codexhost/shared-contracts"; import { type HarnessInstallationParams, type HarnessInstallationState, HARNESS_DISPLAY_GET_METHOD, HARNESS_DISPLAY_CHANGED_METHOD, HARNESS_DISPLAY_CAPABILITIES_METHOD, harnessDisplayCapabilitiesSchema, HARNESS_DISPLAY_SET_METHOD, harnessDisplaySettingsSchema, type HarnessDisplaySet, type HarnessDisplaySettings, CONSOLE_OPEN_METHOD, WEB_OPEN_METHOD, webOpenParamsSchema, webOpenResultSchema, type WebOpenResult, consoleOpenParamsSchema, consoleOpenResultSchema, type ConsoleOpenResult, HARNESS_LAUNCH_SETTINGS_GET_METHOD, HARNESS_LAUNCH_SETTINGS_SET_METHOD, harnessLaunchSettingsGetSchema, harnessLaunchSettingsSetSchema, harnessLaunchSettingsSchema, type HarnessLaunchSettings, type HarnessLaunchSettingsGet, type HarnessLaunchSettingsSet, IDLE_RELEASE_SETTINGS_METHOD, LOADED_SESSIONS_METHOD, loadedSessionsSchema, type LoadedSession, idleReleaseSettingsSchema, type IdleReleaseSettings, harnessAccountInspectParamsSchema, harnessAccountInspectResultSchema, harnessAccountSourceListResultSchema, type HarnessAccountInspectParams, type HarnessAccountInspectResult, type HarnessAccountSourceListResult, harnessAccountListParamsSchema, harnessAccountListResultSchema, type HarnessAccountListParams, type HarnessAccountListResult, codexAccountUsageParamsSchema, codexAccountUsageResultSchema, type CodexAccountUsageParams, type CodexAccountUsageResult, codexAccountChangedSchema, codexAccountListResultSchema, externalThreadForkParamsSchema, externalThreadForkResultSchema, harnessCommandCatalogSchema, harnessCommandsInspectParamsSchema, harnessConfigurationStateSchema, harnessInspectParamsSchema, harnessInspectionSchema, harnessPluginListResultSchema, type HarnessPluginListResult, harnessWebUiOpenParamsSchema, harnessWebUiOpenResultSchema, harnessModelSelectionStateSchema, hostThreadIdSchema, threadInspectionParamsSchema, threadInspectionSchema, threadCommandExecuteParamsSchema, threadCommandExecuteResultSchema, threadCommandsInspectParamsSchema, threadModelSelectParamsSchema, threadPermissionModeSelectParamsSchema, threadThinkingSelectParamsSchema, threadOwnershipListParamsSchema, threadOwnershipListResultSchema, threadUsageInspectionParamsSchema, threadUsageInspectionSchema, updateCheckResultSchema, updateEmptyParamsSchema, updateStartResultSchema, updateStatusResultSchema, type ExternalThreadForkParams, type ExternalThreadForkResult, type CodexAccountChanged, type CodexAccountListResult, type HarnessCommandCatalog, type HarnessCommandsInspectParams, type HarnessConfigurationState, type HarnessInspection, type HarnessInspectParams, type HarnessWebUiOpenParams, type HarnessModelSelectionState, type ThreadInspection, type ThreadInspectionParams, type ThreadCommandExecuteParams, type ThreadCommandExecuteResult, type ThreadCommandsInspectParams, type ThreadModelSelectParams, type ThreadPermissionModeSelectParams, type ThreadThinkingSelectParams, type ThreadOwnershipListParams, type ThreadOwnershipListResult, type ThreadUsageInspection, type ThreadUsageInspectionParams, type UpdateCheckResult, type UpdateStartResult, type UpdateStatusResult, } from "@codexhost/shared-contracts"; import { runRendererInstallation } from "./renderer-installation-client.js"; import { createRendererRequestSender, isUnsupportedMethod, RendererMethodUnavailableError, type RendererRequestOptions, } from "./renderer-request-sender.js"; import { verifyNativeCodexThread } from "./renderer-native-thread.js"; import { HARNESS_PREFERENCES_GET_METHOD, HARNESS_PREFERENCES_PATCH_METHOD, HARNESS_PREFERENCES_CHANGED_METHOD, harnessPreferenceSnapshotSchema, harnessPreferencePatchSchema, harnessPreferenceGetSchema, type HarnessPreferenceSnapshot, type HarnessPreferencePatch, } from "@codexhost/shared-contracts"; import { createRendererSessionImportClient, type RendererSessionImportClient, } from "./renderer-session-import-client.js"; export const HARNESS_INSPECT_METHOD = "codexhost/harness/inspect"; export const HARNESS_PLUGIN_LIST_METHOD = "codexhost/harness/plugins/list"; import { CREDENTIAL_IMPORTS_METHOD, credentialImportsParamsSchema, credentialImportsResultSchema, type CredentialImportsRequest, type CredentialImportsResult, } from "@codexhost/shared-contracts"; export const HARNESS_ACCOUNT_SOURCES_METHOD = "codexhost/harness/accounts/sources"; export const HARNESS_ACCOUNT_INSPECT_METHOD = "codexhost/harness/accounts/inspect"; export const HARNESS_WEB_UI_OPEN_METHOD = "codexhost/harness/web-ui/open"; export const THREAD_FORK_METHOD = "codexhost/thread/fork"; export const THREAD_INSPECT_METHOD = "codexhost/thread/inspect"; export const HARNESS_COMMANDS_INSPECT_METHOD = "codexhost/harness/commands/inspect"; export const THREAD_COMMANDS_INSPECT_METHOD = "codexhost/thread/commands/inspect"; export const THREAD_COMMAND_EXECUTE_METHOD = "codexhost/thread/command/execute"; export const THREAD_MODEL_SELECT_METHOD = "codexhost/thread/model/select"; export const THREAD_THINKING_SELECT_METHOD = "codexhost/thread/thinking/select"; export const THREAD_PERMISSION_MODE_SELECT_METHOD = "codexhost/thread/permission-mode/select"; export const THREAD_OWNERSHIP_LIST_METHOD = "codexhost/thread/ownership/list"; export const THREAD_USAGE_INSPECT_METHOD = "codexhost/thread/usage/inspect"; export const THREAD_USAGE_UPDATED_METHOD = "codexhost/thread/usage/updated"; export const THREAD_TOKEN_USAGE_UPDATED_METHOD = "thread/tokenUsage/updated"; /** * Desktop filters custom usage notifications before native manager callbacks; * renderer-host-clients also observes their raw per-Host window messages. * Native Token updates and Turn completion remain fallback refresh signals, * including for account quota after a reply. */ export const TURN_COMPLETED_METHOD = "turn/completed"; const THREAD_USAGE_REFRESH_METHODS = [ THREAD_TOKEN_USAGE_UPDATED_METHOD, THREAD_USAGE_UPDATED_METHOD, TURN_COMPLETED_METHOD, ] as const; export const UPDATE_CHECK_METHOD = "codexhost/update/check"; export const UPDATE_START_METHOD = "codexhost/update/start"; export const UPDATE_STATUS_METHOD = "codexhost/update/status"; export const CODEX_ACCOUNT_LIST_METHOD = "codexhost/account/list"; export const CODEX_ACCOUNT_REFRESH_METHOD = "codexhost/account/refresh"; export const CODEX_ACCOUNT_CHANGED_METHOD = "codexhost/account/changed"; function isRecord(value: unknown): value is Record { return typeof value === "object" && value !== null && !Array.isArray(value); } function notifiedThreadId(notification: unknown): ThreadUsageInspectionParams["threadId"] | null { if ( !isRecord(notification) || !(THREAD_USAGE_REFRESH_METHODS as readonly unknown[]).includes(notification.method) ) { return null; } const params = notification.params; if (!isRecord(params)) return null; const parsed = hostThreadIdSchema.safeParse(params.threadId); return parsed.success ? parsed.data : null; } interface RequestManagerCandidate { addNotificationCallback?: ( method: string | readonly string[], callback: (notification: unknown) => void, ) => () => void; sendRequest?: (method: string, params: unknown, options?: unknown) => Promise | unknown; requestClient?: RequestManagerCandidate; } function notificationTarget(manager: RequestManagerCandidate): RequestManagerCandidate | null { if (typeof manager.addNotificationCallback === "function") return manager; const nested = manager.requestClient; return nested && typeof nested.addNotificationCallback === "function" ? nested : null; } export interface RendererModelClient extends Partial { getHarnessPreferences?(scope?: string): Promise; patchHarnessPreferences?(input: HarnessPreferencePatch): Promise; subscribeHarnessPreferences?(listener: () => void): () => void; installation?(input: HarnessInstallationParams): Promise; getHarnessDisplayCapabilities?(): Promise<{ events: boolean }>; subscribeHarnessDisplaySettings?(listener: () => void): () => void; getHarnessDisplaySettings?(): Promise; setHarnessDisplaySettings?(input: HarnessDisplaySet): Promise; getHarnessLaunchSettings?(input: HarnessLaunchSettingsGet): Promise; setHarnessLaunchSettings?(input: HarnessLaunchSettingsSet): Promise; setIdleReleaseSettings?(settings: IdleReleaseSettings): Promise; listLoadedSessions?(): Promise; currentHostId?(composer?: Element): string | null; knownHostIds?(): readonly string[]; listHarnessPlugins?(): Promise; listSkills?(params: SkillsListParams): Promise; subscribeSkillsChanged?(listener: (params: SkillsChangedParams) => void): () => void; clientForHost?(hostId: string): RendererModelClient | null; forkThread(input: ExternalThreadForkParams): Promise; inspectHarness( input: HarnessInspectParams, options?: RendererRequestOptions, ): Promise; openHarnessWebUi?(input: HarnessWebUiOpenParams): Promise; inspectThread(input: ThreadInspectionParams): Promise; inspectHarnessCommands(input: HarnessCommandsInspectParams): Promise; inspectThreadCommands(input: ThreadCommandsInspectParams): Promise; executeThreadCommand(input: ThreadCommandExecuteParams): Promise; listThreadOwnership(input: ThreadOwnershipListParams): Promise; inspectThreadUsage(input: ThreadUsageInspectionParams): Promise; subscribeThreadUsage?(listener: (update: ThreadUsageInspection) => void): () => void; selectThreadModel(input: ThreadModelSelectParams): Promise; selectThreadThinking(input: ThreadThinkingSelectParams): Promise; selectThreadPermissionMode( input: ThreadPermissionModeSelectParams, ): Promise; setupSsh?(input: RemoteSshSetupParams): Promise; readDelegationThread?(input: DelegationReadParams): Promise; runtimeStatus?(): Promise; updateRemote?(version: string): Promise; checkUpdate(): Promise; startUpdate(): Promise; readUpdateStatus(): Promise; openConsole?(): Promise; openWeb?(): Promise; inspectCodexAccountUsage?(input: CodexAccountUsageParams): Promise; listHarnessAccountSources?(): Promise; inspectHarnessAccount?(input: HarnessAccountInspectParams): Promise; listHarnessAccounts?(input?: HarnessAccountListParams): Promise; credentialImports?( request: CredentialImportsRequest, targetHarnessId?: string, ): Promise; listCodexAccounts(): Promise; refreshCodexAccounts(): Promise; subscribeCodexAccounts?(listener: (state: CodexAccountChanged) => void): () => void; } export function createThreadUsageSubscriptionRelay(): { connect(client: Pick | null): void; subscribe(listener: (update: ThreadUsageInspection) => void): () => void; dispose(): void; } { const listeners = new Set<(update: ThreadUsageInspection) => void>(); let removeNotificationCallback: (() => void) | null = null; let connectedClient: Pick | null = null; let generation = 0; const disconnect = (): void => { generation += 1; removeNotificationCallback?.(); removeNotificationCallback = null; connectedClient = null; }; return { connect(client) { if (client === connectedClient && removeNotificationCallback) return; disconnect(); if (!client || listeners.size === 0) return; connectedClient = client; const subscriptionGeneration = generation; try { removeNotificationCallback = client.subscribeThreadUsage?.((update) => { if (subscriptionGeneration !== generation) return; for (const listener of listeners) listener(update); }) ?? null; } catch { disconnect(); } }, subscribe(listener) { listeners.add(listener); return () => { listeners.delete(listener); if (listeners.size > 0) return; disconnect(); }; }, dispose() { disconnect(); listeners.clear(); }, }; } export function createRendererModelClient( candidates: readonly RequestManagerCandidate[], ): RendererModelClient | null { const managers = candidates.filter( ( candidate, ): candidate is RequestManagerCandidate & Required> => typeof candidate.sendRequest === "function", ); const source = managers[0]; if (managers.length !== 1 || !source) return null; const manager = { sendRequest: createRendererRequestSender((method, params, options) => options === undefined ? source.sendRequest(method, params) : source.sendRequest(method, params, options), ), }; const inspectHarness = async ( input: HarnessInspectParams, options?: RendererRequestOptions, ): Promise => { const params = harnessInspectParamsSchema.parse(input); let result: unknown; try { result = await manager.sendRequest(HARNESS_INSPECT_METHOD, params, options); } catch (error) { // Hosts that predate `purpose` reject it as an unknown param; they only run full inspection. if (!params.purpose || !isInvalidParams(error)) throw error; const full = { ...params }; delete full.purpose; result = await manager.sendRequest(HARNESS_INSPECT_METHOD, full, options); } return harnessInspectionSchema.parse(result); }; const inspectHarnessCommands = async ( input: HarnessCommandsInspectParams, ): Promise => { const params = harnessCommandsInspectParamsSchema.parse(input); const result = await manager.sendRequest(HARNESS_COMMANDS_INSPECT_METHOD, params); return harnessCommandCatalogSchema.parse(result); }; const inspectThreadCommands = async ( input: ThreadCommandsInspectParams, ): Promise => { const params = threadCommandsInspectParamsSchema.parse(input); const result = await manager.sendRequest(THREAD_COMMANDS_INSPECT_METHOD, params); return harnessCommandCatalogSchema.parse(result); }; const executeThreadCommand = async ( input: ThreadCommandExecuteParams, ): Promise => { const params = threadCommandExecuteParamsSchema.parse(input); const result = await manager.sendRequest(THREAD_COMMAND_EXECUTE_METHOD, params); return threadCommandExecuteResultSchema.parse(result); }; const inspectThreadUsage = async ( input: ThreadUsageInspectionParams, ): Promise => { const params = threadUsageInspectionParamsSchema.parse(input); const result = await manager.sendRequest(THREAD_USAGE_INSPECT_METHOD, params); return threadUsageInspectionSchema.parse(result); }; const selectThreadModel = async ( input: ThreadModelSelectParams, ): Promise => { const params = threadModelSelectParamsSchema.parse(input); const result = await manager.sendRequest(THREAD_MODEL_SELECT_METHOD, params); return harnessModelSelectionStateSchema.parse(result); }; const selectThreadThinking = async ( input: ThreadThinkingSelectParams, ): Promise => { const params = threadThinkingSelectParamsSchema.parse(input); const result = await manager.sendRequest(THREAD_THINKING_SELECT_METHOD, params); return harnessModelSelectionStateSchema.parse(result); }; const selectThreadPermissionMode = async ( input: ThreadPermissionModeSelectParams, ): Promise => { const params = threadPermissionModeSelectParamsSchema.parse(input); const result = await manager.sendRequest(THREAD_PERMISSION_MODE_SELECT_METHOD, params); return harnessConfigurationStateSchema.parse(result); }; return Object.freeze({ async getHarnessPreferences(scope = "external") { return harnessPreferenceSnapshotSchema.parse( await manager.sendRequest( HARNESS_PREFERENCES_GET_METHOD, harnessPreferenceGetSchema.parse({ scope }), ), ); }, async patchHarnessPreferences(input: HarnessPreferencePatch) { return harnessPreferenceSnapshotSchema.parse( await manager.sendRequest( HARNESS_PREFERENCES_PATCH_METHOD, harnessPreferencePatchSchema.parse(input), ), ); }, subscribeHarnessPreferences(listener: () => void) { return ( notificationTarget(source)?.addNotificationCallback?.( HARNESS_PREFERENCES_CHANGED_METHOD, listener, ) ?? (() => {}) ); }, async installation(input: HarnessInstallationParams): Promise { return runRendererInstallation(manager.sendRequest, input); }, async getHarnessDisplayCapabilities() { if (!notificationTarget(source)) return { events: false }; return harnessDisplayCapabilitiesSchema.parse( await manager.sendRequest(HARNESS_DISPLAY_CAPABILITIES_METHOD, {}), ); }, subscribeHarnessDisplaySettings(listener: () => void) { return ( notificationTarget(source)?.addNotificationCallback?.( HARNESS_DISPLAY_CHANGED_METHOD, listener, ) ?? (() => {}) ); }, async getHarnessDisplaySettings() { return harnessDisplaySettingsSchema.parse( await manager.sendRequest(HARNESS_DISPLAY_GET_METHOD, {}), ); }, async setHarnessDisplaySettings(input: HarnessDisplaySet) { return harnessDisplaySettingsSchema.parse( await manager.sendRequest(HARNESS_DISPLAY_SET_METHOD, input), ); }, async getHarnessLaunchSettings( input: HarnessLaunchSettingsGet, ): Promise { return harnessLaunchSettingsSchema.parse( await manager.sendRequest( HARNESS_LAUNCH_SETTINGS_GET_METHOD, harnessLaunchSettingsGetSchema.parse(input), ), ); }, async setHarnessLaunchSettings( input: HarnessLaunchSettingsSet, ): Promise { return harnessLaunchSettingsSchema.parse( await manager.sendRequest( HARNESS_LAUNCH_SETTINGS_SET_METHOD, harnessLaunchSettingsSetSchema.parse(input), ), ); }, async listLoadedSessions(): Promise { return loadedSessionsSchema.parse(await manager.sendRequest(LOADED_SESSIONS_METHOD, {})); }, async setIdleReleaseSettings(settings: IdleReleaseSettings): Promise { const params = idleReleaseSettingsSchema.parse(settings); return idleReleaseSettingsSchema.parse( await manager.sendRequest(IDLE_RELEASE_SETTINGS_METHOD, params), ); }, ...createRendererSessionImportClient(async (method, params) => manager.sendRequest(method, params), ), async forkThread(input: ExternalThreadForkParams): Promise { const params = externalThreadForkParamsSchema.parse(input); const result = await manager.sendRequest(THREAD_FORK_METHOD, params); return externalThreadForkResultSchema.parse(result); }, inspectHarness, async listSkills(params: SkillsListParams): Promise { return skillsListResultSchema.parse( await manager.sendRequest(SKILLS_LIST_METHOD, skillsListParamsSchema.parse(params)), ); }, subscribeSkillsChanged(listener: (params: SkillsChangedParams) => void) { return ( notificationTarget(source)?.addNotificationCallback?.(SKILLS_CHANGED_METHOD, (value) => { if (!isRecord(value) || value.method !== SKILLS_CHANGED_METHOD) return; const parsed = skillsChangedParamsSchema.safeParse(value.params); if (parsed.success) listener(parsed.data); }) ?? (() => {}) ); }, async listHarnessPlugins(): Promise { return harnessPluginListResultSchema.parse( await manager.sendRequest(HARNESS_PLUGIN_LIST_METHOD, {}), ); }, async openHarnessWebUi(input: HarnessWebUiOpenParams): Promise { const params = harnessWebUiOpenParamsSchema.parse(input); const result = await manager.sendRequest(HARNESS_WEB_UI_OPEN_METHOD, params); harnessWebUiOpenResultSchema.parse(result); }, async inspectThread(input: ThreadInspectionParams): Promise { const params = threadInspectionParamsSchema.parse(input); let result: unknown; try { result = await manager.sendRequest(THREAD_INSPECT_METHOD, params); } catch (error) { if (!(error instanceof RendererMethodUnavailableError)) throw error; // Stock Codex has no Host inspection API. Verify its native Thread on // this same connection; neither an RPC failure nor a missing Account // establishes ownership. Match the external markers used by the Host. await verifyNativeCodexThread(manager.sendRequest, params.threadId); return { owner: "codex", locked: true }; } return threadInspectionSchema.parse(result); }, inspectHarnessCommands, inspectThreadCommands, executeThreadCommand, async listThreadOwnership( input: ThreadOwnershipListParams, ): Promise { const params = threadOwnershipListParamsSchema.parse(input); const value = await manager.sendRequest(THREAD_OWNERSHIP_LIST_METHOD, params); const result = threadOwnershipListResultSchema.parse(value); if ( result.threads.length !== params.threadIds.length || result.threads.some((thread, index) => thread.threadId !== params.threadIds[index]) ) { throw new Error("Thread ownership-list result does not match the requested IDs"); } return result; }, inspectThreadUsage, subscribeThreadUsage(listener: (update: ThreadUsageInspection) => void): () => void { const notifications = notificationTarget(source); if (!notifications?.addNotificationCallback) { throw new Error("Renderer Usage notification callback is unavailable"); } let disposed = false; const generations = new Map(); const removeNotificationCallback = notifications.addNotificationCallback( THREAD_USAGE_REFRESH_METHODS, (notification) => { const threadId = notifiedThreadId(notification); if (!threadId) return; const generation = (generations.get(threadId) ?? 0) + 1; generations.set(threadId, generation); void inspectThreadUsage({ threadId }) .then((update) => { if (!disposed && generations.get(threadId) === generation) listener(update); }) .catch(() => undefined); }, ); return () => { if (disposed) return; disposed = true; generations.clear(); removeNotificationCallback(); }; }, selectThreadModel, selectThreadThinking, selectThreadPermissionMode, async setupSsh(input: RemoteSshSetupParams) { return remoteSshSetupResultSchema.parse( await manager.sendRequest(REMOTE_SSH_SETUP_METHOD, remoteSshSetupParamsSchema.parse(input)), ); }, async readDelegationThread(input: DelegationReadParams) { return source.sendRequest(DELEGATION_READ_METHOD, delegationReadParamsSchema.parse(input)); }, async runtimeStatus() { // Asked directly rather than through the remembering sender: an outdated remote // service can be updated in place, after which this method starts answering. try { return runtimeStatusSchema.parse(await source.sendRequest(RUNTIME_STATUS_METHOD, {})); } catch (error) { if (!isUnsupportedMethod(error, RUNTIME_STATUS_METHOD)) throw error; throw new RendererMethodUnavailableError(RUNTIME_STATUS_METHOD, error); } }, async updateRemote(version: string) { return runtimeStatusSchema.parse( await manager.sendRequest(REMOTE_UPDATE_METHOD, { version }), ); }, async checkUpdate(): Promise { const result = await manager.sendRequest( UPDATE_CHECK_METHOD, updateEmptyParamsSchema.parse({}), ); return updateCheckResultSchema.nullable().parse(result); }, async startUpdate(): Promise { const result = await manager.sendRequest( UPDATE_START_METHOD, updateEmptyParamsSchema.parse({}), ); return updateStartResultSchema.parse(result); }, async readUpdateStatus(): Promise { const result = await manager.sendRequest( UPDATE_STATUS_METHOD, updateEmptyParamsSchema.parse({}), ); return updateStatusResultSchema.parse(result); }, async openWeb(): Promise { const result = await manager.sendRequest(WEB_OPEN_METHOD, webOpenParamsSchema.parse({})); return webOpenResultSchema.parse(result); }, async openConsole(): Promise { const result = await manager.sendRequest( CONSOLE_OPEN_METHOD, consoleOpenParamsSchema.parse({}), ); return consoleOpenResultSchema.parse(result); }, async inspectCodexAccountUsage( input: CodexAccountUsageParams, ): Promise { const result = await manager.sendRequest( "codexhost/account/usage/inspect", codexAccountUsageParamsSchema.parse(input), ); return codexAccountUsageResultSchema.parse(result); }, async listHarnessAccountSources(): Promise { return harnessAccountSourceListResultSchema.parse( await manager.sendRequest(HARNESS_ACCOUNT_SOURCES_METHOD, {}), ); }, async inspectHarnessAccount( input: HarnessAccountInspectParams, ): Promise { return harnessAccountInspectResultSchema.parse( await manager.sendRequest( HARNESS_ACCOUNT_INSPECT_METHOD, harnessAccountInspectParamsSchema.parse(input), ), ); }, async credentialImports( request: CredentialImportsRequest, targetHarnessId?: string, ): Promise { return credentialImportsResultSchema.parse( await manager.sendRequest( CREDENTIAL_IMPORTS_METHOD, credentialImportsParamsSchema.parse({ request, targetHarnessId }), ), ); }, async listHarnessAccounts( input: HarnessAccountListParams = {}, ): Promise { return harnessAccountListResultSchema.parse( await manager.sendRequest( "codexhost/harness/accounts/list", harnessAccountListParamsSchema.parse(input), ), ); }, async listCodexAccounts(): Promise { const result = await manager.sendRequest(CODEX_ACCOUNT_LIST_METHOD, {}); return codexAccountListResultSchema.parse(result); }, async refreshCodexAccounts(): Promise { const result = await manager.sendRequest(CODEX_ACCOUNT_REFRESH_METHOD, {}); return codexAccountListResultSchema.parse(result); }, subscribeCodexAccounts(listener: (state: CodexAccountChanged) => void): () => void { const notifications = notificationTarget(source); if (!notifications?.addNotificationCallback) { throw new Error("Renderer Account notification callback is unavailable"); } return notifications.addNotificationCallback(CODEX_ACCOUNT_CHANGED_METHOD, (notification) => { if (!isRecord(notification) || notification.method !== CODEX_ACCOUNT_CHANGED_METHOD) return; const state = codexAccountChangedSchema.safeParse(notification.params); if (state.success) listener(state.data); }); }, }); } function isInvalidParams(error: unknown): boolean { return typeof error === "object" && error !== null && "code" in error && error.code === -32602; }