Function shipsecWorkflowRun

worker/src/temporal/workflows/index.ts:156–1069

(
  input: RunWorkflowActivityInput,
)

}

export async function shipsecWorkflowRun(
  input: RunWorkflowActivityInput,
): Promise<RunWorkflowActivityOutput> {
  const results = new Map<string, unknown>();
  const actionsByRef = new Map<string, WorkflowAction>(
    input.definition.actions.map((action) => [action.ref, action]),
  );

  // Track pending human inputs and their resolutions
  const pendingHumanInputs = new Map<
    string,
    { nodeRef: string; resolve: (res: HumanInputResolution) => void }
  >();
  const humanInputResolutions = new Map<string, HumanInputResolution>();

  // Set up signal handler for human input resolutions
  setHandler(resolveHumanInputSignal, (resolution: HumanInputResolution) => {
    console.log(
      `[Workflow] Received human input signal for ${resolution.nodeRef}: approved=${resolution.approved}`,
    );
    humanInputResolutions.set(resolution.nodeRef, resolution);
    const pending = pendingHumanInputs.get(resolution.nodeRef);
    if (pending) {
      pending.resolve(resolution);
    }
  });

  // Track pending tool calls and their results (for MCP gateway)
  const pendingToolCalls = new Map<
    string,
    { request: ToolCallRequest; resolve: (result: ToolCallResult) => void }
  >();
  const toolCallResults = new Map<string, ToolCallResult>();

  // Set up signal handler for tool call execution requests
  setHandler(executeToolCallSignal, async (request: ToolCallRequest) => {
    // Prevent duplicate execution of the same callId
    if (toolCallResults.has(request.callId)) {
      console.warn(`[Workflow] Duplicate tool call ignored: ${request.callId}`);
      return;
    }

    console.log(
      `[Workflow] Received tool call signal: callId=${request.callId}, componentId=${request.componentId}`,
    );

    // Execute the component via runComponentActivity with timeout protection
    const TOOL_CALL_TIMEOUT_MS = 300000; // 5 minutes
    try {
      const activityOutput = await Promise.race([
        _runComponentActivity({
          runId: input.runId,
          workflowId: input.workflowId,
          workflowVersionId: input.workflowVersionId,
          organizationId: input.organizationId,
          action: {
            ref: `tool-call:${request.callId}`,
            componentId: request.componentId,