@codemation/host 0.0.1

package/src/application/bus/Query.ts

@@ -0,0 +1,3 @@
+export abstract class Query<TResult> {
+  protected readonly __resultType?: TResult;
+}

package/src/application/bus/QueryBus.ts

@@ -0,0 +1,5 @@
+import type { Query } from "./Query";
+
+export interface QueryBus {
+  execute<TResult>(query: Query<TResult>): Promise<TResult>;
+}

package/src/application/bus/QueryHandler.ts

@@ -0,0 +1,5 @@
+import type { Query } from "./Query";
+
+export abstract class QueryHandler<TQuery extends Query<TResult>, TResult> {
+  abstract execute(query: TQuery): Promise<TResult>;
+}

package/src/application/commands/AcceptUserInviteCommand.ts

@@ -0,0 +1,10 @@
+import { Command } from "../bus/Command";
+
+export class AcceptUserInviteCommand extends Command<void> {
+  constructor(
+    public readonly token: string,
+    public readonly password: string,
+  ) {
+    super();
+  }
+}

package/src/application/commands/AcceptUserInviteCommandHandler.ts

@@ -0,0 +1,19 @@
+import { inject } from "@codemation/core";
+
+import { CommandHandler } from "../bus/CommandHandler";
+
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+
+import { UserAccountService } from "../../domain/users/UserAccountServiceRegistry";
+import { AcceptUserInviteCommand } from "./AcceptUserInviteCommand";
+
+@HandlesCommand.forCommand(AcceptUserInviteCommand)
+export class AcceptUserInviteCommandHandler extends CommandHandler<AcceptUserInviteCommand, void> {
+  constructor(@inject(UserAccountService) private readonly userAccounts: UserAccountService) {
+    super();
+  }
+
+  async execute(command: AcceptUserInviteCommand): Promise<void> {
+    await this.userAccounts.acceptInvite(command.token, command.password);
+  }
+}

package/src/application/commands/CopyRunToWorkflowDebuggerCommand.ts

@@ -0,0 +1,14 @@
+import { Command } from "../bus/Command";
+import type {
+  CopyRunToWorkflowDebuggerRequest,
+  WorkflowDebuggerOverlayResponse,
+} from "../contracts/WorkflowDebuggerContracts";
+
+export class CopyRunToWorkflowDebuggerCommand extends Command<WorkflowDebuggerOverlayResponse> {
+  constructor(
+    public readonly workflowId: string,
+    public readonly body: CopyRunToWorkflowDebuggerRequest,
+  ) {
+    super();
+  }
+}

package/src/application/commands/CopyRunToWorkflowDebuggerCommandHandler.ts

@@ -0,0 +1,56 @@
+import { inject } from "@codemation/core";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
+import type { WorkflowDebuggerOverlayRepository } from "../../domain/workflows/WorkflowDebuggerOverlayRepository";
+import type { WorkflowDebuggerOverlayState } from "../../domain/workflows/WorkflowDebuggerOverlayState";
+import type { WorkflowDefinitionRepository } from "../../domain/workflows/WorkflowDefinitionRepository";
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+import { ApplicationRequestError } from "../ApplicationRequestError";
+import { CommandHandler } from "../bus/CommandHandler";
+import type { WorkflowDebuggerOverlayResponse } from "../contracts/WorkflowDebuggerContracts";
+import { WorkflowDebuggerOverlayStateFactory } from "../workflows/WorkflowDebuggerOverlayStateFactory";
+import { CopyRunToWorkflowDebuggerCommand } from "./CopyRunToWorkflowDebuggerCommand";
+
+@HandlesCommand.forCommand(CopyRunToWorkflowDebuggerCommand)
+export class CopyRunToWorkflowDebuggerCommandHandler extends CommandHandler<
+  CopyRunToWorkflowDebuggerCommand,
+  WorkflowDebuggerOverlayResponse
+> {
+  constructor(
+    @inject(ApplicationTokens.WorkflowRunRepository)
+    private readonly workflowRunRepository: WorkflowRunRepository,
+    @inject(ApplicationTokens.WorkflowDefinitionRepository)
+    private readonly workflowDefinitionRepository: WorkflowDefinitionRepository,
+    @inject(ApplicationTokens.WorkflowDebuggerOverlayRepository)
+    private readonly workflowDebuggerOverlayRepository: WorkflowDebuggerOverlayRepository,
+  ) {
+    super();
+  }
+
+  async execute(command: CopyRunToWorkflowDebuggerCommand): Promise<WorkflowDebuggerOverlayState> {
+    if (!command.body.sourceRunId) {
+      throw new ApplicationRequestError(400, "Missing sourceRunId");
+    }
+    const workflowId = decodeURIComponent(command.workflowId);
+    const sourceState = await this.workflowRunRepository.load(command.body.sourceRunId);
+    if (!sourceState) {
+      throw new ApplicationRequestError(404, "Unknown runId");
+    }
+    if (sourceState.workflowId !== workflowId) {
+      throw new ApplicationRequestError(400, "Run does not belong to the requested workflow");
+    }
+    const workflow = await this.workflowDefinitionRepository.getDefinition(workflowId);
+    if (!workflow) {
+      throw new ApplicationRequestError(404, "Unknown workflowId");
+    }
+    const existingOverlay = await this.workflowDebuggerOverlayRepository.load(workflowId);
+    const nextOverlay = WorkflowDebuggerOverlayStateFactory.copyRunStateToOverlay({
+      workflowId,
+      sourceState,
+      liveWorkflowNodeIds: new Set(workflow.nodes.map((node) => node.id)),
+      existingOverlay,
+    });
+    await this.workflowDebuggerOverlayRepository.save(nextOverlay);
+    return nextOverlay;
+  }
+}

package/src/application/commands/CreateCredentialInstanceCommand.ts

@@ -0,0 +1,9 @@
+import type { CreateCredentialInstanceRequest, CredentialInstanceDto } from "../contracts/CredentialContractsRegistry";
+
+import { Command } from "../bus/Command";
+
+export class CreateCredentialInstanceCommand extends Command<CredentialInstanceDto> {
+  constructor(public readonly body: CreateCredentialInstanceRequest) {
+    super();
+  }
+}

package/src/application/commands/CreateCredentialInstanceCommandHandler.ts

@@ -0,0 +1,28 @@
+import { inject } from "@codemation/core";
+
+import type { CredentialInstanceDto } from "../contracts/CredentialContractsRegistry";
+
+import { CommandHandler } from "../bus/CommandHandler";
+
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+
+import { CredentialInstanceService } from "../../domain/credentials/CredentialServices";
+
+import { CreateCredentialInstanceCommand } from "./CreateCredentialInstanceCommand";
+
+@HandlesCommand.forCommand(CreateCredentialInstanceCommand)
+export class CreateCredentialInstanceCommandHandler extends CommandHandler<
+  CreateCredentialInstanceCommand,
+  CredentialInstanceDto
+> {
+  constructor(
+    @inject(CredentialInstanceService)
+    private readonly credentialInstanceService: CredentialInstanceService,
+  ) {
+    super();
+  }
+
+  async execute(command: CreateCredentialInstanceCommand): Promise<CredentialInstanceDto> {
+    return await this.credentialInstanceService.create(command.body);
+  }
+}

package/src/application/commands/CredentialCommandHandlers.ts

@@ -0,0 +1,10 @@
+export { CreateCredentialInstanceCommand } from "./CreateCredentialInstanceCommand";
+export { CreateCredentialInstanceCommandHandler } from "./CreateCredentialInstanceCommandHandler";
+export { DeleteCredentialInstanceCommand } from "./DeleteCredentialInstanceCommand";
+export { DeleteCredentialInstanceCommandHandler } from "./DeleteCredentialInstanceCommandHandler";
+export { TestCredentialInstanceCommand } from "./TestCredentialInstanceCommand";
+export { TestCredentialInstanceCommandHandler } from "./TestCredentialInstanceCommandHandler";
+export { UpdateCredentialInstanceCommand } from "./UpdateCredentialInstanceCommand";
+export { UpdateCredentialInstanceCommandHandler } from "./UpdateCredentialInstanceCommandHandler";
+export { UpsertCredentialBindingCommand } from "./UpsertCredentialBindingCommand";
+export { UpsertCredentialBindingCommandHandler } from "./UpsertCredentialBindingCommandHandler";

package/src/application/commands/DeleteCredentialInstanceCommand.ts

@@ -0,0 +1,7 @@
+import { Command } from "../bus/Command";
+
+export class DeleteCredentialInstanceCommand extends Command<Readonly<{ ok: true }>> {
+  constructor(public readonly instanceId: string) {
+    super();
+  }
+}

package/src/application/commands/DeleteCredentialInstanceCommandHandler.ts

@@ -0,0 +1,27 @@
+import { inject } from "@codemation/core";
+
+import { CommandHandler } from "../bus/CommandHandler";
+
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+
+import { DeleteCredentialInstanceCommand } from "./DeleteCredentialInstanceCommand";
+
+import { CredentialInstanceService } from "../../domain/credentials/CredentialServices";
+
+@HandlesCommand.forCommand(DeleteCredentialInstanceCommand)
+export class DeleteCredentialInstanceCommandHandler extends CommandHandler<
+  DeleteCredentialInstanceCommand,
+  Readonly<{ ok: true }>
+> {
+  constructor(
+    @inject(CredentialInstanceService)
+    private readonly credentialInstanceService: CredentialInstanceService,
+  ) {
+    super();
+  }
+
+  async execute(command: DeleteCredentialInstanceCommand): Promise<Readonly<{ ok: true }>> {
+    await this.credentialInstanceService.delete(command.instanceId);
+    return { ok: true };
+  }
+}

package/src/application/commands/HandleWebhookInvocationCommand.ts

@@ -0,0 +1,12 @@
+import type { Item } from "@codemation/core";
+import { Command } from "../bus/Command";
+
+export class HandleWebhookInvocationCommand extends Command<unknown> {
+  constructor(
+    public readonly endpointPath: string,
+    public readonly requestMethod: string,
+    public readonly requestItem: Item,
+  ) {
+    super();
+  }
+}

package/src/application/commands/HandleWebhookInvocationCommandHandler.ts

@@ -0,0 +1,42 @@
+import type { WebhookRunResult } from "@codemation/core";
+import { inject } from "@codemation/core";
+import { RunIntentService } from "@codemation/core/bootstrap";
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+import { ApplicationRequestError } from "../ApplicationRequestError";
+import { CommandHandler } from "../bus/CommandHandler";
+import { HandleWebhookInvocationCommand } from "./HandleWebhookInvocationCommand";
+
+@HandlesCommand.forCommand(HandleWebhookInvocationCommand)
+export class HandleWebhookInvocationCommandHandler extends CommandHandler<HandleWebhookInvocationCommand, unknown> {
+  constructor(
+    @inject(RunIntentService)
+    private readonly runIntentService: RunIntentService,
+  ) {
+    super();
+  }
+
+  async execute(command: HandleWebhookInvocationCommand): Promise<unknown> {
+    try {
+      const requestMethod = command.requestMethod.toUpperCase() as "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+      const endpointPath = decodeURIComponent(command.endpointPath);
+      const resolution = this.runIntentService.resolveWebhookTrigger({ endpointPath, method: requestMethod });
+      if (resolution.status === "notFound") {
+        throw new ApplicationRequestError(404, "Unknown webhook endpoint");
+      }
+      if (resolution.status === "methodNotAllowed") {
+        throw new ApplicationRequestError(405, "Method not allowed");
+      }
+      const result = (await this.runIntentService.runWebhookMatch({
+        match: resolution.match,
+        requestItem: command.requestItem,
+      })) satisfies WebhookRunResult;
+      return result.response.at(-1)?.json ?? null;
+    } catch (error) {
+      if (error instanceof ApplicationRequestError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new ApplicationRequestError(400, message);
+    }
+  }
+}

package/src/application/commands/InviteUserCommand.ts

@@ -0,0 +1,12 @@
+import type { InviteUserResponseDto } from "../contracts/userDirectoryContracts.types";
+
+import { Command } from "../bus/Command";
+
+export class InviteUserCommand extends Command<InviteUserResponseDto> {
+  constructor(
+    public readonly email: string,
+    public readonly requestOrigin: string,
+  ) {
+    super();
+  }
+}

package/src/application/commands/InviteUserCommandHandler.ts

@@ -0,0 +1,22 @@
+import { inject } from "@codemation/core";
+
+import type { InviteUserResponseDto } from "../contracts/userDirectoryContracts.types";
+
+import { CommandHandler } from "../bus/CommandHandler";
+
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+
+import { UserAccountService } from "../../domain/users/UserAccountServiceRegistry";
+
+import { InviteUserCommand } from "./InviteUserCommand";
+
+@HandlesCommand.forCommand(InviteUserCommand)
+export class InviteUserCommandHandler extends CommandHandler<InviteUserCommand, InviteUserResponseDto> {
+  constructor(@inject(UserAccountService) private readonly userAccounts: UserAccountService) {
+    super();
+  }
+
+  async execute(command: InviteUserCommand): Promise<InviteUserResponseDto> {
+    return await this.userAccounts.inviteUser(command.email, command.requestOrigin);
+  }
+}

package/src/application/commands/RegenerateUserInviteCommand.ts

@@ -0,0 +1,12 @@
+import type { InviteUserResponseDto } from "../contracts/userDirectoryContracts.types";
+
+import { Command } from "../bus/Command";
+
+export class RegenerateUserInviteCommand extends Command<InviteUserResponseDto> {
+  constructor(
+    public readonly userId: string,
+    public readonly requestOrigin: string,
+  ) {
+    super();
+  }
+}

package/src/application/commands/RegenerateUserInviteCommandHandler.ts

@@ -0,0 +1,24 @@
+import { inject } from "@codemation/core";
+
+import type { InviteUserResponseDto } from "../contracts/userDirectoryContracts.types";
+
+import { CommandHandler } from "../bus/CommandHandler";
+
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+
+import { UserAccountService } from "../../domain/users/UserAccountServiceRegistry";
+import { RegenerateUserInviteCommand } from "./RegenerateUserInviteCommand";
+
+@HandlesCommand.forCommand(RegenerateUserInviteCommand)
+export class RegenerateUserInviteCommandHandler extends CommandHandler<
+  RegenerateUserInviteCommand,
+  InviteUserResponseDto
+> {
+  constructor(@inject(UserAccountService) private readonly userAccounts: UserAccountService) {
+    super();
+  }
+
+  async execute(command: RegenerateUserInviteCommand): Promise<InviteUserResponseDto> {
+    return await this.userAccounts.regenerateInvite(command.userId, command.requestOrigin);
+  }
+}

package/src/application/commands/ReplaceMutableRunWorkflowSnapshotCommand.ts

@@ -0,0 +1,12 @@
+import type { PersistedRunState } from "@codemation/core";
+import { Command } from "../bus/Command";
+import type { UpdateRunWorkflowSnapshotRequest } from "../contracts/RunContracts";
+
+export class ReplaceMutableRunWorkflowSnapshotCommand extends Command<PersistedRunState> {
+  constructor(
+    public readonly runId: string,
+    public readonly body: UpdateRunWorkflowSnapshotRequest,
+  ) {
+    super();
+  }
+}

package/src/application/commands/ReplaceMutableRunWorkflowSnapshotCommandHandler.ts

@@ -0,0 +1,47 @@
+import { inject, type PersistedRunState } from "@codemation/core";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+import { ApplicationRequestError } from "../ApplicationRequestError";
+import { CommandHandler } from "../bus/CommandHandler";
+import { ReplaceMutableRunWorkflowSnapshotCommand } from "./ReplaceMutableRunWorkflowSnapshotCommand";
+
+@HandlesCommand.forCommand(ReplaceMutableRunWorkflowSnapshotCommand)
+export class ReplaceMutableRunWorkflowSnapshotCommandHandler extends CommandHandler<
+  ReplaceMutableRunWorkflowSnapshotCommand,
+  PersistedRunState
+> {
+  constructor(
+    @inject(ApplicationTokens.WorkflowRunRepository)
+    private readonly workflowRunRepository: WorkflowRunRepository,
+  ) {
+    super();
+  }
+
+  async execute(command: ReplaceMutableRunWorkflowSnapshotCommand): Promise<PersistedRunState> {
+    if (!command.body.workflowSnapshot) {
+      throw new ApplicationRequestError(400, "Missing workflowSnapshot");
+    }
+    const state = await this.workflowRunRepository.load(command.runId);
+    if (!state) {
+      throw new ApplicationRequestError(404, "Unknown runId");
+    }
+    if (!state.executionOptions?.isMutable) {
+      throw new ApplicationRequestError(403, `Run ${state.runId} is immutable`);
+    }
+    await this.workflowRunRepository.save({
+      ...state,
+      status: "completed",
+      pending: undefined,
+      queue: [],
+      outputsByNode: {},
+      nodeSnapshotsByNodeId: {},
+      workflowSnapshot: command.body.workflowSnapshot,
+    });
+    const updated = await this.workflowRunRepository.load(state.runId);
+    if (!updated) {
+      throw new ApplicationRequestError(404, "Unknown runId");
+    }
+    return updated;
+  }
+}

package/src/application/commands/ReplaceWorkflowDebuggerOverlayCommand.ts

@@ -0,0 +1,14 @@
+import { Command } from "../bus/Command";
+import type {
+  UpdateWorkflowDebuggerOverlayRequest,
+  WorkflowDebuggerOverlayResponse,
+} from "../contracts/WorkflowDebuggerContracts";
+
+export class ReplaceWorkflowDebuggerOverlayCommand extends Command<WorkflowDebuggerOverlayResponse> {
+  constructor(
+    public readonly workflowId: string,
+    public readonly body: UpdateWorkflowDebuggerOverlayRequest,
+  ) {
+    super();
+  }
+}

package/src/application/commands/ReplaceWorkflowDebuggerOverlayCommandHandler.ts

@@ -0,0 +1,35 @@
+import { inject } from "@codemation/core";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { WorkflowDebuggerOverlayRepository } from "../../domain/workflows/WorkflowDebuggerOverlayRepository";
+import type { WorkflowDebuggerOverlayState } from "../../domain/workflows/WorkflowDebuggerOverlayState";
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+import { ApplicationRequestError } from "../ApplicationRequestError";
+import { CommandHandler } from "../bus/CommandHandler";
+import type { WorkflowDebuggerOverlayResponse } from "../contracts/WorkflowDebuggerContracts";
+import { WorkflowDebuggerOverlayStateFactory } from "../workflows/WorkflowDebuggerOverlayStateFactory";
+import { ReplaceWorkflowDebuggerOverlayCommand } from "./ReplaceWorkflowDebuggerOverlayCommand";
+
+@HandlesCommand.forCommand(ReplaceWorkflowDebuggerOverlayCommand)
+export class ReplaceWorkflowDebuggerOverlayCommandHandler extends CommandHandler<
+  ReplaceWorkflowDebuggerOverlayCommand,
+  WorkflowDebuggerOverlayResponse
+> {
+  constructor(
+    @inject(ApplicationTokens.WorkflowDebuggerOverlayRepository)
+    private readonly workflowDebuggerOverlayRepository: WorkflowDebuggerOverlayRepository,
+  ) {
+    super();
+  }
+
+  async execute(command: ReplaceWorkflowDebuggerOverlayCommand): Promise<WorkflowDebuggerOverlayState> {
+    if (!command.body.currentState) {
+      throw new ApplicationRequestError(400, "Missing currentState");
+    }
+    const nextState = WorkflowDebuggerOverlayStateFactory.replaceCurrentState({
+      workflowId: decodeURIComponent(command.workflowId),
+      currentState: command.body.currentState,
+    });
+    await this.workflowDebuggerOverlayRepository.save(nextState);
+    return nextState;
+  }
+}

package/src/application/commands/ReplayWorkflowNodeCommand.ts

@@ -0,0 +1,12 @@
+import { Command } from "../bus/Command";
+import type { RunCommandResult, RunNodeRequest } from "../contracts/RunContracts";
+
+export class ReplayWorkflowNodeCommand extends Command<RunCommandResult> {
+  constructor(
+    public readonly runId: string,
+    public readonly nodeId: string,
+    public readonly body: RunNodeRequest,
+  ) {
+    super();
+  }
+}

package/src/application/commands/ReplayWorkflowNodeCommandHandler.ts

@@ -0,0 +1,164 @@
+import type {
+  Items,
+  PersistedMutableRunState,
+  PersistedRunState,
+  RunCurrentState,
+  WorkflowDefinition,
+} from "@codemation/core";
+import { ItemsInputNormalizer, inject } from "@codemation/core";
+import { RunIntentService } from "@codemation/core/bootstrap";
+import { Engine } from "@codemation/core/bootstrap";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+import { ApplicationRequestError } from "../ApplicationRequestError";
+import { CommandHandler } from "../bus/CommandHandler";
+import type { RunCommandResult } from "../contracts/RunContracts";
+import { ReplayWorkflowNodeCommand } from "./ReplayWorkflowNodeCommand";
+
+@HandlesCommand.forCommand(ReplayWorkflowNodeCommand)
+export class ReplayWorkflowNodeCommandHandler extends CommandHandler<ReplayWorkflowNodeCommand, RunCommandResult> {
+  constructor(
+    @inject(Engine)
+    private readonly engine: Engine,
+    @inject(ItemsInputNormalizer)
+    private readonly itemsInputNormalizer: ItemsInputNormalizer,
+    @inject(RunIntentService)
+    private readonly runIntentService: RunIntentService,
+    @inject(ApplicationTokens.WorkflowRunRepository)
+    private readonly workflowRunRepository: WorkflowRunRepository,
+  ) {
+    super();
+  }
+
+  async execute(command: ReplayWorkflowNodeCommand): Promise<RunCommandResult> {
+    const state = await this.workflowRunRepository.load(command.runId);
+    if (!state) {
+      throw new ApplicationRequestError(404, "Unknown runId");
+    }
+    this.ensureMutable(state);
+    const workflow = this.resolveWorkflow(state);
+    if (!workflow) {
+      throw new ApplicationRequestError(404, "Unknown workflow for run");
+    }
+    const decodedNodeId = decodeURIComponent(command.nodeId);
+    const mode = command.body.mode ?? state.executionOptions?.mode ?? "manual";
+    const requestedItems = await this.resolveRequestedItems({
+      workflow,
+      nodeId: decodedNodeId,
+      items: command.body.items,
+      synthesizeTriggerItems: command.body.synthesizeTriggerItems,
+    });
+    const mutableStateBase = this.cloneMutableState(state.mutableState) ?? { nodesById: {} };
+    const mutableState = requestedItems
+      ? ({
+          nodesById: {
+            ...mutableStateBase.nodesById,
+            [decodedNodeId]: {
+              ...(mutableStateBase.nodesById[decodedNodeId] ?? {}),
+              lastDebugInput: requestedItems,
+            },
+          },
+        } satisfies PersistedMutableRunState)
+      : mutableStateBase;
+    const executionOptions = {
+      mode,
+      sourceWorkflowId: state.executionOptions?.sourceWorkflowId ?? state.workflowId,
+      sourceRunId: state.executionOptions?.sourceRunId ?? state.runId,
+      derivedFromRunId: state.runId,
+      isMutable: true,
+    } as const;
+    const result = await this.runIntentService.rerunFromNode({
+      workflow,
+      nodeId: decodedNodeId,
+      currentState: this.cloneRunCurrentState(state, mutableState),
+      items: requestedItems,
+      executionOptions,
+      workflowSnapshot: this.cloneWorkflowSnapshot(state.workflowSnapshot),
+      mutableState,
+    });
+    const nextState = await this.workflowRunRepository.load(result.runId);
+    return {
+      runId: result.runId,
+      workflowId: result.workflowId,
+      startedAt: result.startedAt,
+      status: result.status,
+      state: nextState ?? null,
+    };
+  }
+
+  private ensureMutable(state: PersistedRunState): void {
+    if (!state.executionOptions?.isMutable) {
+      throw new ApplicationRequestError(403, `Run ${state.runId} is immutable`);
+    }
+  }
+
+  private resolveWorkflow(state: PersistedRunState): WorkflowDefinition | undefined {
+    return this.engine.resolveWorkflowSnapshot({
+      workflowId: state.workflowId,
+      workflowSnapshot: state.workflowSnapshot,
+    });
+  }
+
+  private cloneMutableState(mutableState: PersistedRunState["mutableState"]): PersistedMutableRunState | undefined {
+    if (!mutableState) {
+      return undefined;
+    }
+    return JSON.parse(JSON.stringify(mutableState)) as PersistedMutableRunState;
+  }
+
+  private cloneWorkflowSnapshot(
+    workflowSnapshot: PersistedRunState["workflowSnapshot"],
+  ): PersistedRunState["workflowSnapshot"] {
+    if (!workflowSnapshot) {
+      return undefined;
+    }
+    return JSON.parse(JSON.stringify(workflowSnapshot)) as NonNullable<PersistedRunState["workflowSnapshot"]>;
+  }
+
+  private cloneRunCurrentState(
+    state: PersistedRunState,
+    mutableState: PersistedMutableRunState | undefined,
+  ): RunCurrentState {
+    return {
+      outputsByNode: JSON.parse(JSON.stringify(state.outputsByNode)) as RunCurrentState["outputsByNode"],
+      nodeSnapshotsByNodeId: JSON.parse(
+        JSON.stringify(state.nodeSnapshotsByNodeId),
+      ) as RunCurrentState["nodeSnapshotsByNodeId"],
+      mutableState,
+    };
+  }
+
+  private async resolveRequestedItems(
+    args: Readonly<{
+      workflow: WorkflowDefinition;
+      nodeId: string;
+      items: Items | undefined | null;
+      synthesizeTriggerItems: boolean | undefined;
+    }>,
+  ): Promise<Items | undefined> {
+    const normalizedItems = args.items == null ? undefined : this.itemsInputNormalizer.normalize(args.items);
+    if (!this.shouldSynthesizeTriggerItems(args.workflow, args.nodeId, args.synthesizeTriggerItems, normalizedItems)) {
+      return normalizedItems;
+    }
+    return await this.engine.createTriggerTestItems({
+      workflow: args.workflow,
+      nodeId: args.nodeId,
+    });
+  }
+
+  private shouldSynthesizeTriggerItems(
+    workflow: WorkflowDefinition,
+    nodeId: string,
+    synthesizeTriggerItems: boolean | undefined,
+    normalizedItems: Items | undefined,
+  ): boolean {
+    if (synthesizeTriggerItems) {
+      return true;
+    }
+    if (normalizedItems && normalizedItems.length > 0) {
+      return false;
+    }
+    return workflow.nodes.find((node) => node.id === nodeId)?.kind === "trigger";
+  }
+}

package/src/application/commands/SetPinnedNodeInputCommand.ts

@@ -0,0 +1,13 @@
+import type { PersistedRunState } from "@codemation/core";
+import { Command } from "../bus/Command";
+import type { UpdateRunNodePinRequest } from "../contracts/RunContracts";
+
+export class SetPinnedNodeInputCommand extends Command<PersistedRunState> {
+  constructor(
+    public readonly runId: string,
+    public readonly nodeId: string,
+    public readonly body: UpdateRunNodePinRequest,
+  ) {
+    super();
+  }
+}