feat: upload node input handle, segment-anything invert mask, fix API params defaults

- Add media input port to upload node so it can receive upstream free-tool output
- Upload node now uploads local-asset:// files to CDN before passing URL downstream
- ConnectedInputControl only shows preview when upstream has actual execution results
- Add invertMask bool param to segment-anything node
- Fix AI task buildApiParams to include schema defaults and enum[0] for untouched params
- Hide ML model download hint after first successful run
- i18n updates for all 18 locales

Author: Leeon-Tang

electron.vite.config.ts

@@ -55,6 +55,13 @@ export default defineConfig({
       }
     },
     optimizeDeps: {
+      include: [
+        'onnxruntime-web',
+        'upscaler',
+        '@huggingface/transformers',
+        '@ffmpeg/ffmpeg',
+        '@ffmpeg/util'
+      ],
       exclude: ['@google/model-viewer']
     },
     server: {

electron/workflow/db/workflow.repo.ts

@@ -8,19 +8,47 @@ import type { Workflow, GraphDefinition } from '../../../src/workflow/types/work
 
 function getFileStorage() { return getFileStorageInstance() }
 
+/**
+ * Ensure a workflow name is unique across all workflows.
+ * If a collision is found (excluding the workflow with `excludeId`),
+ * appends (2), (3), etc. until unique.
+ */
+function ensureUniqueName(db: ReturnType<typeof getDatabase>, name: string, excludeId: string | null): string {
+  const trimmed = name.trim() || 'Untitled Workflow'
+  const existingNames = new Set<string>()
+  const result = excludeId
+    ? db.exec('SELECT name FROM workflows WHERE id != ?', [excludeId])
+    : db.exec('SELECT name FROM workflows')
+  if (result.length > 0) {
+    for (const row of result[0].values) {
+      existingNames.add(row[0] as string)
+    }
+  }
+
+  if (!existingNames.has(trimmed)) return trimmed
+
+  let counter = 2
+  while (existingNames.has(`${trimmed} (${counter})`)) counter++
+  return `${trimmed} (${counter})`
+}
+
 export function createWorkflow(name: string): Workflow {
   const db = getDatabase()
   const id = uuid()
   const now = new Date().toISOString()
   const graphDef: GraphDefinition = { nodes: [], edges: [] }
+
+  // Ensure unique name — append (2), (3), etc. if needed
+  const finalName = ensureUniqueName(db, name, null)
+
   db.run(
     `INSERT INTO workflows (id, name, created_at, updated_at, graph_definition, status) VALUES (?, ?, ?, ?, ?, ?)`,
-    [id, name, now, now, JSON.stringify(graphDef), 'draft']
+    [id, finalName, now, now, JSON.stringify(graphDef), 'draft']
   )
   persistDatabase()
   // Also create the workflow directory and initial snapshot on disk
-  getFileStorage().saveWorkflowSnapshot(id, name, graphDef)
-  return { id, name, createdAt: now, updatedAt: now, graphDefinition: graphDef, status: 'draft' }
+  getFileStorage().saveWorkflowSnapshot(id, finalName, graphDef)
+  return { id, name: finalName, createdAt: now, updatedAt: now, graphDefinition: graphDef, status: 'draft' }
 }
 
 export function getWorkflowById(id: string): Workflow | null {
@@ -54,12 +82,20 @@ export function listWorkflows(): Array<{ id: string; name: string; createdAt: st
 export function updateWorkflow(id: string, name: string, graphDefinition: GraphDefinition, status?: Workflow['status']): void {
   const db = getDatabase()
   const now = new Date().toISOString()
+
+  // Get old name to detect rename
+  const existing = getWorkflowById(id)
+  const oldName = existing?.name ?? name
+
+  // Ensure unique name if it changed
+  const finalName = (name !== oldName) ? ensureUniqueName(db, name, id) : name
+
   if (status) {
     db.run('UPDATE workflows SET name = ?, graph_definition = ?, updated_at = ?, status = ? WHERE id = ?',
-      [name, JSON.stringify(graphDefinition), now, status, id])
+      [finalName, JSON.stringify(graphDefinition), now, status, id])
   } else {
     db.run('UPDATE workflows SET name = ?, graph_definition = ?, updated_at = ? WHERE id = ?',
-      [name, JSON.stringify(graphDefinition), now, id])
+      [finalName, JSON.stringify(graphDefinition), now, id])
   }
   // Preserve existing currentOutputId for nodes that already have execution results
   const existingOutputIds = new Map<string, string | null>()
@@ -100,19 +136,36 @@ export function updateWorkflow(id: string, name: string, graphDefinition: GraphD
     db.run('PRAGMA foreign_keys = ON')
   }
   persistDatabase()
-  getFileStorage().saveWorkflowSnapshot(id, name, graphDefinition)
+
+  // Rename directory on disk if name changed
+  if (finalName !== oldName) {
+    getFileStorage().renameWorkflowDir(id, oldName, finalName)
+  }
+  getFileStorage().saveWorkflowSnapshot(id, finalName, graphDefinition)
 }
 
 export function renameWorkflow(id: string, newName: string): void {
   const db = getDatabase()
   const now = new Date().toISOString()
-  db.run('UPDATE workflows SET name = ?, updated_at = ? WHERE id = ?', [newName, now, id])
-  persistDatabase()
-  // Update file storage name mapping and snapshot
+
+  // Get old name before rename (needed for directory rename)
   const existing = getWorkflowById(id)
-  if (existing) {
-    getFileStorage().saveWorkflowSnapshot(id, newName, existing.graphDefinition)
-  }
+  if (!existing) return
+
+  const oldName = existing.name
+
+  // Ensure unique name — append (2), (3), etc. if collides with another workflow
+  const finalName = ensureUniqueName(db, newName, id)
+
+  db.run('UPDATE workflows SET name = ?, updated_at = ? WHERE id = ?', [finalName, now, id])
+  persistDatabase()
+
+  // Rename the data directory on disk (handles collision cleanup)
+  const fs = getFileStorage()
+  fs.renameWorkflowDir(id, oldName, finalName)
+
+  // Update the snapshot file with the new name
+  fs.saveWorkflowSnapshot(id, finalName, existing.graphDefinition)
 }
 
 export function deleteWorkflow(id: string): void {

electron/workflow/ipc/free-tool.ipc.ts

@@ -81,6 +81,22 @@ export function registerFreeToolIpc(): void {
     pending.delete(requestId)
     entry.reject(new Error(error))
   })
+
+  // Detect renderer reload/navigation — fail all pending requests immediately
+  // so the user sees an error right away instead of waiting for timeout
+  const onWebContentsCreated = (_event: Electron.Event, webContents: Electron.WebContents) => {
+    webContents.on('did-start-navigation', () => {
+      if (pending.size > 0) {
+        console.warn(`[FreeTool] Renderer reloading — failing ${pending.size} pending request(s)`)
+        for (const [reqId, entry] of pending) {
+          pending.delete(reqId)
+          entry.reject(new Error('Renderer reloaded during execution. Please retry.'))
+        }
+      }
+    })
+  }
+  const { app } = require('electron')
+  app.on('web-contents-created', onWebContentsCreated)
 }
 
 /**
@@ -91,7 +107,9 @@ export function executeFreeToolInRenderer(req: Omit<FreeToolExecuteRequest, 'req
     const requestId = uuid()
     const startTime = Date.now()
 
-    const timeoutMs = req.nodeType === 'free-tool/video-enhancer' ? 600_000 : 120_000
+    const timeoutMs = (req.nodeType === 'free-tool/video-enhancer') ? 600_000
+      : (req.nodeType === 'free-tool/face-swapper' || req.nodeType === 'free-tool/image-eraser' || req.nodeType === 'free-tool/face-enhancer') ? 300_000
+      : 120_000
     const timeout = setTimeout(() => {
       const entry = pending.get(requestId)
       if (entry) {

electron/workflow/ipc/storage.ipc.ts

@@ -5,7 +5,7 @@ import { ipcMain, dialog, shell } from 'electron'
 import { getFileStorageInstance } from '../utils/file-storage'
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs'
 import { v4 as uuid } from 'uuid'
-import { createWorkflow, updateWorkflow, listWorkflows } from '../db/workflow.repo'
+import { createWorkflow, updateWorkflow } from '../db/workflow.repo'
 import { getModelById } from '../services/model-list'
 
 function getStorage() { return getFileStorageInstance() }
@@ -90,14 +90,8 @@ export function registerStorageIpc(): void {
       const name = data.name ?? 'Imported Workflow'
       if (!rawGraphDef || !Array.isArray(rawGraphDef.nodes)) throw new Error('Invalid workflow file')
 
-      // Check for name conflicts
+      // createWorkflow now auto-deduplicates names, so no need for manual conflict check
       const importName = name + ' (imported)'
-      const existing = listWorkflows()
-      if (existing.some(w => w.name === importName || w.name === name)) {
-        throw new Error(`A workflow named "${name}" already exists. Please rename the "name" field in the JSON file before importing.`)
-      }
-
-      // Generate new UUIDs for all nodes/edges to avoid conflicts on re-import
       const wf = createWorkflow(importName)
       const idMap = new Map<string, string>() // old ID → new UUID
       for (const n of rawGraphDef.nodes) {

electron/workflow/ipc/workflow.ipc.ts

@@ -26,8 +26,11 @@ export function registerWorkflowIpc(): void {
     return workflowRepo.listWorkflows()
   })
 
-  ipcMain.handle('workflow:rename', async (_event, args: { id: string; name: string }): Promise<void> => {
+  ipcMain.handle('workflow:rename', async (_event, args: { id: string; name: string }): Promise<{ finalName: string }> => {
     workflowRepo.renameWorkflow(args.id, args.name)
+    // Return the actual name (may have been deduplicated)
+    const wf = workflowRepo.getWorkflowById(args.id)
+    return { finalName: wf?.name ?? args.name }
   })
 
   ipcMain.handle('workflow:delete', async (_event, args: { id: string }): Promise<void> => {

electron/workflow/nodes/ai-task/run.ts

@@ -81,6 +81,22 @@ export class AITaskHandler extends BaseNodeHandler {
     const params: Record<string, unknown> = {}
     // Internal keys to skip
     const skipKeys = new Set(['modelId', '__meta', '__locks', '__nodeWidth', '__nodeHeight'])
+
+    // First, fill in schema defaults so params that the user never touched
+    // (but are visible in the UI with their default value) are still sent.
+    const meta = ctx.params.__meta as Record<string, unknown> | undefined
+    const schema = (meta?.modelInputSchema ?? []) as Array<{ name: string; default?: unknown; enum?: string[] }>
+    for (const s of schema) {
+      if (skipKeys.has(s.name) || s.name.startsWith('__')) continue
+      if (s.default !== undefined && s.default !== null && s.default !== '') {
+        params[s.name] = s.default
+      } else if (s.enum && s.enum.length > 0) {
+        // Select/enum fields show the first option by default in the UI
+        params[s.name] = s.enum[0]
+      }
+    }
+
+    // Then overlay with actual user-set params (these take priority)
     for (const [key, value] of Object.entries(ctx.params)) {
       if (skipKeys.has(key) || key.startsWith('__')) continue
       if (value !== undefined && value !== null && value !== '') params[key] = value

electron/workflow/nodes/free-tool/segment-anything/index.ts

@@ -9,7 +9,9 @@ export const segmentAnythingDef: NodeTypeDefinition = {
   icon: '🖱️',
   inputs: [{ key: 'input', label: 'Image', dataType: 'image', required: true }],
   outputs: [{ key: 'output', label: 'Mask', dataType: 'image', required: true }],
-  params: []
+  params: [
+    { key: 'invertMask', label: 'Invert Mask', type: 'boolean', default: false }
+  ]
 }
 
 export class SegmentAnythingHandler extends BaseNodeHandler {
@@ -42,7 +44,8 @@ export class SegmentAnythingHandler extends BaseNodeHandler {
           pointX: ctx.params.pointX ?? 0.5,
           pointY: ctx.params.pointY ?? 0.5,
           __segmentPoints: ctx.params.__segmentPoints,
-          __previewMask: ctx.params.__previewMask
+          __previewMask: ctx.params.__previewMask,
+          invertMask: ctx.params.invertMask ?? false
         }
       })
       ctx.onProgress(100, 'Segmentation completed.')

electron/workflow/nodes/input/media-upload.ts

@@ -6,17 +6,25 @@
  * The actual upload happens in the renderer (CustomNode) and the
  * resulting URL is stored in params.uploadedUrl.
  *
- * When executed, this node simply passes through the uploadedUrl.
+ * When executed:
+ * - If a CDN URL is already available (manual upload), pass it through.
+ * - If input is a local-asset:// path (from upstream free-tool), read the
+ *   file from disk and upload it to CDN first.
  */
 import { BaseNodeHandler, type NodeExecutionContext, type NodeExecutionResult } from '../base'
 import type { NodeTypeDefinition } from '../../../../src/workflow/types/node-defs'
+import { getWaveSpeedClient } from '../../services/service-locator'
+import { existsSync, readFileSync } from 'fs'
+import { basename } from 'path'
 
 export const mediaUploadDef: NodeTypeDefinition = {
   type: 'input/media-upload',
   category: 'input',
   label: 'Upload',
   icon: '📁',
-  inputs: [],
+  inputs: [
+    { key: 'media', label: 'Media', dataType: 'url', required: false }
+  ],
   outputs: [
     { key: 'output', label: 'URL', dataType: 'url', required: true }
   ],
@@ -33,10 +41,33 @@ export class MediaUploadHandler extends BaseNodeHandler {
 
   async execute(ctx: NodeExecutionContext): Promise<NodeExecutionResult> {
     const start = Date.now()
-    const url = String(ctx.params.uploadedUrl ?? '')
+    // Prefer connected input over manually uploaded URL
+    let url = String(ctx.inputs.media ?? ctx.params.uploadedUrl ?? '')
 
     if (!url) {
-      return { status: 'error', outputs: {}, durationMs: Date.now() - start, cost: 0, error: 'No file uploaded. Please upload a file first.' }
+      return { status: 'error', outputs: {}, durationMs: Date.now() - start, cost: 0, error: 'No file uploaded or connected. Please upload a file or connect a media source.' }
+    }
+
+    // If the URL is a local-asset:// path (from upstream free-tool nodes),
+    // read the file from disk and upload it to CDN so downstream API nodes
+    // receive a proper HTTP URL.
+    if (/^local-asset:\/\//i.test(url)) {
+      try {
+        ctx.onProgress(10, 'Uploading local file to CDN...')
+        const localPath = decodeURIComponent(url.replace(/^local-asset:\/\//i, ''))
+        if (!existsSync(localPath)) {
+          return { status: 'error', outputs: {}, durationMs: Date.now() - start, cost: 0, error: `Local file not found: ${localPath}` }
+        }
+        const buffer = readFileSync(localPath)
+        const filename = basename(localPath)
+        const blob = new Blob([buffer])
+        const file = new File([blob], filename)
+        const client = getWaveSpeedClient()
+        url = await client.uploadFile(file, filename)
+        ctx.onProgress(90, 'Upload complete')
+      } catch (error) {
+        return { status: 'error', outputs: {}, durationMs: Date.now() - start, cost: 0, error: `Failed to upload local file: ${error instanceof Error ? error.message : String(error)}` }
+      }
     }
 
     return {

electron/workflow/utils/file-storage.ts

@@ -90,6 +90,43 @@ export class FileStorageService {
     return this.nameMap.get(workflowId) ?? workflowId
   }
 
+  /**
+   * Rename a workflow's data directory on disk.
+   * If the old directory exists, rename it to the new sanitized name.
+   * If the target directory already exists (name collision from another workflow),
+   * remove the target first so the rename can proceed.
+   * Returns true if rename succeeded, false if no old dir existed.
+   */
+  renameWorkflowDir(workflowId: string, oldName: string, newName: string): boolean {
+    const oldSanitized = sanitizeName(oldName)
+    const newSanitized = sanitizeName(newName)
+
+    // No-op if sanitized names are the same
+    if (oldSanitized === newSanitized) {
+      this.registerWorkflowName(workflowId, newName)
+      return true
+    }
+
+    const oldDir = path.join(this.rootPath, oldSanitized)
+    const newDir = path.join(this.rootPath, newSanitized)
+
+    if (!fs.existsSync(oldDir)) {
+      // Old dir doesn't exist — just update the name mapping
+      this.registerWorkflowName(workflowId, newName)
+      return false
+    }
+
+    // If target directory already exists (orphaned from a deleted/renamed workflow),
+    // remove it so we can rename cleanly
+    if (fs.existsSync(newDir)) {
+      fs.rmSync(newDir, { recursive: true, force: true })
+    }
+
+    fs.renameSync(oldDir, newDir)
+    this.registerWorkflowName(workflowId, newName)
+    return true
+  }
+
   /* ─── Path helpers ──────────────────────────────────────────── */
 
   getWorkflowDir(workflowId: string): string {

src/components/layout/Sidebar.tsx

@@ -195,7 +195,7 @@ export function Sidebar({ collapsed, onToggle, lastFreeToolsPage, isMobileOpen,
               {group.items.map((item) => {
                 const active = isActive(item)
                 const showTooltip = collapsed && !isMobileOpen && tooltipReady
-                const isNewFeature = item.href === '/workflow'
+                const isNewFeature = false
                 return (
                   <Tooltip key={item.href} delayDuration={0} open={showTooltip ? undefined : false}>
                     <TooltipTrigger asChild>