@codemation/host 0.0.1

package/src/application/contracts/CredentialContractsRegistry.ts

@@ -0,0 +1,88 @@
+import type {
+  CredentialHealth,
+  CredentialInstanceId,
+  CredentialMaterialSourceKind,
+  CredentialRequirement,
+  CredentialSetupStatus,
+  CredentialTypeDefinition,
+  CredentialTypeId,
+} from "@codemation/core";
+
+export type CredentialInstanceDto = Readonly<{
+  instanceId: CredentialInstanceId;
+  typeId: CredentialTypeId;
+  displayName: string;
+  sourceKind: CredentialMaterialSourceKind;
+  publicConfig: Readonly<Record<string, unknown>>;
+  tags: ReadonlyArray<string>;
+  setupStatus: CredentialSetupStatus;
+  createdAt: string;
+  updatedAt: string;
+  latestHealth?: CredentialHealth;
+  oauth2Connection?: CredentialOAuth2ConnectionDto;
+}>;
+
+export type CredentialOAuth2ConnectionDto = Readonly<{
+  status: "connected" | "disconnected";
+  providerId: string;
+  connectedEmail?: string;
+  connectedAt?: string;
+  scopes: ReadonlyArray<string>;
+  updatedAt?: string;
+}>;
+
+export type CredentialInstanceWithSecretsDto = CredentialInstanceDto &
+  Readonly<{
+    secretConfig?: Readonly<Record<string, string>>;
+    envSecretRefs?: Readonly<Record<string, string>>;
+  }>;
+
+export type WorkflowCredentialHealthSlotDto = Readonly<{
+  workflowId: string;
+  nodeId: string;
+  nodeName?: string;
+  requirement: CredentialRequirement;
+  instance?: Pick<CredentialInstanceDto, "instanceId" | "typeId" | "displayName" | "setupStatus">;
+  health: Readonly<{
+    status: "unbound" | "optional-unbound" | "unknown" | "healthy" | "failing";
+    message?: string;
+    testedAt?: string;
+  }>;
+}>;
+
+export type WorkflowCredentialHealthDto = Readonly<{
+  workflowId: string;
+  slots: ReadonlyArray<WorkflowCredentialHealthSlotDto>;
+}>;
+
+export type CreateCredentialInstanceRequest = Readonly<{
+  typeId: CredentialTypeId;
+  displayName: string;
+  sourceKind: CredentialMaterialSourceKind;
+  publicConfig?: Readonly<Record<string, unknown>>;
+  secretConfig?: Readonly<Record<string, unknown>>;
+  envSecretRefs?: Readonly<Record<string, string>>;
+  tags?: ReadonlyArray<string>;
+}>;
+
+export type UpdateCredentialInstanceRequest = Readonly<{
+  displayName?: string;
+  publicConfig?: Readonly<Record<string, unknown>>;
+  secretConfig?: Readonly<Record<string, unknown>>;
+  envSecretRefs?: Readonly<Record<string, string>>;
+  tags?: ReadonlyArray<string>;
+  setupStatus?: CredentialSetupStatus;
+}>;
+
+export type UpsertCredentialBindingRequest = Readonly<{
+  workflowId: string;
+  nodeId: string;
+  slotKey: string;
+  instanceId: CredentialInstanceId;
+}>;
+
+export class CredentialResponseMapper {
+  static toTypeDefinitionList(types: ReadonlyArray<CredentialTypeDefinition>): ReadonlyArray<CredentialTypeDefinition> {
+    return [...types];
+  }
+}

package/src/application/contracts/RunContracts.ts

@@ -0,0 +1,41 @@
+import type { Items, PersistedMutableRunState, PersistedRunState, RunCurrentState } from "@codemation/core";
+
+export type CreateRunRequest = Readonly<{
+  workflowId?: string;
+  items?: Items;
+  synthesizeTriggerItems?: boolean;
+  currentState?: RunCurrentState;
+  startAt?: string;
+  stopAt?: string;
+  clearFromNodeId?: string;
+  mode?: "manual" | "debug";
+  sourceRunId?: string;
+}>;
+
+export type UpdateRunWorkflowSnapshotRequest = Readonly<{
+  workflowSnapshot?: PersistedRunState["workflowSnapshot"];
+}>;
+
+export type UpdateRunNodePinRequest = Readonly<{
+  items?: Items;
+}>;
+
+export type RunNodeRequest = Readonly<{
+  items?: Items;
+  synthesizeTriggerItems?: boolean;
+  mode?: "manual" | "debug";
+}>;
+
+export type RunCommandResult = Readonly<{
+  runId: string;
+  workflowId: string;
+  startedAt?: string;
+  status: string;
+  state: PersistedRunState | null;
+}>;
+
+export type MutableRunNodeInputState = Readonly<{
+  state: PersistedRunState;
+  mutableState: PersistedMutableRunState;
+  nodeId: string;
+}>;

package/src/application/contracts/WorkflowDebuggerContracts.ts

@@ -0,0 +1,12 @@
+import type { RunCurrentState } from "@codemation/core";
+import type { WorkflowDebuggerOverlayState } from "../../domain/workflows/WorkflowDebuggerOverlayState";
+
+export type UpdateWorkflowDebuggerOverlayRequest = Readonly<{
+  currentState?: RunCurrentState;
+}>;
+
+export type CopyRunToWorkflowDebuggerRequest = Readonly<{
+  sourceRunId?: string;
+}>;
+
+export type WorkflowDebuggerOverlayResponse = WorkflowDebuggerOverlayState;

package/src/application/contracts/WorkflowViewContracts.ts

@@ -0,0 +1,40 @@
+export type WorkflowNodeDto = Readonly<{
+  id: string;
+  kind: string;
+  name?: string;
+  type: string;
+  role?: string;
+  icon?: string;
+  parentNodeId?: string;
+  /** Short retry policy label for canvas/properties (e.g. fixed / exponential). */
+  retryPolicySummary?: string;
+  /** Whether this node declares a node-level error handler. */
+  hasNodeErrorHandler?: boolean;
+  /** When true, downstream nodes may run even when this node outputs zero items. */
+  continueWhenEmptyOutput?: boolean;
+}>;
+
+export type WorkflowEdgeDto = Readonly<{
+  from: Readonly<{ nodeId: string; output: string }>;
+  to: Readonly<{ nodeId: string; input: string }>;
+}>;
+
+export type WorkflowDto = Readonly<{
+  id: string;
+  name: string;
+  /** When true, trigger setup runs and webhooks are registered for this workflow. */
+  active: boolean;
+  nodes: ReadonlyArray<WorkflowNodeDto>;
+  edges: ReadonlyArray<WorkflowEdgeDto>;
+  /** Workflow-level error hook configured on the definition. */
+  hasWorkflowErrorHandler?: boolean;
+}>;
+
+export type WorkflowSummary = Readonly<{
+  id: string;
+  name: string;
+  /** When true, trigger setup runs and webhooks are registered for this workflow. */
+  active: boolean;
+  /** Path under workflow discovery root: folders + workflow file stem. */
+  discoveryPathSegments: readonly string[];
+}>;

package/src/application/contracts/WorkflowWebsocketMessage.ts

@@ -0,0 +1,8 @@
+import type { RunEvent } from "@codemation/core";
+
+export type WorkflowWebsocketMessage =
+  | Readonly<{ kind: "event"; event: RunEvent }>
+  | Readonly<{ kind: "workflowChanged"; workflowId: string }>
+  | Readonly<{ kind: "devBuildStarted"; workflowId: string; buildVersion?: string }>
+  | Readonly<{ kind: "devBuildCompleted"; workflowId: string; buildVersion: string }>
+  | Readonly<{ kind: "devBuildFailed"; workflowId: string; message: string }>;

package/src/application/contracts/userDirectoryContracts.types.ts

@@ -0,0 +1,60 @@
+export type UserAccountStatus = "invited" | "active" | "inactive";
+
+export type UserAccountDto = Readonly<{
+  id: string;
+  email: string;
+  status: UserAccountStatus;
+  inviteExpiresAt: string | null;
+  /** Ways the user can sign in (password + linked OAuth / OIDC / email-link accounts). */
+  loginMethods: ReadonlyArray<string>;
+}>;
+
+/** Wire/cache payloads may omit `loginMethods` (older servers or partial JSON). */
+export type UserAccountDtoInput = Readonly<
+  Omit<UserAccountDto, "loginMethods"> & { loginMethods?: ReadonlyArray<string> | undefined }
+>;
+
+export type InviteUserResponseDto = Readonly<{
+  user: UserAccountDto;
+  inviteUrl: string;
+}>;
+
+export function withUserAccountLoginMethodsDefaults(input: UserAccountDtoInput): UserAccountDto {
+  const loginMethods = input.loginMethods;
+  return {
+    ...input,
+    loginMethods: Array.isArray(loginMethods) ? loginMethods : [],
+  };
+}
+
+export function withInviteUserResponseLoginMethodsDefaults(
+  input: Readonly<{ user: UserAccountDtoInput; inviteUrl: string }>,
+): InviteUserResponseDto {
+  return {
+    inviteUrl: input.inviteUrl,
+    user: withUserAccountLoginMethodsDefaults(input.user),
+  };
+}
+
+export type VerifyUserInviteResponseDto = Readonly<{
+  valid: boolean;
+  email?: string;
+}>;
+
+export type InviteUserRequestDto = Readonly<{
+  email: string;
+}>;
+
+export type AcceptUserInviteRequestDto = Readonly<{
+  token: string;
+  password: string;
+}>;
+
+export type UpdateUserAccountStatusRequestDto = Readonly<{
+  status: UserAccountStatus;
+}>;
+
+/** Result of CLI/bootstrap `upsert` for a local password user (distinct from invite-based onboarding). */
+export type UpsertLocalBootstrapUserResultDto = Readonly<{
+  outcome: "created" | "updated";
+}>;

package/src/application/dev/BootRuntimeSnapshotHolder.ts

@@ -0,0 +1,19 @@
+import { injectable } from "@codemation/core";
+import type { BootRuntimeSummary } from "./BootRuntimeSummary.types";
+
+/**
+ * Holds the latest {@link BootRuntimeSummary} after {@link CodemationApplication} prepare wiring.
+ * Avoids injecting {@link CodemationApplication} into dev diagnostics (circular ESM graph with assembler).
+ */
+@injectable()
+export class BootRuntimeSnapshotHolder {
+  private snapshot: BootRuntimeSummary | null = null;
+
+  set(snapshot: BootRuntimeSummary | null): void {
+    this.snapshot = snapshot;
+  }
+
+  get(): BootRuntimeSummary | null {
+    return this.snapshot;
+  }
+}

package/src/application/dev/BootRuntimeSummary.types.ts

@@ -0,0 +1,11 @@
+import type { ResolvedDatabasePersistence } from "../../infrastructure/persistence/DatabasePersistenceResolver";
+import type { CodemationEventBusKind, CodemationSchedulerKind } from "../../presentation/config/CodemationConfig";
+
+/** Resolved persistence + scheduler wiring captured at host prepare time (dev banner / diagnostics). */
+export type BootRuntimeSummary = Readonly<{
+  databasePersistence: ResolvedDatabasePersistence;
+  eventBusKind: CodemationEventBusKind;
+  queuePrefix: string;
+  schedulerKind: CodemationSchedulerKind;
+  redisUrl?: string;
+}>;

package/src/application/dev/DevBootstrapSummaryAssembler.ts

@@ -0,0 +1,84 @@
+import { CoreTokens, inject, injectable } from "@codemation/core";
+import type { WorkflowRepository } from "@codemation/core";
+import { BootRuntimeSnapshotHolder } from "./BootRuntimeSnapshotHolder";
+import { LogLevelPolicyFactory } from "../../infrastructure/logging/LogLevelPolicyFactory";
+import { RuntimeWorkflowActivationPolicy } from "../../infrastructure/persistence/RuntimeWorkflowActivationPolicy";
+import type { BootRuntimeSummary } from "./BootRuntimeSummary.types";
+import type { DevBootstrapSummaryJson } from "./DevBootstrapSummaryJson.types";
+
+@injectable()
+export class DevBootstrapSummaryAssembler {
+  constructor(
+    @inject(BootRuntimeSnapshotHolder) private readonly bootRuntimeSnapshot: BootRuntimeSnapshotHolder,
+    @inject(LogLevelPolicyFactory) private readonly logLevelPolicyFactory: LogLevelPolicyFactory,
+    @inject(RuntimeWorkflowActivationPolicy) private readonly workflowActivationPolicy: RuntimeWorkflowActivationPolicy,
+    @inject(CoreTokens.WorkflowRepository) private readonly workflowRepository: WorkflowRepository,
+  ) {}
+
+  assemble(): DevBootstrapSummaryJson | null {
+    const summary = this.bootRuntimeSnapshot.get();
+    if (!summary) {
+      return null;
+    }
+    const envRaw = process.env.CODEMATION_LOG_LEVEL?.trim();
+    const min = this.logLevelPolicyFactory.create().resolveMin();
+    const logLevel = envRaw && envRaw.length > 0 ? `${min} (CODEMATION_LOG_LEVEL=${envRaw})` : `${min}`;
+    const workflows = [...this.workflowRepository.list()].sort((a, b) => a.name.localeCompare(b.name));
+    const active = workflows
+      .filter((w) => this.workflowActivationPolicy.isActive(w.id))
+      .map((w) => ({ id: w.id, name: w.name }));
+    return {
+      logLevel,
+      codemationLogLevelEnv: envRaw && envRaw.length > 0 ? envRaw : undefined,
+      databaseLabel: this.formatDatabase(summary),
+      schedulerLabel: this.formatScheduler(summary),
+      eventBusLabel: this.formatEventBus(summary),
+      redisUrlRedacted: this.formatRedis(summary),
+      activeWorkflows: active,
+    };
+  }
+
+  private formatDatabase(summary: BootRuntimeSummary): string {
+    const p = summary.databasePersistence;
+    if (p.kind === "none") {
+      return "in-memory (no Prisma persistence)";
+    }
+    if (p.kind === "pglite") {
+      return `PGlite — ${p.dataDir}`;
+    }
+    return `PostgreSQL — ${this.redactUrlForDisplay(p.databaseUrl)}`;
+  }
+
+  private formatScheduler(summary: BootRuntimeSummary): string {
+    if (summary.schedulerKind === "local") {
+      return "inline (this process)";
+    }
+    return `BullMQ — queue prefix "${summary.queuePrefix}"`;
+  }
+
+  private formatEventBus(summary: BootRuntimeSummary): string {
+    if (summary.eventBusKind === "memory") {
+      return "in-memory";
+    }
+    return "Redis";
+  }
+
+  private formatRedis(summary: BootRuntimeSummary): string | undefined {
+    if (!summary.redisUrl || summary.redisUrl.trim().length === 0) {
+      return undefined;
+    }
+    return this.redactUrlForDisplay(summary.redisUrl);
+  }
+
+  private redactUrlForDisplay(raw: string): string {
+    try {
+      const parsed = new URL(raw);
+      if (parsed.password) {
+        parsed.password = "***";
+      }
+      return parsed.toString();
+    } catch {
+      return "(unparseable URL)";
+    }
+  }
+}

package/src/application/dev/DevBootstrapSummaryJson.types.ts

@@ -0,0 +1,9 @@
+export type DevBootstrapSummaryJson = Readonly<{
+  logLevel: string;
+  codemationLogLevelEnv?: string;
+  databaseLabel: string;
+  schedulerLabel: string;
+  eventBusLabel: string;
+  redisUrlRedacted?: string;
+  activeWorkflows: ReadonlyArray<Readonly<{ id: string; name: string }>>;
+}>;

package/src/application/logging/LogFilter.ts

@@ -0,0 +1,7 @@
+export type LogFilter = (
+  entry: Readonly<{
+    scope: string;
+    level: "info" | "warn" | "error" | "debug";
+    message: string;
+  }>,
+) => boolean;

package/src/application/logging/Logger.ts

@@ -0,0 +1,10 @@
+export interface Logger {
+  info(message: string, exception?: Error): void;
+  warn(message: string, exception?: Error): void;
+  error(message: string, exception?: Error): void;
+  debug(message: string, exception?: Error): void;
+}
+
+export interface LoggerFactory {
+  create(scope: string): Logger;
+}

package/src/application/mapping/DataMapper.ts

@@ -0,0 +1,3 @@
+export interface DataMapper<TSource, TTarget> {
+  map(source: TSource): Promise<TTarget>;
+}

package/src/application/mapping/WorkflowDefinitionMapper.ts

@@ -0,0 +1,171 @@
+import type {
+  ChatModelConfig,
+  NodeDefinition,
+  ToolConfig,
+  WorkflowActivationPolicy,
+  WorkflowDefinition,
+} from "@codemation/core";
+import { AgentConfigInspector, ConnectionNodeIdFactory, CoreTokens, inject, injectable } from "@codemation/core";
+import type { WorkflowDto, WorkflowNodeDto, WorkflowSummary } from "../contracts/WorkflowViewContracts";
+import type { DataMapper } from "./DataMapper";
+import { WorkflowPolicyUiPresentationFactory } from "./WorkflowPolicyUiPresentationFactory";
+
+@injectable()
+export class WorkflowDefinitionMapper implements DataMapper<WorkflowDefinition, WorkflowDto> {
+  constructor(
+    @inject(WorkflowPolicyUiPresentationFactory)
+    private readonly policyUi: WorkflowPolicyUiPresentationFactory,
+    @inject(CoreTokens.WorkflowActivationPolicy)
+    private readonly workflowActivationPolicy: WorkflowActivationPolicy,
+  ) {}
+
+  async map(workflow: WorkflowDefinition): Promise<WorkflowDto> {
+    return this.mapSync(workflow);
+  }
+
+  mapSync(workflow: WorkflowDefinition): WorkflowDto {
+    return {
+      id: workflow.id,
+      name: workflow.name,
+      active: this.workflowActivationPolicy.isActive(workflow.id),
+      hasWorkflowErrorHandler: this.policyUi.workflowHasErrorHandler(workflow),
+      nodes: this.toNodes(workflow),
+      edges: this.toEdges(workflow),
+    };
+  }
+
+  toSummary(workflow: WorkflowDefinition): WorkflowSummary {
+    return {
+      id: workflow.id,
+      name: workflow.name,
+      active: this.workflowActivationPolicy.isActive(workflow.id),
+      discoveryPathSegments: workflow.discoveryPathSegments ?? [],
+    };
+  }
+
+  private buildConnectionChildMeta(
+    workflow: WorkflowDefinition,
+  ): ReadonlyMap<string, Readonly<{ parentNodeId: string; connectionName: string }>> {
+    const map = new Map<string, Readonly<{ parentNodeId: string; connectionName: string }>>();
+    for (const c of workflow.connections ?? []) {
+      for (const childId of c.childNodeIds) {
+        map.set(childId, { parentNodeId: c.parentNodeId, connectionName: c.connectionName });
+      }
+    }
+    return map;
+  }
+
+  private agentHasConnectionMetadata(workflow: WorkflowDefinition, agentNodeId: string): boolean {
+    return (workflow.connections ?? []).some((c) => c.parentNodeId === agentNodeId);
+  }
+
+  private toNodes(workflow: WorkflowDefinition): ReadonlyArray<WorkflowNodeDto> {
+    const connectionChildMeta = this.buildConnectionChildMeta(workflow);
+    const nodes: WorkflowNodeDto[] = [];
+    for (const node of workflow.nodes) {
+      const conn = connectionChildMeta.get(node.id);
+      if (conn) {
+        const role = conn.connectionName === "llm" ? "languageModel" : "tool";
+        nodes.push({
+          id: node.id,
+          kind: node.kind,
+          name: node.name ?? node.config?.name,
+          type: this.nodeTypeName(node),
+          role,
+          icon: node.config?.icon,
+          retryPolicySummary: this.policyUi.nodeRetrySummary(node.config),
+          hasNodeErrorHandler: this.policyUi.nodeHasErrorHandler(node.config),
+          parentNodeId: conn.parentNodeId,
+        });
+        continue;
+      }
+      nodes.push({
+        id: node.id,
+        kind: node.kind,
+        name: node.name ?? node.config?.name,
+        type: this.nodeTypeName(node),
+        role: AgentConfigInspector.isAgentNodeConfig(node.config) ? "agent" : "workflowNode",
+        icon: node.config?.icon,
+        retryPolicySummary: this.policyUi.nodeRetrySummary(node.config),
+        hasNodeErrorHandler: this.policyUi.nodeHasErrorHandler(node.config),
+      });
+      if (AgentConfigInspector.isAgentNodeConfig(node.config) && !this.agentHasConnectionMetadata(workflow, node.id)) {
+        nodes.push(this.createLanguageModelNode(node, node.config.chatModel));
+        for (const toolConfig of node.config.tools ?? []) {
+          nodes.push(this.createToolNode(node, toolConfig));
+        }
+      }
+    }
+    return nodes;
+  }
+
+  private toEdges(workflow: WorkflowDefinition): WorkflowDto["edges"] {
+    const edges = [...workflow.edges];
+    for (const node of workflow.nodes) {
+      if (!AgentConfigInspector.isAgentNodeConfig(node.config)) {
+        continue;
+      }
+      if (this.agentHasConnectionMetadata(workflow, node.id)) {
+        for (const c of workflow.connections ?? []) {
+          if (c.parentNodeId !== node.id) {
+            continue;
+          }
+          for (const childId of c.childNodeIds) {
+            edges.push({
+              from: { nodeId: node.id, output: "main" },
+              to: { nodeId: childId, input: "in" },
+            });
+          }
+        }
+        continue;
+      }
+      edges.push({
+        from: { nodeId: node.id, output: "main" },
+        to: { nodeId: ConnectionNodeIdFactory.languageModelConnectionNodeId(node.id), input: "in" },
+      });
+      for (const toolConfig of node.config.tools ?? []) {
+        edges.push({
+          from: { nodeId: node.id, output: "main" },
+          to: { nodeId: ConnectionNodeIdFactory.toolConnectionNodeId(node.id, toolConfig.name), input: "in" },
+        });
+      }
+    }
+    return edges;
+  }
+
+  private createLanguageModelNode(node: NodeDefinition, chatModel: ChatModelConfig): WorkflowNodeDto {
+    return {
+      id: ConnectionNodeIdFactory.languageModelConnectionNodeId(node.id),
+      kind: "node",
+      name: chatModel.presentation?.label ?? chatModel.name,
+      type: chatModel.name,
+      role: "languageModel",
+      icon: chatModel.presentation?.icon,
+      parentNodeId: node.id,
+    };
+  }
+
+  private createToolNode(node: NodeDefinition, toolConfig: ToolConfig): WorkflowNodeDto {
+    return {
+      id: ConnectionNodeIdFactory.toolConnectionNodeId(node.id, toolConfig.name),
+      kind: "node",
+      name: toolConfig.presentation?.label ?? toolConfig.name,
+      type: toolConfig.name,
+      role: "tool",
+      icon: toolConfig.presentation?.icon,
+      parentNodeId: node.id,
+    };
+  }
+
+  private nodeTypeName(node: NodeDefinition): string {
+    const configToken = node.config?.type as Readonly<{ name?: unknown }> | undefined;
+    if (typeof configToken?.name === "string" && configToken.name) {
+      return configToken.name;
+    }
+    const nodeToken = node.type as Readonly<{ name?: unknown }> | undefined;
+    if (typeof nodeToken?.name === "string" && nodeToken.name) {
+      return nodeToken.name;
+    }
+    return "Node";
+  }
+}

package/src/application/mapping/WorkflowPolicyUiPresentationFactory.ts

@@ -0,0 +1,39 @@
+import type { NodeDefinition, RetryPolicySpec, WorkflowDefinition } from "@codemation/core";
+
+/** UI-facing policy labels derived from workflow/node definitions (live or hydrated snapshot). */
+export class WorkflowPolicyUiPresentationFactory {
+  workflowHasErrorHandler(workflow: WorkflowDefinition): boolean {
+    return workflow.workflowErrorHandler !== undefined;
+  }
+
+  nodeRetrySummary(config: NodeDefinition["config"]): string | undefined {
+    const spec = config.retryPolicy as RetryPolicySpec | undefined;
+    if (!spec) return undefined;
+    if (spec.kind === "none") return "Retry: off";
+    if (spec.kind === "fixed") return `Retry: ${spec.maxAttempts}x @ ${spec.delayMs}ms`;
+    if (spec.kind === "exponential") {
+      const jitter = spec.jitter ? ", jitter" : "";
+      return `Retry: exp ${spec.maxAttempts}x from ${spec.initialDelayMs}ms (x${spec.multiplier}${jitter})`;
+    }
+    return undefined;
+  }
+
+  nodeHasErrorHandler(config: NodeDefinition["config"]): boolean {
+    return config.nodeErrorHandler !== undefined;
+  }
+
+  snapshotNodeRetrySummary(config: unknown): string | undefined {
+    const record = this.asRecord(config);
+    const spec = record.retryPolicy as RetryPolicySpec | undefined;
+    if (!spec || typeof spec !== "object") return undefined;
+    return this.nodeRetrySummary({ retryPolicy: spec } as NodeDefinition["config"]);
+  }
+
+  snapshotNodeHasErrorHandler(config: unknown): boolean {
+    return this.asRecord(config).nodeErrorHandler !== undefined;
+  }
+
+  private asRecord(value: unknown): Readonly<Record<string, unknown>> {
+    return value !== null && typeof value === "object" ? (value as Record<string, unknown>) : {};
+  }
+}

package/src/application/queries/CredentialQueryHandlers.ts

@@ -0,0 +1,12 @@
+export { GetCredentialInstanceQuery } from "./GetCredentialInstanceQuery";
+export { GetCredentialInstanceQueryHandler } from "./GetCredentialInstanceQueryHandler";
+export { GetCredentialInstanceWithSecretsQuery } from "./GetCredentialInstanceWithSecretsQuery";
+export { GetCredentialInstanceWithSecretsQueryHandler } from "./GetCredentialInstanceWithSecretsQueryHandler";
+export { GetWorkflowCredentialHealthQuery } from "./GetWorkflowCredentialHealthQuery";
+export { GetWorkflowCredentialHealthQueryHandler } from "./GetWorkflowCredentialHealthQueryHandler";
+export { ListCredentialInstancesQuery } from "./ListCredentialInstancesQuery";
+export { ListCredentialInstancesQueryHandler } from "./ListCredentialInstancesQueryHandler";
+export { ListCredentialTypesQuery } from "./ListCredentialTypesQuery";
+export { ListCredentialTypesQueryHandler } from "./ListCredentialTypesQueryHandler";
+export { GetCredentialFieldEnvStatusQuery } from "./GetCredentialFieldEnvStatusQuery";
+export { GetCredentialFieldEnvStatusQueryHandler } from "./GetCredentialFieldEnvStatusQueryHandler";

package/src/application/queries/GetCredentialFieldEnvStatusQuery.ts

@@ -0,0 +1,5 @@
+import { Query } from "../bus/Query";
+
+export type CredentialFieldEnvStatusDto = Readonly<Record<string, boolean>>;
+
+export class GetCredentialFieldEnvStatusQuery extends Query<CredentialFieldEnvStatusDto> {}