Fix RPA import portability and local script execution

Author: lius-new

plugins/pages/rpa-workflow/src/components/task-editor/workflow-mapper.ts

@@ -18,16 +18,30 @@ interface EditorState {
   workflow: RpaWorkflowSchema;
 }
 
-interface StoredWorkflowStep {
-  id?: string;
-  type?: string;
-  name?: string;
-  enabled?: boolean;
-  next?: string | null;
-  branches?: Record<string, string>;
-  config?: Record<string, unknown>;
-  ui?: {
-    source_type?: string;
+interface StoredWorkflowStep {
+  id?: string;
+  type?: string;
+  name?: string;
+  enabled?: boolean;
+  next?: string | null;
+  branches?: Record<string, string>;
+  click_type?: string;
+  wait_for_element?: boolean;
+  clear_first?: boolean;
+  type_slowly?: boolean;
+  duration_ms?: number;
+  timeout_ms?: number;
+  output?: string;
+  script?: string;
+  url?: string;
+  value?: string;
+  target?: {
+    by?: string;
+    value?: string;
+  };
+  config?: Record<string, unknown>;
+  ui?: {
+    source_type?: string;
     position?: {
       x?: number;
       y?: number;
@@ -330,18 +344,69 @@ function mapStoredGlobalVariables(
     .filter((variable) => variable.name.trim());
 }
 
-function buildFlowStepFromStoredStep(step: StoredWorkflowStep): FlowStep {
-  const uiType = typeof step.ui?.source_type === 'string' ? step.ui.source_type : step.type;
-  const position = step.ui?.position;
-  const parentLoopId = typeof step.ui?.parent_id === 'string' ? step.ui.parent_id : null;
-  const config =
-    step.config && typeof step.config === 'object'
-      ? { ...(step.config as Record<string, unknown>) }
-      : {};
-
-  if (step.branches && typeof step.branches === 'object') {
-    config.branches = step.branches;
-  }
+function buildFlowStepFromStoredStep(step: StoredWorkflowStep): FlowStep {
+  const uiType = typeof step.ui?.source_type === 'string' ? step.ui.source_type : step.type;
+  const position = step.ui?.position;
+  const parentLoopId = typeof step.ui?.parent_id === 'string' ? step.ui.parent_id : null;
+  const config =
+    step.config && typeof step.config === 'object'
+      ? { ...(step.config as Record<string, unknown>) }
+      : {};
+  const selector = typeof step.target?.value === 'string' ? step.target.value : '';
+
+  if (!config.selector && selector) {
+    config.selector = selector;
+  }
+
+  if (!config.url && typeof step.url === 'string') {
+    config.url = step.url;
+  }
+
+  if (step.type === 'click') {
+    if (!config.clickType && typeof step.click_type === 'string') {
+      config.clickType = step.click_type;
+    }
+    if (!Object.prototype.hasOwnProperty.call(config, 'waitForElement')) {
+      config.waitForElement = step.wait_for_element !== false;
+    }
+  }
+
+  if (step.type === 'fill') {
+    if (!config.text && typeof step.value === 'string') {
+      config.text = step.value;
+    }
+    if (!Object.prototype.hasOwnProperty.call(config, 'clearFirst')) {
+      config.clearFirst = step.clear_first !== false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(config, 'typeSlowly')) {
+      config.typeSlowly = step.type_slowly === true;
+    }
+  }
+
+  if (step.type === 'delay') {
+    if (!config.duration && typeof step.duration_ms === 'number') {
+      config.duration = step.duration_ms;
+    }
+    if (!config.waitType) {
+      config.waitType = 'time';
+    }
+  }
+
+  if (step.type === 'wait_for' && !config.timeout && typeof step.timeout_ms === 'number') {
+    config.timeout = step.timeout_ms;
+  }
+
+  if (!config.outputKey && typeof step.output === 'string') {
+    config.outputKey = step.output;
+  }
+
+  if (!config.script && typeof step.script === 'string') {
+    config.script = step.script;
+  }
+
+  if (step.branches && typeof step.branches === 'object') {
+    config.branches = step.branches;
+  }
 
   return {
     id: String(step.id),
@@ -548,31 +613,43 @@ export function mapPortableTaskToEditorState(document: PortableRpaTaskDocument):
   })?.config?.workflow_meta as StoredWorkflowMeta | undefined;
   const importedIdMap = new Map<string, string>();
   sortedSteps.forEach((step) => {
-    importedIdMap.set(step.uuid, crypto.randomUUID());
+    const nextId = crypto.randomUUID();
+    importedIdMap.set(step.uuid, nextId);
+
+    const storedStep = step.config?.workflow_step;
+    if (storedStep && typeof storedStep === 'object' && typeof storedStep.id === 'string') {
+      importedIdMap.set(storedStep.id, nextId);
+    }
   });
   const storedStartStepId =
     typeof storedWorkflowMeta?.start_step_id === 'string'
       ? importedIdMap.get(storedWorkflowMeta.start_step_id) ?? null
       : null;
 
   const steps = sortedSteps.map((step, index) => {
-    const legacyStep = buildLegacyFlowStep(
-      {
-        uuid: step.uuid,
-        step_type: step.step_type,
-        name: step.name,
-        config: step.config,
-        enabled: step.enabled ?? true,
-        position_x: step.position_x,
-        position_y: step.position_y,
-        sort_order: step.sort_order,
-        next_step_uuid: step.next_step_uuid,
-        branch_config: step.branch_config,
-      },
-      step.next_step_uuid ?? sortedSteps[index + 1]?.uuid ?? null
-    );
-
-    const currentBranches = (legacyStep.config.branches as Record<string, unknown> | undefined) ?? {};
+    const storedStep =
+      step.config?.workflow_step && typeof step.config.workflow_step === 'object'
+        ? (step.config.workflow_step as StoredWorkflowStep)
+        : null;
+    const baseStep = storedStep
+      ? buildFlowStepFromStoredStep(storedStep)
+      : buildLegacyFlowStep(
+          {
+            uuid: step.uuid,
+            step_type: step.step_type,
+            name: step.name,
+            config: step.config,
+            enabled: step.enabled ?? true,
+            position_x: step.position_x,
+            position_y: step.position_y,
+            sort_order: step.sort_order,
+            next_step_uuid: step.next_step_uuid,
+            branch_config: step.branch_config,
+          },
+          step.next_step_uuid ?? sortedSteps[index + 1]?.uuid ?? null
+        );
+    const sourceId = storedStep?.id ?? step.uuid;
+    const currentBranches = (baseStep.config.branches as Record<string, unknown> | undefined) ?? {};
     const mappedBranches = Object.fromEntries(
       Object.entries(currentBranches).map(([key, value]) => [
         key,
@@ -581,17 +658,18 @@ export function mapPortableTaskToEditorState(document: PortableRpaTaskDocument):
     );
 
     return {
-      ...legacyStep,
-      id: importedIdMap.get(step.uuid) ?? legacyStep.id,
-      nextStepId: step.next_step_uuid ? importedIdMap.get(step.next_step_uuid) ?? null : null,
-      isStart: storedStartStepId ? importedIdMap.get(step.uuid) === storedStartStepId : index === 0,
+      ...baseStep,
+      id: importedIdMap.get(sourceId) ?? baseStep.id,
+      nextStepId: baseStep.nextStepId ? importedIdMap.get(baseStep.nextStepId) ?? null : null,
+      parentLoopId: baseStep.parentLoopId ? importedIdMap.get(baseStep.parentLoopId) ?? null : null,
+      isStart: storedStartStepId ? importedIdMap.get(sourceId) === storedStartStepId : index === 0,
       config:
         Object.keys(mappedBranches).length > 0
           ? {
-              ...legacyStep.config,
+              ...baseStep.config,
               branches: mappedBranches,
             }
-          : legacyStep.config,
+          : baseStep.config,
     };
   });
 

plugins/pages/rpa-workflow/src/lib/rpa-transfer.ts

@@ -71,7 +71,7 @@ export function buildPortableRpaTask(detail: RpaTaskDetailDto): PortableRpaTaskD
       stop_on_error: detail.task.stop_on_error,
       notify_on_complete: detail.task.notify_on_complete,
       notify_on_error: detail.task.notify_on_error,
-      environment_uuids: detail.environment_uuids,
+      environment_uuids: [],
       steps: detail.steps.map((step) => ({
         uuid: step.uuid,
         step_type: step.step_type,

src-tauri/src/commands/rpa.rs

@@ -34,11 +34,11 @@ pub async fn execute_local_rpa_script(
         .await
         .map_err(|_| "LOCAL_SCRIPT_PREPARE_FAILED".to_string())?;
 
-    let execution = timeout(
-        Duration::from_secs(60),
-        Command::new("node").arg(&script_path).output(),
-    )
-    .await;
+    let mut command = Command::new("node");
+    command.arg(&script_path);
+    apply_hidden_window_flags(&mut command);
+
+    let execution = timeout(Duration::from_secs(60), command.output()).await;
 
     let cleanup_result = fs::remove_file(&script_path).await;
     if cleanup_result.is_err() {
@@ -90,7 +90,11 @@ pub async fn execute_local_rpa_script(
 }
 
 async fn ensure_node_runtime() -> std::result::Result<(), String> {
-    match Command::new("node").arg("--version").output().await {
+    let mut command = Command::new("node");
+    command.arg("--version");
+    apply_hidden_window_flags(&mut command);
+
+    match command.output().await {
         Ok(output) if output.status.success() => Ok(()),
         Ok(_) => Err("NODE_RUNTIME_NOT_FOUND".to_string()),
         Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
@@ -104,6 +108,16 @@ fn build_temp_script_path() -> PathBuf {
     env::temp_dir().join(format!("simprint-rpa-script-{}.cjs", Uuid::new_v4()))
 }
 
+fn apply_hidden_window_flags(command: &mut Command) {
+    #[cfg(target_os = "windows")]
+    {
+        use std::os::windows::process::CommandExt;
+
+        const CREATE_NO_WINDOW: u32 = 0x08000000;
+        command.creation_flags(CREATE_NO_WINDOW);
+    }
+}
+
 fn build_runner_script(script: &str, variables: &Value) -> std::result::Result<String, String> {
     let script_body =
         serde_json::to_string(script).map_err(|_| "LOCAL_SCRIPT_PREPARE_FAILED".to_string())?;