update

src/main/main-runtime-support.ts

@@ -0,0 +1,178 @@
+import log from "electron-log/main.js";
+import type { AgentApiServer } from "./api-server";
+import { initializeAgentTokenSigningKey } from "./agent-auth";
+import { bootstrapApplication } from "./bootstrap-application";
+import { openConnectorAuthTerminal as openConnectorAuthTerminalImpl } from "./connector-auth-service";
+import { getConnectorDefinition } from "./connectors";
+import type { AppDatabase } from "./database";
+import { seedDefaultAutomationRules as seedDefaultAutomationRulesImpl } from "./default-automation-rules";
+import { registerCoreHandlers } from "./ipc-core-handlers";
+import { registerDomainHandlers } from "./ipc-domain-handlers";
+
+type BootstrapResult = Awaited<ReturnType<typeof bootstrapApplication>>;
+
+interface MainRuntimeState {
+  db: AppDatabase | null;
+  apiServer: AgentApiServer | null;
+  serviceGraph: BootstrapResult["serviceGraph"] | null;
+  ipcSupport: BootstrapResult["ipcSupport"] | null;
+}
+
+export function createMainRuntimeSupport(state: MainRuntimeState) {
+  function requireDb() {
+    if (!state.db) {
+      throw new Error("Database is not initialized.");
+    }
+    return state.db;
+  }
+
+  function requireServiceGraph() {
+    if (!state.serviceGraph) {
+      throw new Error("Service graph is not initialized.");
+    }
+    return state.serviceGraph;
+  }
+
+  function requireIpcSupport() {
+    if (!state.ipcSupport) {
+      throw new Error("IPC support is not initialized.");
+    }
+    return state.ipcSupport;
+  }
+
+  function requireAutomationService() {
+    const service = requireServiceGraph().getAutomationService();
+    if (!service) {
+      throw new Error("Automation service is not initialized.");
+    }
+    return service;
+  }
+
+  function requireBrowserActionService() {
+    const service = requireServiceGraph().getBrowserActionService();
+    if (!service) {
+      throw new Error("Browser action service is not initialized.");
+    }
+    return service;
+  }
+
+  function requireConnectorHealthService() {
+    const service = requireServiceGraph().getConnectorHealthService();
+    if (!service) {
+      throw new Error("Connector health service is not initialized.");
+    }
+    return service;
+  }
+
+  function requireOnboardingService() {
+    const service = requireServiceGraph().getOnboardingService();
+    if (!service) {
+      throw new Error("Onboarding service is not initialized.");
+    }
+    return service;
+  }
+
+  function requireOrchestrationService() {
+    const service = requireServiceGraph().getOrchestrationService();
+    if (!service) {
+      throw new Error("Orchestration service is not initialized.");
+    }
+    return service;
+  }
+
+  function requireUpdaterService() {
+    const service = requireServiceGraph().getUpdaterService();
+    if (!service) {
+      throw new Error("Updater service is not initialized.");
+    }
+    return service;
+  }
+
+  function emitEvent(event: Parameters<BootstrapResult["ipcSupport"]["emitEvent"]>[0]) {
+    requireIpcSupport().emitEvent(event);
+  }
+
+  function publishDomainChanged() {
+    requireIpcSupport().publishDomainChanged();
+  }
+
+  function ensureCompanyExists(companyId: string) {
+    return requireIpcSupport().ensureCompanyExists(companyId);
+  }
+
+  function findInvalidReference<T extends { id: string | null | undefined; table: string; label: string }>(
+    companyId: string,
+    refs: T[],
+  ) {
+    return requireIpcSupport().findInvalidReference(companyId, refs) as T | null;
+  }
+
+  function seedDefaultAutomationRules(companyId: string) {
+    const db = requireDb();
+    seedDefaultAutomationRulesImpl(companyId, {
+      listAutomationRuleNames: (targetCompanyId) => db.listAutomationRuleNames(targetCompanyId),
+      saveAutomationRule: (input) => db.saveAutomationRule(input),
+    });
+  }
+
+  function registerHandlers() {
+    registerCoreHandlers({
+      registerHandle: requireIpcSupport().registerHandle,
+      db: requireDb(),
+      ensureCompanyExists,
+      findInvalidReference,
+      publishDomainChanged,
+      emitEvent,
+      wakeAgentIfPossible: (agentId, companyId, trigger) =>
+        requireOrchestrationService().wakeAgentIfPossible(agentId, companyId, trigger),
+      handleTaskCreated: (taskId, companyId) => requireAutomationService().handleTaskCreated(taskId, companyId),
+      handleTaskStatusChange: (taskId, companyId, previousStatus, newStatus) =>
+        requireAutomationService().handleTaskStatusChange(taskId, companyId, previousStatus, newStatus),
+      handleApprovalResolved: (approvalId, companyId, decision) =>
+        requireAutomationService().handleApprovalResolved(approvalId, companyId, decision),
+      dispatchAutomation: (trigger, ctx) => requireAutomationService().dispatchAutomation(trigger, ctx),
+      queueTaskRun: (taskId, trigger, actor) =>
+        requireOrchestrationService().queueTaskRun(taskId, trigger, actor),
+      checkConnector: async (id) => requireConnectorHealthService().checkConnector(id),
+      openConnectorAuthTerminal: async (id) => {
+        const connector = requireDb().getConnector(id);
+        return openConnectorAuthTerminalImpl(id, connector.command);
+      },
+      checkForUpdates: () => requireUpdaterService().checkForUpdates(),
+      getWorkerProcess: () => requireServiceGraph().getWorkerService()?.getWorker() ?? null,
+      resetAfterRestore: () => {
+        initializeAgentTokenSigningKey(requireDb().profileDir);
+        requireBrowserActionService().resetBrowserManager();
+      },
+      getApiPort: () => state.apiServer?.getPort() ?? 0,
+      listConnectorModels: async (connectorId) => {
+        const definition = getConnectorDefinition(connectorId as Parameters<typeof getConnectorDefinition>[0]);
+        return definition.listModels ? definition.listModels() : [];
+      },
+    });
+
+    registerDomainHandlers({
+      registerHandle: requireIpcSupport().registerHandle,
+      db: requireDb(),
+      logger: log,
+      ensureCompanyExists,
+      findInvalidReference,
+      publishDomainChanged,
+      emitEvent,
+      wakeAgentIfPossible: (agentId, companyId, trigger) =>
+        requireOrchestrationService().wakeAgentIfPossible(agentId, companyId, trigger),
+      dispatchAutomation: (trigger, ctx) => requireAutomationService().dispatchAutomation(trigger, ctx),
+      runWorkflowPipeline: (workflowId, companyId) =>
+        requireAutomationService().runWorkflowPipeline(workflowId, companyId),
+      bootstrapOnboarding: (input) => requireOnboardingService().bootstrapOnboarding(input),
+      getBrowserActions: () => requireServiceGraph().getBrowserActionService(),
+      randomFallbackCompanyId: () => requireConnectorHealthService().randomFallbackCompanyId(),
+    });
+  }
+
+  return {
+    publishDomainChanged,
+    seedDefaultAutomationRules,
+    registerHandlers,
+  };
+}