@codemation/host 0.0.15 → 0.0.18

package/src/bootstrap/AppContainerFactory.ts

@@ -22,12 +22,52 @@ import {
   WorkflowRepositoryWebhookTriggerMatcher,
 } from "@codemation/core/bootstrap";
 import { AIAgentConnectionWorkflowExpander, ConnectionCredentialNodeConfigFactory } from "@codemation/core-nodes";
-import "../application/commands/CredentialCommandHandlers";
-import "../application/commands/UserAccountCommandHandlers";
-import "../application/commands/WorkflowCommandHandlers";
-import "../application/queries/CredentialQueryHandlers";
-import "../application/queries/UserAccountQueryHandlers";
-import "../application/queries/WorkflowQueryHandlers";
+import {
+  CreateCredentialInstanceCommandHandler,
+  DeleteCredentialInstanceCommandHandler,
+  TestCredentialInstanceCommandHandler,
+  UpdateCredentialInstanceCommandHandler,
+  UpsertCredentialBindingCommandHandler,
+} from "../application/commands/CredentialCommandHandlers";
+import {
+  AcceptUserInviteCommandHandler,
+  InviteUserCommandHandler,
+  RegenerateUserInviteCommandHandler,
+  UpdateUserAccountStatusCommandHandler,
+  UpsertLocalBootstrapUserCommandHandler,
+} from "../application/commands/UserAccountCommandHandlers";
+import {
+  CopyRunToWorkflowDebuggerCommandHandler,
+  HandleWebhookInvocationCommandHandler,
+  ReplaceMutableRunWorkflowSnapshotCommandHandler,
+  ReplaceWorkflowDebuggerOverlayCommandHandler,
+  ReplayWorkflowNodeCommandHandler,
+  SetPinnedNodeInputCommandHandler,
+  SetWorkflowActivationCommandHandler,
+  StartWorkflowRunCommandHandler,
+  UploadOverlayPinnedBinaryCommandHandler,
+} from "../application/commands/WorkflowCommandHandlers";
+import {
+  GetCredentialFieldEnvStatusQueryHandler,
+  GetCredentialInstanceQueryHandler,
+  GetCredentialInstanceWithSecretsQueryHandler,
+  GetWorkflowCredentialHealthQueryHandler,
+  ListCredentialInstancesQueryHandler,
+  ListCredentialTypesQueryHandler,
+} from "../application/queries/CredentialQueryHandlers";
+import {
+  ListUserAccountsQueryHandler,
+  VerifyUserInviteQueryHandler,
+} from "../application/queries/UserAccountQueryHandlers";
+import {
+  GetRunBinaryAttachmentQueryHandler,
+  GetRunStateQueryHandler,
+  GetWorkflowDebuggerOverlayQueryHandler,
+  GetWorkflowDetailQueryHandler,
+  GetWorkflowOverlayBinaryAttachmentQueryHandler,
+  GetWorkflowSummariesQueryHandler,
+  ListWorkflowRunsQueryHandler,
+} from "../application/queries/WorkflowQueryHandlers";
 import { OpenAiApiKeyCredentialHealthTester } from "../infrastructure/credentials/OpenAiApiKeyCredentialHealthTester";
 import { OpenAiApiKeyCredentialTypeFactory } from "../infrastructure/credentials/OpenAiApiKeyCredentialTypeFactory";
 import { CodemationPluginRegistrar } from "../infrastructure/config/CodemationPluginRegistrar";
@@ -61,10 +101,15 @@ import { WorkflowPolicyUiPresentationFactory } from "../application/mapping/Work
 import { WorkflowWebsocketServer } from "../presentation/websocket/WorkflowWebsocketServer";
 import { CodemationFrontendAuthSnapshotFactory } from "../presentation/frontend/CodemationFrontendAuthSnapshotFactory";
 import { FrontendAppConfigFactory } from "../presentation/frontend/FrontendAppConfigFactory";
+import { InternalAuthBootstrapFactory } from "../presentation/frontend/InternalAuthBootstrapFactory";
+import { PublicFrontendBootstrapFactory } from "../presentation/frontend/PublicFrontendBootstrapFactory";
 import { DevBootstrapSummaryHttpRouteHandler } from "../presentation/http/routeHandlers/DevBootstrapSummaryHttpRouteHandler";
+import { InternalAuthBootstrapHttpRouteHandler } from "../presentation/http/routeHandlers/InternalAuthBootstrapHttpRouteHandler";
+import { PublicFrontendBootstrapHttpRouteHandler } from "../presentation/http/routeHandlers/PublicFrontendBootstrapHttpRouteHandler";
 import { WhitelabelLogoHttpRouteHandler } from "../presentation/http/routeHandlers/WhitelabelLogoHttpRouteHandler";
 import { CodemationHonoApiApp } from "../presentation/http/hono/CodemationHonoApiAppFactory";
 import { BinaryHonoApiRouteRegistrar } from "../presentation/http/hono/registrars/BinaryHonoApiRouteRegistrar";
+import { BootstrapHonoApiRouteRegistrar } from "../presentation/http/hono/registrars/BootstrapHonoApiRouteRegistrar";
 import { CredentialHonoApiRouteRegistrar } from "../presentation/http/hono/registrars/CredentialHonoApiRouteRegistrar";
 import { DevHonoApiRouteRegistrar } from "../presentation/http/hono/registrars/DevHonoApiRouteRegistrar";
 import { OAuth2HonoApiRouteRegistrar } from "../presentation/http/hono/registrars/OAuth2HonoApiRouteRegistrar";
@@ -124,8 +169,47 @@ type PrismaOwnership = Readonly<{
 }>;
 
 export class AppContainerFactory {
+  private static readonly queryHandlers = [
+    GetCredentialFieldEnvStatusQueryHandler,
+    GetCredentialInstanceQueryHandler,
+    GetCredentialInstanceWithSecretsQueryHandler,
+    GetWorkflowCredentialHealthQueryHandler,
+    ListCredentialInstancesQueryHandler,
+    ListCredentialTypesQueryHandler,
+    ListUserAccountsQueryHandler,
+    VerifyUserInviteQueryHandler,
+    GetRunBinaryAttachmentQueryHandler,
+    GetRunStateQueryHandler,
+    GetWorkflowDebuggerOverlayQueryHandler,
+    GetWorkflowDetailQueryHandler,
+    GetWorkflowOverlayBinaryAttachmentQueryHandler,
+    GetWorkflowSummariesQueryHandler,
+    ListWorkflowRunsQueryHandler,
+  ] as const;
+  private static readonly commandHandlers = [
+    CreateCredentialInstanceCommandHandler,
+    DeleteCredentialInstanceCommandHandler,
+    TestCredentialInstanceCommandHandler,
+    UpdateCredentialInstanceCommandHandler,
+    UpsertCredentialBindingCommandHandler,
+    AcceptUserInviteCommandHandler,
+    InviteUserCommandHandler,
+    RegenerateUserInviteCommandHandler,
+    UpdateUserAccountStatusCommandHandler,
+    UpsertLocalBootstrapUserCommandHandler,
+    CopyRunToWorkflowDebuggerCommandHandler,
+    HandleWebhookInvocationCommandHandler,
+    ReplaceMutableRunWorkflowSnapshotCommandHandler,
+    ReplaceWorkflowDebuggerOverlayCommandHandler,
+    ReplayWorkflowNodeCommandHandler,
+    SetPinnedNodeInputCommandHandler,
+    SetWorkflowActivationCommandHandler,
+    StartWorkflowRunCommandHandler,
+    UploadOverlayPinnedBinaryCommandHandler,
+  ] as const;
   private static readonly honoRouteRegistrars = [
     BinaryHonoApiRouteRegistrar,
+    BootstrapHonoApiRouteRegistrar,
     CredentialHonoApiRouteRegistrar,
     DevHonoApiRouteRegistrar,
     OAuth2HonoApiRouteRegistrar,
@@ -327,6 +411,8 @@ export class AppContainerFactory {
     container.register(OAuth2ConnectService, { useClass: OAuth2ConnectService });
     container.register(CodemationFrontendAuthSnapshotFactory, { useClass: CodemationFrontendAuthSnapshotFactory });
     container.register(FrontendAppConfigFactory, { useClass: FrontendAppConfigFactory });
+    container.register(PublicFrontendBootstrapFactory, { useClass: PublicFrontendBootstrapFactory });
+    container.register(InternalAuthBootstrapFactory, { useClass: InternalAuthBootstrapFactory });
     container.register(DatabaseMigrations, { useClass: DatabaseMigrations });
     container.register(FrontendRuntime, { useClass: FrontendRuntime });
     container.register(WorkerRuntime, { useClass: WorkerRuntime });
@@ -397,6 +483,12 @@ export class AppContainerFactory {
     container.register(InMemoryQueryBus, { useClass: InMemoryQueryBus });
     container.register(InMemoryCommandBus, { useClass: InMemoryCommandBus });
     container.register(InMemoryDomainEventBus, { useClass: InMemoryDomainEventBus });
+    for (const handler of AppContainerFactory.queryHandlers) {
+      container.register(ApplicationTokens.QueryHandler, { useClass: handler });
+    }
+    for (const handler of AppContainerFactory.commandHandlers) {
+      container.register(ApplicationTokens.CommandHandler, { useClass: handler });
+    }
     container.register(ApplicationTokens.QueryBus, {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryQueryBus)),
     });
@@ -411,6 +503,8 @@ export class AppContainerFactory {
   private registerApplicationServicesAndRoutes(container: Container): void {
     container.register(DevBootstrapSummaryAssembler, { useClass: DevBootstrapSummaryAssembler });
     container.register(DevBootstrapSummaryHttpRouteHandler, { useClass: DevBootstrapSummaryHttpRouteHandler });
+    container.register(PublicFrontendBootstrapHttpRouteHandler, { useClass: PublicFrontendBootstrapHttpRouteHandler });
+    container.register(InternalAuthBootstrapHttpRouteHandler, { useClass: InternalAuthBootstrapHttpRouteHandler });
     container.register(WhitelabelLogoHttpRouteHandler, { useClass: WhitelabelLogoHttpRouteHandler });
     for (const registrar of AppContainerFactory.honoRouteRegistrars) {
       container.register(ApplicationTokens.HonoApiRouteRegistrar, { useClass: registrar });
@@ -561,6 +655,7 @@ export class AppContainerFactory {
     return {
       databasePersistence: appConfig.persistence,
       eventBusKind: appConfig.eventing.kind,
+      plugins: appConfig.pluginLoadSummary ?? [],
       queuePrefix: appConfig.scheduler.queuePrefix ?? appConfig.eventing.queuePrefix ?? "codemation",
       schedulerKind: appConfig.scheduler.kind,
       redisUrl: appConfig.scheduler.redisUrl ?? appConfig.eventing.redisUrl,

package/src/bootstrap/runtime/AppConfigFactory.ts

@@ -1,5 +1,6 @@
 import { CoreTokens } from "@codemation/core";
-import type { AppConfig } from "../../presentation/config/AppConfig";
+import type { AppConfig, AppPluginLoadSummary } from "../../presentation/config/AppConfig";
+import { CodemationPluginPackageMetadata } from "../../presentation/config/CodemationPlugin";
 import type { NormalizedCodemationConfig } from "../../presentation/config/CodemationConfigNormalizer";
 import type {
   CodemationApplicationRuntimeConfig,
@@ -10,6 +11,8 @@ import type {
 import path from "node:path";
 
 export class AppConfigFactory {
+  private readonly pluginPackageMetadata = new CodemationPluginPackageMetadata();
+
   create(
     args: Readonly<{
       repoRoot: string;
@@ -30,6 +33,7 @@ export class AppConfigFactory {
     const hasConfiguredCredentialSessionServiceRegistration = args.config.containerRegistrations.some(
       (entry) => entry.token === CoreTokens.CredentialSessionService,
     );
+    const plugins = [...(args.config.plugins ?? [])];
 
     return {
       consumerRoot: args.consumerRoot,
@@ -39,7 +43,8 @@ export class AppConfigFactory {
       workflows: [...(args.config.workflows ?? [])],
       containerRegistrations: [...args.config.containerRegistrations],
       credentialTypes: [...(args.config.credentialTypes ?? [])],
-      plugins: [...(args.config.plugins ?? [])],
+      plugins,
+      pluginLoadSummary: this.createConfiguredPluginLoadSummary(plugins),
       hasConfiguredCredentialSessionServiceRegistration,
       log: args.config.log,
       engineExecutionLimits: runtimeConfig.engineExecutionLimits,
@@ -65,6 +70,21 @@ export class AppConfigFactory {
     };
   }
 
+  private createConfiguredPluginLoadSummary(plugins: AppConfig["plugins"]): AppConfig["pluginLoadSummary"] {
+    const summaries: AppPluginLoadSummary[] = [];
+    for (const plugin of plugins) {
+      const packageName = this.pluginPackageMetadata.readPackageName(plugin);
+      if (!packageName) {
+        continue;
+      }
+      summaries.push({
+        packageName,
+        source: "configured",
+      });
+    }
+    return summaries;
+  }
+
   private resolvePersistence(
     runtimeConfig: CodemationApplicationRuntimeConfig,
     env: NodeJS.ProcessEnv,

package/src/client.ts

@@ -6,5 +6,9 @@ export type {
   CodemationFrontendAuthProviderSnapshot,
   CodemationFrontendAuthSnapshot,
 } from "./presentation/frontend/CodemationFrontendAuthSnapshot";
+export type { InternalAuthBootstrap } from "./presentation/frontend/InternalAuthBootstrap";
+export type { PublicFrontendBootstrap } from "./presentation/frontend/PublicFrontendBootstrap";
 export { CodemationFrontendAuthSnapshotJsonCodec } from "./presentation/frontend/CodemationFrontendAuthSnapshotJsonCodec";
 export { FrontendAppConfigJsonCodec } from "./presentation/frontend/FrontendAppConfigJsonCodec";
+export { InternalAuthBootstrapJsonCodec } from "./presentation/frontend/InternalAuthBootstrapJsonCodec";
+export { PublicFrontendBootstrapJsonCodec } from "./presentation/frontend/PublicFrontendBootstrapJsonCodec";

package/src/index.ts

@@ -10,9 +10,10 @@ export { FrontendRuntime } from "./bootstrap/runtime/FrontendRuntime";
 export { WorkerRuntime } from "./bootstrap/runtime/WorkerRuntime";
 export { AppConfigFactory } from "./bootstrap/runtime/AppConfigFactory";
 export { ApplicationTokens } from "./applicationTokens";
+export { workflow } from "@codemation/core-nodes";
 export { CodemationBootstrapRequest } from "./bootstrap/CodemationBootstrapRequest";
 export type { CodemationWhitelabelConfig } from "./presentation/config/CodemationWhitelabelConfig";
-export type { AppConfig } from "./presentation/config/AppConfig";
+export type { AppConfig, AppPluginLoadSummary } from "./presentation/config/AppConfig";
 export type {
   CodemationAuthConfig,
   CodemationAuthKind,
@@ -34,6 +35,13 @@ export type {
   CodemationSchedulerConfig,
   CodemationSchedulerKind,
 } from "./presentation/config/CodemationConfig";
+export type {
+  DefineCodemationAppOptions,
+  DefinePluginOptions,
+  FriendlyCodemationDatabaseConfig,
+  FriendlyCodemationExecutionConfig,
+} from "./presentation/config/CodemationAuthoring.types";
+export { defineCodemationApp, definePlugin } from "./presentation/config/CodemationAuthoring.types";
 export type {
   CodemationAppContext,
   CodemationRegistrationContextBase,
@@ -48,19 +56,27 @@ export type {
   CodemationLogLevelName,
   CodemationLogRule,
 } from "./presentation/config/CodemationLogConfig";
+export type { CodemationPackageManifest } from "./presentation/config/CodemationPackageManifest";
 export type {
-  CodemationPackageManifest,
-  CodemationPluginPackageManifest,
-} from "./presentation/config/CodemationPackageManifest";
-export type { CodemationPlugin, CodemationPluginContext } from "./presentation/config/CodemationPlugin";
+  CodemationPlugin,
+  CodemationPluginConfig,
+  CodemationPluginContext,
+} from "./presentation/config/CodemationPlugin";
+export { CodemationPluginPackageMetadata } from "./presentation/config/CodemationPlugin";
 export { CodemationPluginListMerger } from "./presentation/config/CodemationPluginListMerger";
 export type { CodemationWorkflowDiscovery } from "./presentation/config/CodemationWorkflowDiscovery";
+export type { InternalAuthBootstrap } from "./presentation/frontend/InternalAuthBootstrap";
+export type { PublicFrontendBootstrap } from "./presentation/frontend/PublicFrontendBootstrap";
 export {
   ApiPaths,
   CodemationFrontendAuthSnapshotFactory,
   CodemationFrontendAuthSnapshotJsonCodec,
   FrontendAppConfigFactory,
   FrontendAppConfigJsonCodec,
+  InternalAuthBootstrapFactory,
+  InternalAuthBootstrapJsonCodec,
+  PublicFrontendBootstrapFactory,
+  PublicFrontendBootstrapJsonCodec,
   CodemationConsumerConfigLoader,
   CodemationPostgresPrismaClientFactory,
   CodemationServerGateway,

package/src/infrastructure/config/CodemationPluginRegistrar.ts

@@ -15,6 +15,12 @@ export class CodemationPluginRegistrar {
     }>,
   ): Promise<void> {
     for (const plugin of args.plugins) {
+      for (const credentialType of plugin.credentialTypes ?? []) {
+        args.registerCredentialType(credentialType);
+      }
+      if (!plugin.register) {
+        continue;
+      }
       await plugin.register({
         container: args.container,
         appConfig: args.appConfig,

package/src/infrastructure/di/HandlesCommandRegistry.ts

@@ -1,10 +1,7 @@
-import { injectable, registry } from "@codemation/core";
+import { injectable } from "@codemation/core";
 import type { Command } from "../../application/bus/Command";
-import type { CommandHandler } from "../../application/bus/CommandHandler";
-import { ApplicationTokens } from "../../applicationTokens";
 
 type AbstractType<TInstance> = abstract new (...args: any[]) => TInstance;
-type ConcreteType<TInstance> = new (...args: any[]) => TInstance;
 
 export const commandHandlerMetadataKey = Symbol.for("codemation.infrastructure.di.CommandHandler");
 
@@ -13,12 +10,6 @@ export class HandlesCommand {
     return (target) => {
       Reflect.defineMetadata(commandHandlerMetadataKey, commandType, target);
       injectable()(target as never);
-      registry([
-        {
-          token: ApplicationTokens.CommandHandler,
-          useClass: target as unknown as ConcreteType<CommandHandler<Command<unknown>, unknown>>,
-        },
-      ])(target as never);
     };
   }
 }

package/src/infrastructure/di/HandlesQueryRegistry.ts

@@ -1,10 +1,7 @@
-import { injectable, registry } from "@codemation/core";
+import { injectable } from "@codemation/core";
 import type { Query } from "../../application/bus/Query";
-import type { QueryHandler } from "../../application/bus/QueryHandler";
-import { ApplicationTokens } from "../../applicationTokens";
 
 type AbstractType<TInstance> = abstract new (...args: any[]) => TInstance;
-type ConcreteType<TInstance> = new (...args: any[]) => TInstance;
 
 export const queryHandlerMetadataKey = Symbol.for("codemation.infrastructure.di.QueryHandler");
 
@@ -13,12 +10,6 @@ export class HandlesQuery {
     return (target) => {
       Reflect.defineMetadata(queryHandlerMetadataKey, queryType, target);
       injectable()(target as never);
-      registry([
-        {
-          token: ApplicationTokens.QueryHandler,
-          useClass: target as unknown as ConcreteType<QueryHandler<Query<unknown>, unknown>>,
-        },
-      ])(target as never);
     };
   }
 }

package/src/nextServer.ts

@@ -27,7 +27,11 @@ export type {
   CodemationFrontendAuthSnapshot,
 } from "./presentation/frontend/CodemationFrontendAuthSnapshot";
 export type { FrontendAppConfig } from "./presentation/frontend/FrontendAppConfig";
+export type { InternalAuthBootstrap } from "./presentation/frontend/InternalAuthBootstrap";
+export type { PublicFrontendBootstrap } from "./presentation/frontend/PublicFrontendBootstrap";
 export { FrontendAppConfigFactory } from "./presentation/frontend/FrontendAppConfigFactory";
+export { InternalAuthBootstrapFactory } from "./presentation/frontend/InternalAuthBootstrapFactory";
+export { PublicFrontendBootstrapFactory } from "./presentation/frontend/PublicFrontendBootstrapFactory";
 export { CredentialBindingService, CredentialInstanceService } from "./domain/credentials/CredentialServices";
 export { RequestToWebhookItemMapper } from "./infrastructure/webhooks/RequestToWebhookItemMapper";
 export { CodemationHonoApiApp } from "./presentation/http/hono/CodemationHonoApiAppFactory";

package/src/presentation/config/AppConfig.ts

@@ -16,6 +16,11 @@ export type AppPersistenceConfig =
   | Readonly<{ kind: "postgresql"; databaseUrl: string }>
   | Readonly<{ kind: "pglite"; dataDir: string }>;
 
+export type AppPluginLoadSummary = Readonly<{
+  packageName: string;
+  source: "configured" | "discovered";
+}>;
+
 export interface AppConfig {
   readonly consumerRoot: string;
   readonly repoRoot: string;
@@ -25,6 +30,7 @@ export interface AppConfig {
   readonly containerRegistrations: ReadonlyArray<CodemationContainerRegistration<unknown>>;
   readonly credentialTypes: ReadonlyArray<AnyCredentialType>;
   readonly plugins: ReadonlyArray<CodemationPlugin>;
+  readonly pluginLoadSummary?: ReadonlyArray<AppPluginLoadSummary>;
   readonly hasConfiguredCredentialSessionServiceRegistration: boolean;
   readonly log?: CodemationLogConfig;
   readonly engineExecutionLimits?: CodemationEngineExecutionLimitsConfig;

package/src/presentation/config/CodemationAuthoring.types.ts

@@ -0,0 +1,169 @@
+import type { AnyCredentialType, DefinedNode, WorkflowDefinition } from "@codemation/core";
+import type { CodemationAppContext } from "./CodemationAppContext";
+import type {
+  CodemationAppDefinition,
+  CodemationAppSchedulerConfig,
+  CodemationConfig,
+  CodemationDatabaseConfig,
+} from "./CodemationConfig";
+import type { CodemationPlugin, CodemationPluginContext } from "./CodemationPlugin";
+import type { CodemationWhitelabelConfig } from "./CodemationWhitelabelConfig";
+
+export interface FriendlyCodemationDatabaseConfig {
+  readonly kind: "postgresql" | "pglite";
+  readonly url?: string;
+  readonly dataDir?: string;
+}
+
+export interface FriendlyCodemationExecutionConfig {
+  readonly mode?: "inline" | "queue";
+  readonly queuePrefix?: string;
+  readonly workerQueues?: ReadonlyArray<string>;
+  readonly redisUrl?: string;
+}
+
+export interface DefineCodemationAppOptions extends Omit<
+  CodemationConfig,
+  "app" | "credentialTypes" | "register" | "whitelabel" | "auth"
+> {
+  readonly name?: string;
+  readonly auth?: CodemationConfig["auth"];
+  readonly database?: FriendlyCodemationDatabaseConfig;
+  readonly execution?: FriendlyCodemationExecutionConfig;
+  readonly nodes?: ReadonlyArray<DefinedNode<string, Record<string, unknown>, unknown, unknown>>;
+  readonly credentialTypes?: ReadonlyArray<AnyCredentialType>;
+  readonly credentials?: ReadonlyArray<AnyCredentialType>;
+  readonly register?: (context: CodemationAppContext) => void;
+  readonly whitelabel?: CodemationWhitelabelConfig;
+}
+
+export interface DefinePluginOptions {
+  readonly name?: string;
+  readonly pluginPackageId?: string;
+  readonly nodes?: ReadonlyArray<DefinedNode<string, Record<string, unknown>, unknown, unknown>>;
+  readonly credentials?: ReadonlyArray<AnyCredentialType>;
+  readonly register?: (context: CodemationPluginContext) => void | Promise<void>;
+  readonly sandbox?: DefineCodemationAppOptions & Readonly<{ workflows?: ReadonlyArray<WorkflowDefinition> }>;
+}
+
+class CodemationAuthoringConfigFactory {
+  static createApp(options: DefineCodemationAppOptions): CodemationConfig {
+    const appDefinition = this.createAppDefinition(options);
+    const credentialTypes = [...(options.credentialTypes ?? []), ...(options.credentials ?? [])];
+    const register = this.composeAppRegister(options.register, options.nodes);
+    const { workflows, workflowDiscovery, plugins, runtime, log } = options;
+    return {
+      workflows,
+      workflowDiscovery,
+      plugins,
+      runtime,
+      log,
+      app: appDefinition,
+      credentialTypes,
+      register,
+    };
+  }
+
+  static createPlugin(
+    options: DefinePluginOptions,
+  ): CodemationPlugin & Readonly<{ sandbox?: DefinePluginOptions["sandbox"] }> {
+    return {
+      pluginPackageId: options.pluginPackageId,
+      sandbox: options.sandbox,
+      async register(context: CodemationPluginContext): Promise<void> {
+        for (const nodeDefinition of options.nodes ?? []) {
+          nodeDefinition.register(context);
+        }
+        for (const credential of options.credentials ?? []) {
+          context.registerCredentialType(credential);
+        }
+        await options.register?.(context);
+      },
+    };
+  }
+
+  private static createAppDefinition(options: DefineCodemationAppOptions): CodemationAppDefinition | undefined {
+    const scheduler = this.createSchedulerConfig(options.execution);
+    const database = this.createDatabaseConfig(options.database);
+    const whitelabel = this.createWhitelabel(options.name, options.whitelabel);
+    if (!options.auth && !database && !scheduler && !whitelabel) {
+      return undefined;
+    }
+    return {
+      auth: options.auth,
+      database,
+      scheduler,
+      whitelabel,
+    };
+  }
+
+  private static createDatabaseConfig(
+    database: FriendlyCodemationDatabaseConfig | undefined,
+  ): CodemationDatabaseConfig | undefined {
+    if (!database) {
+      return undefined;
+    }
+    if (database.kind === "pglite") {
+      return {
+        kind: "pglite",
+        pgliteDataDir: database.dataDir,
+      };
+    }
+    return {
+      kind: "postgresql",
+      url: database.url,
+    };
+  }
+
+  private static createSchedulerConfig(
+    execution: FriendlyCodemationExecutionConfig | undefined,
+  ): CodemationAppSchedulerConfig | undefined {
+    if (!execution) {
+      return undefined;
+    }
+    return {
+      kind: execution.mode,
+      queuePrefix: execution.queuePrefix,
+      workerQueues: execution.workerQueues,
+      redisUrl: execution.redisUrl,
+    };
+  }
+
+  private static createWhitelabel(
+    name: string | undefined,
+    whitelabel: CodemationWhitelabelConfig | undefined,
+  ): CodemationWhitelabelConfig | undefined {
+    if (!name && !whitelabel) {
+      return undefined;
+    }
+    return {
+      productName: name ?? whitelabel?.productName,
+      logoPath: whitelabel?.logoPath,
+    };
+  }
+
+  private static composeAppRegister(
+    register: ((context: CodemationAppContext) => void) | undefined,
+    nodes: ReadonlyArray<DefinedNode<string, Record<string, unknown>, unknown, unknown>> | undefined,
+  ): ((context: CodemationAppContext) => void) | undefined {
+    if (!register && (!nodes || nodes.length === 0)) {
+      return undefined;
+    }
+    return (context: CodemationAppContext) => {
+      for (const nodeDefinition of nodes ?? []) {
+        nodeDefinition.register(context);
+      }
+      register?.(context);
+    };
+  }
+}
+
+export function defineCodemationApp(options: DefineCodemationAppOptions): CodemationConfig {
+  return CodemationAuthoringConfigFactory.createApp(options);
+}
+
+export function definePlugin(
+  options: DefinePluginOptions,
+): CodemationPlugin & Readonly<{ sandbox?: DefinePluginOptions["sandbox"] }> {
+  return CodemationAuthoringConfigFactory.createPlugin(options);
+}

package/src/presentation/config/CodemationPackageManifest.ts

@@ -1,9 +1,3 @@
-export interface CodemationPluginPackageManifest {
-  readonly kind: "plugin";
-  readonly entry: string;
-  readonly exportName?: string;
-}
-
 export interface CodemationPackageManifest {
-  readonly plugin?: CodemationPluginPackageManifest;
+  readonly plugin?: string;
 }

package/src/presentation/config/CodemationPlugin.ts

@@ -1,7 +1,8 @@
-import type { Container } from "@codemation/core";
+import type { AnyCredentialType, Container } from "@codemation/core";
 import type { LoggerFactory } from "../../application/logging/Logger";
 import type { AppConfig } from "./AppConfig";
 import type { CodemationRegistrationContextBase } from "./CodemationAppContext";
+import type { CodemationConfig } from "./CodemationConfig";
 
 export interface CodemationPluginContext extends CodemationRegistrationContextBase {
   readonly container: Container;
@@ -9,12 +10,48 @@ export interface CodemationPluginContext extends CodemationRegistrationContextBa
   readonly loggerFactory: LoggerFactory;
 }
 
-export interface CodemationPlugin {
-  /**
-   * Optional npm package name for this plugin (e.g. `"@codemation/core-nodes-gmail"`).
-   * When set, the host merges configured and discovered plugin lists by this id so the same package is not
-   * registered twice when separate module graphs load duplicate class instances (different `constructor` values).
-   */
+export interface CodemationPluginConfig {
   readonly pluginPackageId?: string;
-  register(context: CodemationPluginContext): void | Promise<void>;
+  readonly credentialTypes?: ReadonlyArray<AnyCredentialType>;
+  readonly register?: (context: CodemationPluginContext) => void | Promise<void>;
+  readonly sandbox?: CodemationConfig;
+}
+
+export type CodemationPlugin = CodemationPluginConfig;
+
+const definePlugin = <TConfig extends CodemationPluginConfig>(config: TConfig): TConfig => config;
+
+export { definePlugin };
+
+export class CodemationPluginPackageMetadata {
+  private static readonly packageNameSymbol = Symbol.for("@codemation/plugin-package-name");
+
+  attachPackageName(plugin: CodemationPlugin, packageName: string): CodemationPlugin {
+    if (packageName.trim().length === 0) {
+      return plugin;
+    }
+    const mutablePlugin = plugin as CodemationPlugin & {
+      [CodemationPluginPackageMetadata.packageNameSymbol]?: string;
+    };
+    const existingPackageName = mutablePlugin[CodemationPluginPackageMetadata.packageNameSymbol];
+    if (existingPackageName === packageName) {
+      return plugin;
+    }
+    Object.defineProperty(mutablePlugin, CodemationPluginPackageMetadata.packageNameSymbol, {
+      configurable: true,
+      enumerable: false,
+      value: packageName,
+      writable: true,
+    });
+    return plugin;
+  }
+
+  readPackageName(plugin: CodemationPlugin): string | undefined {
+    const packageName = (
+      plugin as CodemationPlugin & {
+        [CodemationPluginPackageMetadata.packageNameSymbol]?: unknown;
+      }
+    )[CodemationPluginPackageMetadata.packageNameSymbol];
+    return typeof packageName === "string" && packageName.trim().length > 0 ? packageName : undefined;
+  }
 }