@checkstack/integration-backend 0.1.30 → 0.3.0

package/src/index.ts

@@ -13,39 +13,31 @@ import {
 } from "@checkstack/integration-common";
 import { resolveRoute } from "@checkstack/common";
 import type { PluginMetadata } from "@checkstack/common";
-import type {
-  IntegrationEventDefinition,
-  IntegrationProvider,
-} from "./provider-types";
+import type { IntegrationProvider } from "./provider-types";
 
 import * as schema from "./schema";
-import {
-  createIntegrationEventRegistry,
-  type IntegrationEventRegistry,
-} from "./event-registry";
-import {
-  createIntegrationProviderRegistry,
-  type IntegrationProviderRegistry,
-} from "./provider-registry";
-import { createDeliveryCoordinator } from "./delivery-coordinator";
+import { createIntegrationProviderRegistry } from "./provider-registry";
 import {
   createConnectionStore,
   type ConnectionStore,
 } from "./connection-store";
-import { subscribeToRegisteredEvents } from "./hook-subscriber";
 import { createIntegrationRouter } from "./router";
 import { registerSearchProvider } from "@checkstack/command-backend";
+import {
+  secretResolverRef,
+  internalSecretsRef,
+} from "@checkstack/secrets-backend";
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 // Service References
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 /**
- * Service reference for the connection store.
- * Provider plugins can inject this to access connection credentials.
+ * Service reference for the connection store. Provider plugins inject
+ * this to look up credentials when an automation action runs.
  */
 export const connectionStoreRef = createServiceRef<ConnectionStore>(
-  "integration.connectionStore"
+  "integration.connectionStore",
 );
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -53,83 +45,45 @@ export const connectionStoreRef = createServiceRef<ConnectionStore>(
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 /**
- * Extension point for registering integration events.
- * Plugins use this to expose their hooks for external webhook subscriptions.
- */
-export interface IntegrationEventExtensionPoint {
-  /**
-   * Register a hook as an integration event.
-   * The event will be namespaced by the plugin's ID automatically.
-   */
-  registerEvent<T>(
-    definition: IntegrationEventDefinition<T>,
-    pluginMetadata: PluginMetadata
-  ): void;
-}
-
-export const integrationEventExtensionPoint =
-  createExtensionPoint<IntegrationEventExtensionPoint>(
-    "integration.eventExtensionPoint"
-  );
-
-/**
- * Extension point for registering integration providers.
- * Plugins use this to register webhook delivery providers.
+ * Extension point for registering integration providers. After the
+ * migration to the Automation Platform a provider is just the
+ * connection metadata + dropdown resolvers + a test endpoint — the
+ * per-event delivery work moved onto automation actions.
  */
 export interface IntegrationProviderExtensionPoint {
-  /**
-   * Register an integration provider.
-   * The provider will be namespaced by the plugin's ID automatically.
-   * @template TConfig - Per-subscription configuration type
-   * @template TConnection - Site-wide connection configuration type (optional)
-   */
-  addProvider<TConfig, TConnection = undefined>(
-    provider: IntegrationProvider<TConfig, TConnection>,
-    pluginMetadata: PluginMetadata
+  addProvider<TConnection = undefined>(
+    provider: IntegrationProvider<TConnection>,
+    pluginMetadata: PluginMetadata,
   ): void;
 }
 
 export const integrationProviderExtensionPoint =
   createExtensionPoint<IntegrationProviderExtensionPoint>(
-    "integration.providerExtensionPoint"
+    "integration.providerExtensionPoint",
   );
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 // Plugin Definition
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
+interface EnvStash {
+  /** Set in `init`, used by `afterPluginsReady` for the credential migration. */
+  runCredentialMigration?: () => Promise<void>;
+}
+
 export default createBackendPlugin({
   metadata: pluginMetadata,
 
   register(env) {
-    // Create the registries
-    const eventRegistry = createIntegrationEventRegistry();
     const providerRegistry = createIntegrationProviderRegistry();
 
-    // Register static access rules
     env.registerAccessRules(integrationAccessRules);
 
-    // Register the event extension point
-    env.registerExtensionPoint(integrationEventExtensionPoint, {
-      registerEvent: <T>(
-        definition: IntegrationEventDefinition<T>,
-        metadata: PluginMetadata
-      ) => {
-        // Type erasure: cast to unknown for storage (the registry handles this internally)
-        eventRegistry.register(
-          definition as IntegrationEventDefinition<unknown>,
-          metadata
-        );
-      },
-    });
-
-    // Register the provider extension point
     env.registerExtensionPoint(integrationProviderExtensionPoint, {
       addProvider: (provider, metadata) => {
-        // Type erasure: cast to unknown for storage (the registry handles this internally)
         providerRegistry.register(
           provider as IntegrationProvider<unknown>,
-          metadata
+          metadata,
         );
       },
     });
@@ -140,167 +94,87 @@ export default createBackendPlugin({
         logger: coreServices.logger,
         rpc: coreServices.rpc,
         config: coreServices.config,
-        signalService: coreServices.signalService,
-        queueManager: coreServices.queueManager,
+        secretResolver: secretResolverRef,
+        internalSecrets: internalSecretsRef,
       },
       init: async ({
         logger,
-        database,
         rpc,
         config,
-        signalService,
-        queueManager,
+        database,
+        secretResolver,
+        internalSecrets,
       }) => {
         logger.debug("🔌 Initializing Integration Backend...");
 
-        const db = database;
-
-        // Create connection store for generic connection management
         const connectionStore = createConnectionStore({
           configService: config,
           providerRegistry,
           logger,
+          // Unified credential resolution through the ONE secrets channel.
+          credentials: { secretResolver, internalSecrets },
         });
-
-        // Publish connection store for provider plugins to inject
         env.registerService(connectionStoreRef, connectionStore);
+        // Stash the migration for afterPluginsReady (all providers + their
+        // connectionSchemas are registered only by then).
+        (env as unknown as EnvStash).runCredentialMigration = () =>
+          connectionStore.runCredentialMigration();
 
-        // Create delivery coordinator
-        const deliveryCoordinator = createDeliveryCoordinator({
-          db,
-          providerRegistry,
-          connectionStore,
-          queueManager,
-          signalService,
-          logger,
-        });
-
-        // Store for afterPluginsReady access
-        (
-          env as unknown as {
-            eventRegistry: IntegrationEventRegistry;
-            providerRegistry: IntegrationProviderRegistry;
-            deliveryCoordinator: typeof deliveryCoordinator;
-          }
-        ).eventRegistry = eventRegistry;
-        (
-          env as unknown as {
-            eventRegistry: IntegrationEventRegistry;
-            providerRegistry: IntegrationProviderRegistry;
-            deliveryCoordinator: typeof deliveryCoordinator;
-          }
-        ).providerRegistry = providerRegistry;
-        (
-          env as unknown as {
-            eventRegistry: IntegrationEventRegistry;
-            providerRegistry: IntegrationProviderRegistry;
-            deliveryCoordinator: typeof deliveryCoordinator;
-          }
-        ).deliveryCoordinator = deliveryCoordinator;
-
-        // Create and register the router
         const router = createIntegrationRouter({
-          db,
-          eventRegistry,
+          db: database,
           providerRegistry,
-          deliveryCoordinator,
           connectionStore,
-          signalService,
           logger,
         });
         rpc.registerRouter(router, integrationContract);
 
-        // Register command palette commands
         registerSearchProvider({
           pluginMetadata,
           commands: [
             {
-              id: "create",
-              title: "Create Integration Subscription",
-              subtitle: "Create a new subscription for integration events",
-              iconName: "Webhook",
-              route:
-                resolveRoute(integrationRoutes.routes.list) + "?action=create",
-              requiredAccessRules: [integrationAccess.manage],
-            },
-            {
-              id: "manage",
-              title: "Manage Integrations",
-              subtitle: "Manage integration subscriptions and connections",
+              id: "connections",
+              title: "Manage Integration Connections",
+              subtitle: "Configure credentials for Jira, Teams, Webex, etc.",
               iconName: "Webhook",
               shortcuts: ["meta+shift+g", "ctrl+shift+g"],
               route: resolveRoute(integrationRoutes.routes.list),
               requiredAccessRules: [integrationAccess.manage],
             },
-            {
-              id: "logs",
-              title: "View Integration Logs",
-              subtitle: "View integration delivery logs",
-              iconName: "FileText",
-              route: resolveRoute(integrationRoutes.routes.logs),
-              requiredAccessRules: [integrationAccess.manage],
-            },
           ],
         });
 
-        logger.debug("✅ Integration Backend initialized.");
-      },
-      afterPluginsReady: async ({ logger, onHook }) => {
-        // Get registries from env
-        const stored = env as unknown as {
-          eventRegistry: IntegrationEventRegistry;
-          providerRegistry: IntegrationProviderRegistry;
-          deliveryCoordinator: ReturnType<typeof createDeliveryCoordinator>;
-        };
-
-        const events = stored.eventRegistry.getEvents();
-        const providers = stored.providerRegistry.getProviders();
-
-        logger.debug(
-          `🔌 Registered ${events.length} integration events: ${events
-            .map((e) => e.eventId)
-            .join(", ")}`
-        );
-
         logger.debug(
-          `📡 Registered ${providers.length} integration providers: ${providers
-            .map((p) => p.qualifiedId)
-            .join(", ")}`
+          `📡 Integration Backend init complete with ${providerRegistry.getProviders().length} providers`,
         );
+      },
 
-        // Subscribe to all registered integration events
-        // Uses work-queue mode to ensure only ONE instance processes each event
-        subscribeToRegisteredEvents({
-          onHook,
-          eventRegistry: stored.eventRegistry,
-          deliveryCoordinator: stored.deliveryCoordinator,
-          logger,
-        });
-
-        // Start the delivery worker
-        await stored.deliveryCoordinator.startWorker();
-
-        logger.debug("✅ Integration Backend afterPluginsReady complete.");
+      // Consolidate legacy inline connection credentials onto the secrets
+      // platform once every provider (and its connectionSchema) is
+      // registered. Idempotent + parity-verified + reversible (backup).
+      afterPluginsReady: async ({ logger }) => {
+        try {
+          await (env as unknown as EnvStash).runCredentialMigration?.();
+        } catch (error) {
+          logger.error(
+            `Connection credential migration failed: ${String(error)}`,
+          );
+        }
       },
     });
   },
 });
 
-// Re-export extension points for consumer plugins
-export { integrationEventExtensionPoint as eventExtensionPoint };
+// ─── Re-exports ─────────────────────────────────────────────────────────
+
 export { integrationProviderExtensionPoint as providerExtensionPoint };
 
-// Re-export provider types for consumer plugins
-// All backend-only types are defined here (not in integration-common)
 export type {
-  IntegrationEventDefinition,
-  IntegrationDeliveryContext,
-  IntegrationDeliveryResult,
   TestConnectionResult,
   ProviderDocumentation,
   ConnectionOption,
   GetConnectionOptionsParams,
   IntegrationProvider,
   RegisteredIntegrationProvider,
-  RegisteredIntegrationEvent,
 } from "./provider-types";
+
+export type { ConnectionStore } from "./connection-store";