Changelog

All notable changes to this project will be documented in this file.

The format is inspired by Keep a Changelog and Semantic Versioning will be adopted after initial stabilization.

[1.0.5] – April 8, 2026

Fixed

OpenAI Models Now Work with Autonomous Agent — Newer OpenAI models (GPT-5.4, GPT-4.1, o4-mini) were failing with 400 Unsupported parameter: 'max_tokens'. Fixed: these models now correctly use max_completion_tokens. Legacy models (GPT-4o, GPT-3.5) are unaffected.
Continue Workflow Button Now Works — The foreground “Continue Workflow” error panel was never appearing due to missing state updates in the halt path. Fixed: when a node fails with no error edges, the red error panel now correctly shows with a “▶ Continue” button. Also fixed: clicking Continue previously skipped the first node after the failure — it now properly executes all downstream nodes.

Changed

Stop on Error Moved to Per-Schedule — The global “Stop workflow when nodes fail” checkbox has been removed from Settings → Email Notifications. Stop-on-error is now a per-schedule setting: each schedule has its own “Stop on error” checkbox (enabled by default). Foreground runs and manual background runs always stop on error. Schedule cards show a ⛔ badge when the setting is enabled. When a scheduled workflow is halted by this setting, the email notification now correctly reports FAILED instead of SUCCESS.

Added

Scheduler: Pause/Resume/Run Now Controls — Schedule cards in Settings now include ▶ (run now), ⏸ (pause/resume), and ✎ (edit) buttons for per-schedule control without deleting and recreating.
Scheduler: Edit Existing Schedules — Click the ✎ button to modify an existing schedule’s cron expression, enabled state, or other options.
Scheduler: Ownership Metadata — Schedules now track createdBy user and machineId for multi-device support and audit clarity.
Scheduler: External Edit Support — A file watcher monitors schedules.json for external edits; changes are merged rather than overwritten.
Scheduler: Refresh Button — Manually reload schedules from disk to sync the UI with externally-made changes.
Scheduler: Per-Schedule Notification Control — New “Notify on completion” checkbox when creating or editing a schedule. Uncheck to disable desktop notifications for frequently-running workflows. Silent schedules show a 🔕 badge.

Changed

Scheduler UI Compacted — Schedule action buttons are now icon-only (✎ ▶ ⏸ ✕) in a horizontal row, reducing vertical space.
Workflow Selector Modal — Starts with folders collapsed by default; modal is larger (800px × 70vh) for easier browsing.

Fixed

Browse Configs Slow Loading — Converted /config-files endpoint from synchronous to async file operations with Promise.all() parallel processing, improving load time significantly for large workflow collections.
Workflow Selector Overflow Bug — Refresh button was being cut off at the edge; fixed with proper box-sizing, overflow-x: hidden, and flex-shrink on controls.

[1.0.4] – April 6, 2026

Added

AI Autonomous Agent: Tool Discovery — Enable “Allow Tool Discovery” in the edit panel to let agents find and use tools from your Tool Library at runtime without pre-configuring them. Includes search_tools built-in and lazy resolution for unknown tool names.
AI Autonomous Agent: Loop Iteration Memory — AA nodes now have context across loop iterations (loop:N edges). The agent sees what happened in the previous iteration, preventing duplicate work.
AI Autonomous Agent: Logging Parity with CSA — Added /ai-autonomous-agent/stop endpoint, cost event emission per iteration, and abort controller tracking for clean cancellation.

Changed

AI Model Defaults Updated (April 2026) — All AI nodes now default to current models:
Anthropic: claude-haiku-4-5 (was deprecated claude-3-5-haiku-latest). Dropdown includes Claude 4.6 family.
OpenAI: gpt-5.4-mini (was legacy gpt-4o-mini). Dropdown includes GPT-5.4 family.
Gemini: gemini-2.5-flash (was deprecated gemini-2.0-flash). Dropdown includes Gemini 2.5 and 3.x preview models.
Built-in Tools corrected — Documentation updated to match actual implementation: read_file, write_file, list_directory, file_exists, run_command.

Fixed

Working Directory Safety for AA — AA nodes now use safe fallback directory (~/Documents/NORA/aa-workdir) when no valid working directory is configured, preventing accidental writes to program folders.
Anthropic API 404 errors — Fixed deprecated model IDs causing “model not found” errors from Anthropic API.
AA JSON parsing errors — Increased token limit (2048→4096), added truncation detection with helpful error message (“try asking for shorter output”), and system prompt now guides agents to keep file content compact.
AA Button visibility — Copy/Rerun/Clear buttons now match CSA behavior. Clear button appears after errors even without chat messages.

[1.0.3] – March 25–26, 2026

Added

run_command built-in tool — New built-in tool for all agent types (AI Agent, AI Autonomous Agent, Custom Script Agent). Agents can execute shell commands (install packages, run scripts, git operations, etc.) in their working directory. Configurable timeout (default 30s, max 120s), auto-kill on timeout, 1 MB output buffer. See Built-in Tools.
Self-Tooling Pattern — Custom Script Agents can now create and run their own helper scripts on the fly using write_file + run_command. Enables web scraping, data transformation, and any capability not covered by built-in tools without pre-configuration. See Self-Tooling Pattern.
Conversation history in generated scripts (Req #9) — All four create-agent-cli variants now generate scripts that check config.conversationHistory for prior messages, enabling multi-turn conversations in generated agents.

Fixed

Conversation persistence (Custom Script Agent) — Fixed agent replies vanishing from chatbox and conversation restarting fresh on every run. Root cause was three interacting bugs: restoration useEffect overwrite loop, React 18 batching making refs stale during SSE, and duplicate messages from emit_message + emit_complete. Fixed with hasRestoredConversationRef guard, localMessages closure variable, and dedup in complete handler.
Debug panel scroll & text selection — Fixed all four agent nodes (AI Agent, AI Router, AI Autonomous Agent, Custom Script Agent) so the debug panel scrolls content instead of zooming the canvas, and text is selectable/copyable.
No-hallucinated-tools enforcement — Generated agents were inventing tools like search_web and browse_url that don’t exist, causing runtime “Tool not found” errors. Added explicit ban on hallucinated tool names to all 8 create-agent-cli copies, with concrete self-tooling examples for web access. Temperature recommendation changed to 0.7 (from 1.0 which caused JSON parsing failures).

Security

Directory safety for agent file operations — Agent file operations are now sandboxed. Blocks path traversal (../) and writes to protected directories (Electron install dir, Windows system folders, Program Files). Custom Script Agent working directory falls back to Documents\NORA\csa-workdir when the resolved path is inside a protected location.

[1.0.2] – March 5, 2026

Fixed

Custom Script Agent Stop button — Now properly terminates scripts on Windows by killing the entire process tree (not just the parent process)
Custom Script Agent Clear button — Now available in all states (error, cancelled, success) not just when chat messages exist

Added

Agent Folder quick access — Open/Copy buttons on the Agent Folder badge for quick navigation to your CSA scripts folder
Interactive Conversations — Scripts can now ask follow-up questions using needs_input and carry on multi-turn Q&A with users. Uses a conversation-based (stateless) architecture where each response spawns a fresh process with full history.
Interactive script templates — Added interactive_agent.py and interactive_agent.js examples demonstrating the multi-turn Q&A pattern
Chat Panel Controls documentation — Added table documenting Stop, Clear, Rerun, Send, and Copy controls

[1.0.1] – Documentation Update – March 2026

Documentation

Added

License Activation guide in Getting Started — first-run activation, hardware binding, offline grace period
First-Run Setup section — auto-copied tools and example workflows to Documents folder
License tab documentation in Settings — view license key, machine ID, version
Auto-Updates section in Settings — check, download, and install updates
Source Sync feature in Tool Library — track script changes, sync tools, update nodes
10 condition types documented (expanded from 6) — output-check, output-contains, output-matches, numeric-threshold, numeric-range, json-expression
Debug Mode & Dynamic Tool Discovery for Custom Script Agent — fuzzy matching, Levenshtein tolerance, search_tools
Session Persistence for AI Autonomous Agent — resume interrupted sessions
Custom Script Agent API endpoints — session management endpoints
Tool Library Source quick access — click source label to open original file, plus Copy path action for full absolute path

Changed

AI model tables — updated with current models (gpt-4.1, o4-mini, o3, gemini-3 previews, gemini-2.5-flash-lite)
AI cost tracking — added prominent disclaimer that costs are approximate estimates only
Built-in tools for Autonomous Agent — expanded from 4 to 7 tools (added execute_command, ask_user, get_timestamp, delete_file)
API key security note — clarified that keys are not bundled with installer
Condition templates table in Reference — comprehensive table with all logic types and parameters

Fixed

Condition documentation now matches actual conditionLibrary.js implementation
API endpoints table now includes all Custom Script Agent routes

[Unreleased] – 0.3.31

Added – Custom Script Agent Node

Status: Implemented
Date: February 7, 2026

Overview

A new node type that provides the workflow UI shell (chat, execution log, routing, cost tracking) while letting users write their own agent logic in any language (Python, Node.js, etc.) with any LLM provider (OpenAI, Anthropic, Ollama, Groq, local models, etc.).

Problem

Existing AI agent nodes (AI Agent, AI Autonomous Agent, AI Router) are locked to specific LLM providers (OpenAI, Anthropic, Gemini). Power users need:
– Any LLM provider or local model
– Custom agent architectures (ReAct, CoT, multi-agent, etc.)
– Full control over prompts, parsing, and decision logic
– The same workflow routing, tool execution, and UI they already know

Solution: Custom Script Agent Node

Stdin/Stdout JSON Protocol
– Server spawns user’s script as a child process
– Bidirectional JSON communication via stdin (commands) → stdout (events)
– Events: log, thinking, message, cost, tool_request, needs_input, complete, error
– Actions: start, tool_result, user_message, stop

Dynamic Route Labels
– User-defined comma-separated labels (e.g., approve, reject, review)
– Each label becomes an output handle on the node (route_approve, route_reject, route_review)
– Built-in success and error handles always present
– Script chooses route via {"event": "complete", "route": "approve", "output": "..."}

Tool Execution Support
– Script can request tools via tool_request event
– Dashboard executes tools using existing executeToolCommand() infrastructure
– Results returned to script via tool_result action

Real-Time Streaming UI
– SSE streaming from server to frontend
– Live execution log, thinking indicators, iteration counter
– Cost tracking with USD calculation
– Chat panel with conversation history

Self-Contained API Key Management
– Scripts load their own .env file from the script’s directory
– Built-in .env parser fallback (no python-dotenv dependency required)
– App does NOT manage API keys for user scripts — users choose their model and key

Implementation Details

Phase	Component	Files
1	Backend Service	`services/customScriptAgent.js` — process spawn, JSON protocol, tool execution
2	Server Endpoints	`server.js` — SSE `/custom-script-agent/execute`, POST `/message`, `/stop`, GET `/status`
3	Node Component	`src/CustomScriptAgentNode.js` — dynamic handles, chat, execution log, run/stop
4	Properties Panel	`src/App.js` — script path, type, route labels, tools, memory config
5	Workflow Runner	`src/App.js` — execution block, edge routing, streaming state push
6	Templates	`docs/AI_Nodes/custom-script-templates/` — Python/JS templates + Anthropic Claude template

Integration Fixes (Post-Implementation)

AgentLogger crash: Added missing info/warn/error/debug convenience methods; fixed constructor args
Workflow routing: All edges were followed instead of routed one — added customScriptAgent execution block and edge routing logic to workflow runner
Streaming output: Node wasn’t showing live output during “Run from Selected” — added pushStateToNode pattern
SSE disconnect: req.on('close') fired on normal completion — added !res.writableEnded guard
Edge label dialog: Route labels now appear as quick-select suggestions when double-clicking edges from Custom Script Agent nodes
API key loading: Scripts now load .env from their own directory with built-in parser fallback

Critical Bug Fixes (February 7, 2026)

FIX: React 18 setState Batching Breaks All AI Agent Routing
– Symptom: Custom Script Agent (and all AI agent types) always routed to success edge regardless of script’s chosen route
– Root Cause: setNodes(updater) stores lastAgentRouteHandle inside its callback, but React 18 batches setState updaters. The followWorkflowExecution() function reads nodesRef.current before the batched updater executes, seeing undefined which defaults to 'success'
– Fix: Changed all three agent types (AI Agent, Custom Script Agent, AI Autonomous Agent) to update nodesRef.current synchronously (direct .map() mutation) THEN call setNodes(() => nodesRef.current) for UI re-render
– Files: src/App.js — 3 locations in executeNode() (aiAgent, customScriptAgent, aiAutonomousAgent)

FIX: handleSave Deletes maxMemoryFiles for Custom Script Agent
– Symptom: Memory folder shows 0 files despite being configured — maxMemoryFiles disappeared after saving properties
– Root Cause: handleSave() had if (type === 'aiAgent') { normalize } else { delete maxMemoryFiles } — the else branch deleted it for ALL non-aiAgent types including customScriptAgent
– Fix: Changed condition to if (type === 'aiAgent' || type === 'customScriptAgent') with type-appropriate defaults (1 for aiAgent, 5 for customScriptAgent)
– File: src/App.js — handleSave() function

FIX: toolsJson Not Parsed for Custom Script Agent
– Symptom: Tools configured in properties panel weren’t available to the script — saved as raw JSON string instead of parsed array
– Root Cause: Only aiAutonomousAgent had the JSON.parse(toolsJson) → tools conversion in handleSave(). Custom Script Agent saved the raw toolsJson string
– Fix: Added customScriptAgent block in handleSave() to parse toolsJson into tools array, delete toolsJson, and normalize maxRuntime
– File: src/App.js — handleSave() function

FIX: Tool Library Insert Not Working for Custom Script Agent
– Symptom: “+ Add from Tool Library” button opened the drawer but tools couldn’t be added — clicking a tool inserted it as a new canvas node instead of adding to the agent’s tools array
– Root Cause: Two files only checked for aiAutonomousAgent node type:
1. src/App.js — insertToolFromLibrary() callback only handled aiAutonomousAgent, so Custom Script Agent fell through to the default “insert as new node” path
2. src/components/ToolLibraryDrawer.js — Three UI gates (bulk “Add Selected” button, “Add All” button, per-tool checkboxes + “Add” button) were all gated to aiAutonomousAgent only
– Fix: Added || selectedNode.data?.type === 'customScriptAgent' to all 4 locations (1 in App.js, 3 in ToolLibraryDrawer.js)
– Files: src/App.js, src/components/ToolLibraryDrawer.js

UI Improvements (February 7, 2026)

Open/Copy Memory Folder Buttons: Added Open and Copy buttons to memory folder display on Custom Script Agent nodes, matching the pattern from AI Agent Node. Uses window.electronAPI.openDirectory() with clipboard fallback
Message Events in Execution Log: Script message events (containing reasoning, analysis) now render in the execution log UI. Previously only log, thinking, tool_start, tool_complete were displayed
Execution Log Height: Increased max height from 200px to 350px for better visibility of detailed logs
Files: src/CustomScriptAgentNode.js

[Unreleased] – 0.3.30

Added – Persistent Logging System for AI Agents

Status: Implemented
Date: February 6, 2026

Problem

All AI agent executions (Autonomous Agent, AI Agent, AI Router) previously kept logs and conversation history in memory only:
– ❌ No disk persistence – logs disappeared on reload/restart
– ❌ Single-node “Run” button executions had no tracking (no jobId, no nodeId)
– ❌ No way to review past agent conversations or debug issues
– ❌ WorkflowLogger only used for background workflows, not standalone runs
– ❌ Context window management: agents accumulated conversation history indefinitely with no pruning

Solution: Comprehensive Agent Logging System

New Service: AgentLogger
– Created services/agentLogger.js for persistent log management
– Directory: ~/.workflow-dashboard/agent_logs/{sessionId}-{nodeId}/
– Files per session:
– metadata.json – Session info (nodeId, nodeTitle, agentType, timestamps)
– conversation.json – Full conversation history with timestamps
– execution-log.json – Tool calls, iterations, costs, errors
– summary.json – Final status, total cost, duration, outcome

Session Tracking:
– Background workflows: Use existing jobId from WorkflowRunner
– Standalone runs: Generate standalone-{nodeId}-{timestamp} ID
– Pass sessionId + nodeId + nodeTitle from UI → server → aiAgentService

Integration Points:
– Modified all 3 agent node components (AIAutonomousAgentNode, AIAgentNode, AIRouterNode) to pass context
– Updated server endpoints to accept and track session info
– Integrated AgentLogger in aiAgentService for all agent types
– Updated WorkflowRunner to pass session tracking to background workflows
– Automatic log cleanup available via AgentLogger.cleanupOldLogs(maxAgeInDays)

Benefits:
– Full audit trail of all agent executions
– Debug capability by reviewing past sessions
– Cost tracking across all agents
– Persistent conversation history for resume
– Separate logs per session (no monolithic files)

Added – Tool Library Bulk Addition for Autonomous Agents

Status: Implemented
Date: February 6, 2026

Problem

Adding tools from the Tool Library to an Autonomous Agent required tedious one-by-one selection:
– Click “Add from Tool Library” button
– Select ONE tool from drawer
– Click add → drawer closes
– Repeat for each tool (5-10+ times for complex agents)

This process took 30+ clicks to configure a production agent with 10 tools, requiring 2-5 minutes of repetitive clicking.

Solution: Multi-Select + Add All

Added bulk tool addition capabilities with two new workflows:

Multi-Select Workflow:
– Check multiple tools in the Tool Library Drawer
– Click “Add Selected (N)” to add all checked tools at once
– Visual feedback shows count of tools being added
– Automatic deduplication skips already-added tools

Add All Workflow:
– Click “Add All Tools” to give agent access to entire library
– Warning when adding >20 tools: “Large tool sets may reduce agent accuracy”
– Useful for power users who want comprehensive tool access

Technical Analysis:
Token budget investigation confirms feasibility:
– Average tool description: ~100-200 tokens
– 10 tools = ~2,400-3,400 total tokens
– 50 tools = ~6,400-11,400 total tokens
– 100 tools = ~11,400-21,400 total tokens

Context window limits support large tool sets:
– GPT-4o: 128k tokens ✅
– Gemini 2.0 Flash: 1M tokens ✅
– Claude Sonnet: 200k tokens ✅

Even 100 tools would use <20% of most context windows.

Best Practices:
– Recommend 5-15 focused tools per agent (optimal)
– Warn at >20 tools (may reduce accuracy)
– Document: More tools = larger system prompt = slower responses + higher cost

Files Modified

File	Changes
`src/ToolLibraryDrawer.js`	Added checkboxes, multi-select UI, bulk action buttons
`src/App.js`	Modified insertToolFromLibrary to handle arrays
`src/AIAutonomousAgentNode.js`	Updated tool display for bulk additions

Benefits

10x faster configuration: 3 clicks instead of 30 clicks for 10 tools
Time savings: 2-5 minutes saved per agent configuration
Scale impact: Users configuring 5-10+ agents per project save 10-50 minutes total
Better UX: Clear visual feedback, deduplication, smart defaults

[0.3.29] – 2026-01-31

Fixed – Unicode Output Encoding for User Scripts

Problem

Python scripts printing Unicode characters (✓, emojis, etc.) failed on Windows with:

'charmap' codec can't encode character '\u2713' in position 0: character maps to <undefined>

This occurred because Windows console uses legacy codepages (e.g., cp1252) that don’t support Unicode characters, and child processes spawned by Node.js inherited this limitation.

Solution

Added UTF-8 encoding environment variables to all child process executions:
– PYTHONIOENCODING=utf-8 – Forces Python stdout/stderr to use UTF-8
– PYTHONUTF8=1 – Enables Python UTF-8 mode (Python 3.7+)

Files Modified

File	Changes
`server.js`	Added UTF-8 env vars to `/execute` endpoint options
`services/workflowRunner.js`	Added UTF-8 env vars to background execution options

Coverage

✅ Foreground runs (/execute endpoint)
✅ Background runs (WorkflowRunner)
✅ Interactive runs (terminal handles encoding natively)

User scripts can now safely print any Unicode characters without encoding errors.

[0.3.28] – 2026-01-27

Added – CMD + PowerShell Shell Support

Script nodes now support an explicit per-node shell selection (shellType): auto, cmd, powershell, pwsh.
PowerShell metacharacters (e.g. |, ;, $, $(...)) are supported when running under PowerShell/pwsh.
Shell selection is honored across foreground runs, interactive runs, background workflow runner, and AI tool execution.
pwsh selection falls back to powershell.exe automatically if PowerShell 7 (pwsh.exe) is not installed.

Changed – Command Execution Trust Model

Removed the brittle “block shell metacharacters” approach; workflow configs are treated as the trust boundary (configs are effectively code).
Documentation updated to guide users to choose the correct shell instead of relying on character restrictions.

[0.3.27] – 2026-01-25

Fixed – AI Autonomous Agent Tool Execution Protocol

Root Cause Fixed: –config Flag Not Being Appended

Problem: External tools (Python scripts) configured with argparse --config option were failing with:

error: one of the arguments --config --prompt is required

Root Cause Analysis:
1. During previous cleanup of CLI flag handling, the --config flag appending was accidentally removed
2. Tools were invoked as python script.py instead of python script.py --config params.json
3. This caused argparse to fail since required arguments were missing

Fix Applied:
– services/aiAgentService.js – Added --config flag appending in executeToolCommand():
javascript const configFlag = paramsFile ? ['--config', paramsFile] : []; const args = [...tokens.slice(1), ...configFlag];
– Both execFile (no-shell) and exec (shell) modes now correctly append the flag
– Shell mode uses proper quoting: ${command} --config "${paramsFile}"

Secondary Issue Fixed: Stale Server Process
– Electron’s server reuse logic (Server already running on port 4003, reusing it...) caused old code to persist
– Developers must kill orphaned server processes when testing code changes
– Added troubleshooting notes to documentation

Updated: System Prompt for Built-in Tools

Clarified that read_file, write_file, list_directory, file_exists are called via tool_call action
Added explicit example showing correct built-in tool invocation pattern
Prevents LLM from incorrectly using tool names as action types

Documentation Updates

Updated docs/AI_Nodes/TOOL-EXECUTION-PROTOCOL.md to v2.1
Added comprehensive Troubleshooting section with:
Common issues and solutions
Debug steps for tool execution failures
Server restart procedures
Added Quick Start Guide for script and workflow authors
Added Testing Your Tool section with PowerShell examples

Improved: Temp Tool Params JSON Location

Tool parameter/config JSON files are written under the tool workingDir in <workingDir>/.workflow-temp/.
This makes relative paths inside params/config (e.g. env_file: "../.env", output_json: "output/result.json") resolve predictably relative to the tool/workflow folder.

Technical Details

How Tool Execution Now Works (in NORA):
1. Agent provides parameters as JSON object
2. Dashboard writes params to .workflow-temp/tool_<name>_<hash>.json
3. Dashboard appends --config <path> to command
4. Dashboard also sets AI_TOOL_PARAMS_PATH environment variable
5. Script can read params from either source (flag or env var)

Verification:
– Tested with 01_generate_image tool successfully
– Prediction ID generated, Replicate API called correctly
– Full agent execution completed in 4 iterations

Fixed – AI Autonomous Agent Edge Routing

Root Cause Fixed: Workflow Followed ALL Outgoing Edges

Problem: When an AI Autonomous Agent completed execution, the workflow followed ALL outgoing edges regardless of which output handle was triggered.

Expected Behavior:
– Success → only follow edges from complete handle (green)
– Error → only follow edges from error handle (red)
– Max iterations → only follow edges from partial handle (yellow)
– Needs input → only follow edges from needs-input handle (blue)

Root Cause:
– src/App.js → followWorkflowExecution() had explicit handle-based routing for aiAgent, but no routing case for aiAutonomousAgent
– aiAutonomousAgent fell through to the generic handler which fans out across all outgoing edges

Fix Applied:
– src/App.js – Added an else if (nodeType === 'aiAutonomousAgent') routing block inside followWorkflowExecution()
– Filters candidate edges by edge.sourceHandle === targetHandle
– Uses targetHandle = sourceNode.data.lastAgentRouteHandle || 'complete' (forces error when node status is error/failed)

Verification:
– Confirmed handle IDs are complete, partial, needs-input, error in src/AIAutonomousAgentNode.js
– Confirmed executeNode() persists lastAgentRouteHandle for Autonomous Agent runs
– No syntax/type errors reported for src/App.js

[0.3.26] – 2026-01-23

Added – Media Viewer Path Management

Open/Copy Buttons for Media Path

The Media Viewer node now includes interactive path management similar to AI Agent nodes:

Features:
– Open Button – Opens the folder containing the media file in native file explorer
– For file paths: Automatically opens the parent directory
– For folder paths: Opens the folder directly
– Only shown for local paths (hidden for HTTP/HTTPS URLs)
– Desktop app only (uses window.electronAPI.openDirectory())
– Copy Button – Copies the full media path to clipboard
– Works for both local paths and remote URLs
– One-click access to the full path for debugging or documentation

UI Enhancement:
– Path display now uses flex row layout with truncation
– Full path visible on hover (tooltip)
– Consistent styling with AI Agent/Autonomous Agent nodes
– Buttons positioned next to truncated path for quick access

Technical Details:
– openMediaPath() function intelligently detects file vs folder paths
– File paths: Extracts parent directory using path normalization
– Folder paths: Opens directly without modification
– copyMediaPath() uses navigator clipboard API with fallback handling

Fixed – Media Viewer in Dropdown

Added Media Viewer to conditionLibrary.js (was missing after code cleanup)
Positioned before AI section to prevent accidental removal during AI development
Updated categoryOrder in App.js to show Display category before AI

[0.3.25] – 2026-01-20

Added – AI Autonomous Agent Premium Enhancements 🚀

Built-in File System Tools (Always Available)

The Autonomous Agent now has 4 built-in file system tools that work without external scripts:

Tool	Description	Parameters
`read_file`	Read file contents from any path	`path` (required), `maxChars` (default: 50000)
`list_directory`	List files/folders in a directory	`path` (required), `recursive` (optional)
`write_file`	Write/append content to files	`path`, `content` (required), `append` (optional)
`file_exists`	Check if path exists	`path` (required)

User Impact:
– Agent can now explore and read files when user mentions a path in conversation
– No more “I can’t access your file system” responses
– Works immediately without configuring any external tools
– User tools are additive (built-in + your configured tools)

Security Note:
– Read operations are unrestricted (agent can read any accessible path)
– Write operations can create/overwrite files (no delete capability)
– No path restrictions currently enforced

Persistent Conversation (True Dialogue)

Conversation persists after task completion – history is maintained
Follow-up messages continue with full context (e.g., “now also do X”)
Backend distinguishes between:
Resume after question (waiting-for-input) → Answers pending question
Follow-up after completion → Treats as new related task with context
actionType markers on messages help backend detect conversation state
Premium agent behavior: Ongoing dialogue with memory, not just task completion

Unified Chat Interface

Single persistent chat UI regardless of agent status
No more mode switching between “chat bubbles” and “static view”
Saved task display with “Run Configured Task” button for rerun
Consistent Clear/Rerun/Copy buttons in all states

Fixed – Memory Folder File Patterns

Problem: Memory folder ignoring .md files (only reading .txt)
Fix: Default file pattern now *.txt;*.md;*.json;*.html across all 8 locations:
aiAgentService.js loadMemoryFiles default
aiAgentService.js executeAgent config
server.js autonomous agent endpoint (line 1685)
server.js ai-agent endpoint (line 1465)
workflowRunner.js 3 locations (AI Agent, Router, Autonomous)
AIAutonomousAgentNode.js parseResolvedValue fallback
Impact: README.md and other markdown files in memory folder now loaded as context

Fixed – Open/Copy Memory Folder Buttons

Added Open/Copy buttons to all 3 AI node types consistently:
AI Agent Node ✅ (already had)
AI Autonomous Agent Node ✅ (added)
AI Router Node ✅ (added)
Electron: Opens folder in native file explorer
Web: Copies path to clipboard with alert

Technical Details

services/aiAgentService.js:
Added BUILTIN_TOOLS object with 4 file system tools
Each tool has isBuiltin: true flag and execute() async function
executeAutonomousAgent() merges built-in + user tools
buildAutonomousSystemPrompt() now shows parameter details
buildAgentContext() detects completion vs question-resume
src/AIAutonomousAgentNode.js:
Unified renderChatPanel() for consistent UI
actionType markers on conversation messages
Resume logic simplified (any existing conversation = resume)

Known Issue – Canvas Shift During Streaming ✅ FIXED

Problem: When Autonomous Agent chat is streaming messages, the canvas shifted up
Cause: scrollIntoView() was scrolling the entire page, not just the chat container
Fix: Changed to scrollTop on chat container ref – only scrolls within the chat panel
Result: Canvas stays stable during message streaming

[0.3.24] – 2026-01-19

Improved – Chat UI Separation & Clear Button Accessibility

Separate Chat Input Field: Chat input is now completely separate from Task textarea
chatInput state independent from taskInput
Dedicated Send button in chat panel (not Resume button reuse)
Enter key to send in chat mode
Chat input clears after sending
Task Textarea Hidden in Chat Mode: When agent waiting for input, Task field is hidden
No confusion between two input fields
Chat panel handles all input during conversation
Action Buttons Hidden in Chat Mode: Run/Resume buttons replaced by Send in chat panel
Cleaner UI when in conversation mode
No redundant controls
Clear Button Always Accessible: Added Clear button to both chat modes
Live Chat mode: Clear button in header next to “Live Chat” label
Static History mode: Clear button in header next to Copy button
Can reset for fresh run from any state
Copy Button in Live Chat: Added Copy button to Live Chat mode header
Consistent UI between chat modes
Both Copy and Clear accessible in either mode
Fixed Duplicate Props Warning: Removed duplicate onFocus handler on chat input

Technical Details

src/AIAutonomousAgentNode.js:
Added chatInput state separate from taskInput
Added chatInputRef for chat input field
Conditional rendering: Task textarea hidden when waiting-for-input
Action buttons hidden when waiting-for-input
Chat panel header has Copy + Clear buttons in both modes
handleResumeWithInput() uses chatInput not taskInput

[0.3.23] – 2026-01-19

Added – AI Autonomous Agent Chat UI & Error Display 💬

Chat Bubble Interface (when waiting for user input):
Conversational chat bubbles instead of static text dump
Agent messages: Blue bubbles, left-aligned with 🤖 icon
User responses: Green bubbles, right-aligned with 👤 icon
Max-width 70%, rounded corners, subtle shadows
Pending question appears as highlighted agent bubble with blue border
Auto-scroll to latest message
Live Chat header with “Agent is waiting for your response” indicator
Static Conversation View (for background/review):
Traditional conversation history display when not waiting for input
Copy button for full conversation text
Compact view for reviewing past exchanges
Expandable Error Details in execution log:
Initial compact display: [3] ✗ tool-name - Error: Command failed (click for details)
Click to expand shows full error context:
- Command that was executed
- Full stderr output (scrollable)
- Full stdout output (scrollable)
- Exit code
- Error message
Red-bordered panel with monospace font for error details
Click again to collapse back to compact view
No extra files or windows needed
Enhanced Backend Error Reporting:
executeToolCommand() now returns errorDetails object
Includes: command, stderr, stdout, exitCode, message
Full error context available for debugging
Execution log preserves error details for later inspection

Why This Matters

Before: “Error: Command failed: python” → No idea what went wrong
After: Click to see full stderr: “ModuleNotFoundError: No module named ‘pillow'” → Fix immediately
Chat UI: Natural conversation flow when agent asks questions, not awkward static form
Conditional Display: Right UI for the context (chat when interactive, static when reviewing)

Technical Details

src/AIAutonomousAgentNode.js: Added expandedErrors state, conditional chat UI rendering
services/aiAgentService.js: executeToolCommand() returns errorDetails object
Chat bubbles only appear when executionState === 'waiting-for-input'
Error expansion tracked per-log-entry with Set state
Auto-scroll to bottom on new messages (chatEndRef)

[0.3.22] – 2026-01-19

Fixed – Foreground Workflow Execution for Autonomous Agent 🚀

Problem: “Run Full Workflow” button didn’t execute AI Autonomous Agent nodes – workflows “flew through” without running the agent
Root Cause: App.js executeNode() had incomplete stub implementation that only checked lastAgentStatus and marked as ‘pending’ without executing
Impact: Agent only worked via “Run” button on node, not during full workflow execution
Fix Applied:
Replaced stub with full executeAutonomousAgent() API call
Added real-time progress updates during execution
Proper routing to all 4 handles (complete, partial, needs-input, error)
Conversation state persistence for resume scenarios
Cost and iteration tracking
Detailed output messages (✅ Complete, ⚠️ Partial, 💬 Needs Input, ❌ Error)
Files Updated: src/App.js executeNode() function (~145 lines of new execution logic)
Execution Modes Now Working:
✅ Interactive (click “Run” on node)
✅ Foreground (click “Run Full Workflow” button)
✅ Background (scheduled/automated workflows)

Added – Production Example Workflows

4 Complete Workflow Examples for testing AI Autonomous Agent:
email-triage-workflow.js – Customer email auto-response with sentiment analysis
data-quality-etl-workflow.js – ETL data validation pipeline
incident-response-devops-workflow.js – DevOps auto-remediation
video-production-workflow.js – AI video creation from text requirements
Each Workflow Includes:
Autonomous agent node with inline tools (4-7 tools each)
All 4 routing paths (complete → partial → needs-input → error)
Downstream notification nodes
Archive/logging nodes
“WHERE SCRIPTS GO” documentation in notepad
Field Structure: Both userRequest (Task UI field) and systemPrompt (agent instructions)

Fixed – Field Name Mismatch

Problem: Example workflows used systemPrompt but UI expected userRequest for Task text area
Impact: Task field appeared empty when loading workflows
Solution: Updated all workflows to include BOTH fields:
userRequest = Short task description shown in UI
systemPrompt = Internal agent behavior instructions
Files Updated: All 4 example workflow files

Documentation Updates

Updated AI-AUTONOMOUS-AGENT-PLAN.md:
Phase 3.2 complete ✅
Added “Foreground Execution Fix” section
Known Issues #2 documented with fix details
Status: Production Ready ✅
Updated FIXES-SUMMARY.md with foreground execution bug fix
Updated CHANGELOG.md with v0.3.22 release notes

[0.3.21] – 2026-01-18

Added – AI Autonomous Agent Node

New Node Type: AI Autonomous Agent 🤖⚡: A production-grade agentic node that executes multiple tools in sequence autonomously.
Agentic Loop Execution: LLM decides which tool to call next, executes it, reads result, and continues until task is complete
Multi-Tool Support: Configure multiple tools (scripts, commands) that the agent can orchestrate
Three Ways to Add Tools:
1. Tool Library Button: Click “Add from Tool Library” to browse and add reusable tools
2. Drag-Drop Scripts: Drag Python/JS/etc scripts directly onto the agent node from File Explorer
3. Manual Configuration: Define inline tool definitions in the form
Real-Time Execution Log: See step-by-step progress as agent works:
- ▶ Connecting to agent... (immediate feedback)
- [1] 🔧 tool-name - reasoning (tool starts)
- [1] ✓ tool-name (123ms) (tool completes with result preview)
SSE Streaming: Live progress updates via Server-Sent Events
Conversation History: Agent can ask clarifying questions, user responds, agent continues
Four Output Handles: Route based on execution state:
- complete → Task finished successfully
- partial → Did what it could, needs more info later
- needs-input → Blocked, waiting for user response
- error → Execution failed
Upstream Context Merging: Accepts aiToolParams from prior nodes for workflow integration
Memory Folder Support: Load context from files in a configured folder
Execution Limits: Configurable max iterations, timeout, and budget limits
Background Workflow Support: Works in scheduled/automated workflows via workflowRunner
Copy Buttons: Copy execution log or conversation history with one click
Stop Button: Cancel running agent with feedback in log

Added – Drag-Drop Scripts onto Autonomous Agent

Drop to Add Tool: Drag script files from File Explorer directly onto an AI Autonomous Agent node
Script automatically converted to inline tool definition
Tool name extracted from filename (e.g., process_data.py → process-data)
Command auto-generated from file type (e.g., python "E:/scripts/process_data.py")
Duplicate detection prevents adding same tool twice
Works with multiple files at once
Notification confirms: ✅ Added "tool-name" as tool to agent

Technical Details – AI Autonomous Agent

Backend Service (services/aiAgentService.js):
executeAutonomousAgent() – Core agentic loop with iteration, timeout, budget limits
resolveTools() – Resolves toolRef to inline definitions via Tool Library
parseAutonomousAction() – Parses LLM output for tool_call, complete, needs_input actions
buildAutonomousSystemPrompt() – Constructs agent system prompt with tool descriptions
SSE Endpoint (server.js):
POST /ai-autonomous-agent/execute – Streaming endpoint with progress events
Events: start, progress (tool_start, tool_complete), complete, error
Frontend Component (src/AIAutonomousAgentNode.js):
~900 lines with full execution UI, chat panel, execution log
Uses eventType vs type to distinguish SSE event name from progress subtype
Frontend API (src/services/apiService.js):
executeAutonomousAgent() – Streaming SSE client with fetch + ReadableStream
App.js Integration:
Node type registered in nodeTypes object
Added to 6+ type mapping locations for persistence
handleCanvasDrop updated with three-way routing (agent→tools, node→links, canvas→nodes)
findNodeUnderDrop() helper uses DOM traversal to detect drop target
addToolToAutonomousAgent() helper creates inline tool from dropped script
Background Workflow (services/workflowRunner.js):
Full handler for aiAutonomousAgent nodes
Gathers upstream context from parent nodes
Routes to all 4 handles (complete, partial, needs-input, error)
Saves conversation state for resume scenarios
Condition Library (src/conditionLibrary.js):
Entry for ai-autonomous-agent with edgeDefaults for all handles

Fixed – SSE Event Type Collision

Problem: Agent showed no step-by-step progress (“black box” behavior)
Root Cause: apiService.js was using {type: currentEvent, ...data} which overwrote type: 'tool_start' from the data payload with type: 'progress' from the SSE event
Solution: Changed to {eventType: currentEvent, ...data} so both values are preserved
Result: Execution log now shows each tool call in real-time

Fixed – Node Type Persistence

Problem: AI Autonomous Agent nodes reverted to basic CustomNode UI after save/reload
Root Cause: aiAutonomousAgent was missing from multiple type mapping locations in App.js
Fixed Locations (6+):
initialNodes useMemo
updateNodeDataInline mapWorkflowTypeToReactFlowType
insertToolFromLibrary reactFlowType
addNewBlock reactFlowType
loadConfig newNodes
handleImport newNodes
updateNodeData nextReactFlowType

Session Statistics (January 18, 2026)

Files Created: 1 (src/AIAutonomousAgentNode.js ~900 lines)
Files Modified: 6 (App.js, apiService.js, aiAgentService.js, server.js, workflowRunner.js, conditionLibrary.js)
Implementation Phases: 1 (Core) → 1.5 (Resume) → 2 (Tool Library) → 2.5 (Fixes) → 2.6 (Drag-Drop)
Key Bug Fixes: SSE event collision, node type persistence, tool syncing, textarea input handling

[0.3.20] – 2026-01-18

Added – Drag & Drop Files as Links to Regular Nodes

Auto-Add Links via Drag & Drop: Users can now drag and drop files (text, markdown, PDFs, scripts, etc.) from Windows Explorer directly onto regular workflow nodes to automatically add them as links.
Parallel Feature to Agent Tool Drop: This mirrors the recently implemented drag-drop-to-agent feature (where scripts are dropped onto autonomous agent nodes to add as tools), but targets regular nodes for link addition.
No Manual Entry Required: Eliminates tedious manual typing of file paths and file:/// URL formatting.
Automatic Filename Extraction: File label is automatically extracted from the full path (e.g., E:/Projects/notes.txt → notes.txt).
file:/// URL Generation: Paths are automatically converted to proper file:/// URLs with normalized forward slashes for cross-platform compatibility.
Duplicate Detection: Checks existing links array and prevents adding duplicate URLs to the same node.
Multi-File Support: Drop multiple files at once; shows batch notification (e.g., “✅ Added 3 links to Node Title”).
Path Normalization: Converts Windows backslashes to forward slashes for consistent file:/// URL format.
User Feedback: Shows notification with filename for single-file drops, count for multi-file batches.

Technical Details – Implementation

New Helper Function (src/App.js line ~1458, 35 lines):
addLinkToNode(node, droppedItem): Handles link addition logic
- Extracts filename: split(/[/\\]/).pop() for cross-platform compatibility
- Formats file:/// URL: file:///${normalizedPath} (backslash → forward slash)
- Checks for duplicate URLs in existing node.data.links array
- Updates node via updateNodeDataInline({ links: updatedLinks })
- Shows notification: showNotification('success', \✅ Added ${filename} to ${node.data.title}`)`
Updated Drag & Drop Router (src/App.js handleCanvasDrop, ~line 1493):
Three-Branch Routing Logic:
1. Autonomous Agent Branch: if (isAutonomousAgent) → add tools (existing behavior from previous feature)
2. Regular Node Branch (NEW): if (targetNode && !isAutonomousAgent) → add links to regular nodes
3. Canvas Branch: else → create new nodes from dropped files (existing behavior)
Iterates over dropped items calling addLinkToNode for each file
Batch notifications for multi-file drops
Path Analysis: Reuses existing window.electronAPI.analyzePathsForNodes infrastructure from Quick Add Phase 3
Cross-Platform Compatibility: Forward slash normalization ensures file:/// URLs work on Windows, Mac, and Linux

User Benefits

Time Savings: No more manually copying paths, typing file:///, or entering link labels
Error Reduction: Eliminates typos in long absolute paths and URL formatting mistakes
Workflow Efficiency: Quickly reference supporting documents, scripts, and resources by dragging them from File Explorer
Consistency: File URLs work reliably across platforms with normalized path format

Example Use Cases

Drag README.md onto a node to document its purpose
Drop Python scripts onto nodes that use them as inputs
Attach log files to monitoring nodes for quick access
Link configuration files to setup/deployment nodes
Reference PDFs, images, or any file type from workflow nodes

Debugging Context

Feature implemented via 2 operations using multi_replace_string_in_file tool
Clean implementation with no errors reported
Pattern follows existing addToolToAutonomousAgent reference implementation
Duplicate checking prevents redundant links accumulating over time

Session Statistics (January 15, 2026)

Duration: ~2 hours (planning, approval, implementation, documentation)
Files Modified: 1 (src/App.js)
Lines of Code: ~50 new (35 lines helper + ~15 lines router update)
Implementation Approach: multi_replace_string_in_file (2 atomic operations)
Reference Pattern: Reused addToolToAutonomousAgent design for consistency

[0.3.19] – 2026-01-15

Fixed – Workflow Saving (Inline Command Editor)

Ctrl/Cmd+S could save a stale command: If the Command textarea still had focus, the latest keystrokes might not be committed into node state before serialization. This could make the UI show “saved” but a refresh would bring back the previous command.
Save now commits focused edits before serializing: quickSave() and saveAs() force a blur on the active element and yield one tick before building workflowBlocks.

Fixed – Electron Mode Save Path Handling

Electron save could break due to undeclared variable: /save-config referenced customWorkflowFolders even though that variable is not in scope in that handler.
Save now uses request-provided folders: /save-config uses customFolders (sent from saveConfigFile() in the frontend) to expand the list of allowed save directories.

Added – Save Verification (Debugging)

Save response includes file stats: /save-config now returns { savedStats: { size, mtimeMs } } so we can verify that a save actually hit disk and changed the file.

[0.3.18] – 2026-01-13

Fixed – Media Viewer Node

Text File Preview: Text files (.txt, .md, .json) now display their content in an iframe instead of just showing a download link. Preview works both inline (150px) and expanded modal (82vh).
Video/Audio Auto-Refresh: Fixed videos and audio files not updating when auto-latest refresh triggers. Now uses cache-busting query parameter (&v=) and element remounting via React key prop to force reload on source changes.
Refresh Button Accessibility: Moved manual refresh button (🔄) from edit-mode-only controls to always-visible header area next to expand button. Users can now refresh latest file without entering edit mode.
Workflow Persistence: Fixed Media Viewer nodes disappearing when workflows are saved and reloaded. Added media-viewer → mediaViewer type mapping in handleConfigImport function (was missing, causing nodes to render as generic custom nodes).

Technical Details – Media Viewer Fixes

Text Preview Implementation (src/MediaViewerNode.js):
Added rendering case for detectedType === 'document' (was falling through to download link)
Uses iframe with same dimensions as PDF preview
Supports .txt, .md, .json files (detected via detectMediaTypeFromUrl)
Video/Audio Reload Fix (src/MediaViewerNode.js):
Enhanced buildLocalMediaUrl() to accept optional cacheBust parameter
Added state tracking: resolvedLatestModifiedTime and latestReloadNonce
Cache-buster appended to resolvedSrc when shouldResolveLatest === true
Video element: added key prop tied to resolvedSrc to force remount on change
Audio element: same treatment (key + direct src)
Removed nested <source> tags (not needed with direct src attribute)
Refresh Button UI Change (src/MediaViewerNode.js):
Moved from edit controls section to header button group (lines 549-571)
Shows when (autoLatest || looksLikeFolderPath(mediaUrlRaw)) && looksLikeLocalPath(mediaUrlRaw)
Removed duplicate “Refresh now” button from edit-mode controls
Always accessible in both edit and run modes
Persistence Fix (src/App.js line ~1620):
Added type mapping in handleConfigImport: block.type === 'media-viewer' ? 'mediaViewer'
Mirrors existing mappings for notepad, condition, aiRouter, aiAgent
Prevents Media Viewer nodes from being loaded as generic custom nodes

Planned – Media Viewer Enhancements

Text File Editing (Phase 4): Documented as possible future feature in MEDIA-VIEWER-NODE-PLAN.md. Would add inline editing with save capability via new POST /media/write-local endpoint. On hold pending user feedback.

[0.3.17] – 2026-01-13

Improved

Import Config Browser Starts Collapsed: The Import Configuration modal now opens showing only the top-level folders/sources; users expand folders to reveal files.

Added

ConfigFileSelector defaultExpand Prop: ConfigFileSelector now supports defaultExpand="all" | "none" so callers can control whether sources start expanded.

[0.3.16] – 2026-01-10

Added – AI Agent Tool Parameters (Dynamic Param Passing)

Production-Safe Tool Parameter Handoff: AI Agent can now pass arbitrary, evolving parameters (prompt, model, width, height, etc.) to connected tool scripts without brittle command-line templating.
Per-Invocation JSON Params File: Runtime creates a unique JSON file per tool execution in .workflow-temp/ with restricted permissions.
Environment Variable Pointer: Tool processes receive AI_TOOL_PARAMS_PATH pointing to the params JSON file.
Automatic Cleanup: Params files are deleted immediately after tool completion to avoid clutter.
Frontend→Backend Flow (Foreground): AI Agent toolArgs flow from aiAgentService → frontend aiToolParams → /execute endpoint → temp JSON → spawned tool process.
Background Workflow Support: workflowRunner.js now handles AI Agent tool parameters for scheduled, automated, and continuous workflows.
Backwards Compatible: Existing workflows and tools work unchanged; param reading is optional.
Multi-Language Support: Tools can read params in Python, Node.js, PowerShell, Bash with minimal code changes (5-10 lines).
Test Workflow Included: ai-tool-params-echo-workflow.js demonstrates multi-media routing (image + video generation from single AI Agent).
AI Agent “Open Memory Folder” Link: AI Agent nodes now display Open and Copy buttons next to the configured memory folder path.
One-Click Folder Access: Clicking “Open” launches Windows Explorer (or Finder on Mac) directly to the memory folder, eliminating the need to copy-paste paths.
Electron IPC Integration: New open-directory IPC handler in electron.js uses shell.openPath() with path validation (exists + is directory).
Graceful Fallback: In web/browser mode (non-Electron), “Open” falls back to copying the path to clipboard.
Error Handling: Displays alerts for missing directories or permission errors.

Technical Details – Tool Parameters

Implementation Files:
src/services/apiService.js: executeCommand() accepts optional toolParams and sends to /execute.
src/App.js: After AI Agent returns toolArgs, attaches as node.data.aiToolParams to downstream tool node; passes to executeCommand(); clears after execution.
server.js: /execute endpoint creates temp JSON file via createTempJsonFile(), injects AI_TOOL_PARAMS_PATH into spawned process env, cleans up file after completion/error.
services/workflowRunner.js: AI Agent nodes store lastAgentToolParams; script nodes detect params from parent AI Agents, create temp JSON, inject env var, cleanup after execution.
docs/AI_Nodes/standalone_image_generator.py: Updated with minimal JSON-reading code (5-10 lines) as reference implementation.
docs/AI_Nodes/standalone_video_generator.py: Updated to support AI Agent params with argparse fallback pattern.
Security: No shell injection risk (params stay in JSON file); file created with restricted permissions; cleanup prevents sensitive data accumulation.
Concurrency-Safe: Unique file names per invocation (params-<timestamp>-<random>.json) prevent collisions across parallel runs.
Design Rationale: Avoids Windows command-length limits, shell quoting/escaping issues, and brittle placeholder templating; matches patterns used by production workflow platforms.

Technical Details – Open Memory Folder

Implementation Files:
electron.js: Added shell import and ipcMain.handle('open-directory') handler with path normalization, existence checks, and shell.openPath() call.
preload.js: Already exposed openDirectory method in window.electronAPI.
src/AIAgentNode.js: Added openMemoryFolder() and copyMemoryFolder() handlers; updated UI to show Open/Copy buttons in flex layout.
Path Validation: Backend verifies path exists and is a directory before attempting to open; returns { success, error } to frontend.
Cross-Platform: Uses shell.openPath() which works on Windows, Mac, and Linux.

Documentation

Updated: docs/AI_Nodes/AI-AGENT-TOOL-PARAMETERS-PLAN.md with comprehensive “Implementation Complete” section including:
Detailed user guide for configuring scripts to read JSON params (Python, Node.js, PowerShell, Bash examples)
Best practices (always provide defaults, handle missing file gracefully, coerce types)
Debugging tips (check env var, print JSON, verify structure)
Security considerations (treat as untrusted input, validate, sanitize)
Real-world image generator example with CLI + AI params fallback pattern
Testing instructions (manual test with test JSON file, workflow test)
Updated: docs/CHANGELOG.md, docs/PROJECT-STATUS.md with feature summaries and status.

[0.3.15] – 2025-12-26

Added

Execution History Cost Grand Total: Execution History now shows a footer row with the grand total AI cost across the listed executions.
AI Cost in Email Execution Summary: Workflow completion emails include total AI cost and total AI tokens in the Execution Summary (when available).

Fixed

Execution History Cost Always $0.00: Fixed cost aggregation returning 0 due to inconsistent cost shapes/types across log entries (e.g., string values vs numbers, top-level vs nested fields).
Cost Extraction Robustness: Logger summary now supports both costUsd and cost.totalUsd and safely converts values to numbers before summing.
Foreground Runs Missing Cost in Execution History: Fixed a timing issue where the foreground logger jobId could lag behind the first node execution, causing AI usage/cost log events to be skipped and totals to remain at $0.00.

[0.3.14] – 2025-12-25

Added – AI Agent Multi-Turn Conversations (Phase 2)

Multi-Turn Conversation Mode: AI Agents can now hold stateful conversations across multiple execution steps.
Conversation Loop: The agent can execute a tool, receive the result, and then decide to execute another tool or give a final answer.
Configuration: New “Conversation Settings” section in Block Edit Form allows toggling between “Single Turn” (default) and “Multi-Turn”.
Safety Limits: Configurable “Max Turns” (default: 5) prevents infinite loops.
Visual Feedback:
Turn Counter: AI Agent nodes display a “Turn X/Y” badge when running in multi-turn mode.
History Persistence: Conversation history is preserved in the node’s data throughout the workflow execution.
Backend Support:
Stateful Execution: aiAgentService.js now returns updated conversation history.
Loop Handling: workflowRunner.js (background) and App.js (frontend) updated to support re-executing the same agent node until the conversation concludes or max turns are reached.

Fixed

AI Node Input Fields: Fixed bug where users could not type commas in “Categories / Routes” (AI Router) and “Tools” (AI Agent) fields.
Root cause: onChange handler was splitting the string into an array on every keystroke, removing trailing commas immediately.
Fix: Updated BlockEditForm to manage these fields as raw strings during editing and only parse them into arrays upon saving.

[0.3.13] – 2025-12-24

Added – AI Agent Node (Phase 1)

AI Agent Node (aiAgent): New node type that builds on the existing AI Router classifier to choose a “tool” for the latest text/HTML file in a folder and route the workflow using source handles, not edge labels.
Tools are configured as a simple list of names (e.g., create-task, send-email, summarize) in the Block Edit form.
At runtime, the agent reuses the AI Router classifier endpoint, treating tool names as categories to pick the best next action.
The chosen tool is exposed on the node as lastAgentTool along with aiSummary, aiFields, and aiSourceFile metadata.
Handle-Based Routing: followWorkflowExecution now understands aiAgent nodes and routes them via dedicated source handles:
One handle per tool: tool_<slug> (e.g., tool_create-task).
success handle when no specific tool edge is matched (or when you just want a generic AI branch).
error handle for failure paths.
This is intentionally different from the AI Router, which routes exclusively via edge labels.
Agent Configuration UI: The Block Edit modal gained a dedicated configuration section when a block is of type aiAgent:
AI provider/model dropdowns (Gemini/OpenAI/Anthropic) with the same presets and custom model support as aiRouter.
Memory/input folder path, file pattern (e.g., *.txt;*.html), sort-by (modified/created).
Tools text box (comma-separated list) with inline help explaining how handles are derived.
Optional custom prompt to nudge the agent on how to pick tools or summarize content.
Canvas Visualization (AIAgentNode): New React Flow node component that:
Shows provider/model, memory folder, and a compact list of tools.
Renders one right-side handle per tool, plus success and error handles, matching the runtime routing logic.
Displays status/output in the same style as other nodes for easy debugging.

Improved – UI/UX Refinements

Edit Block Modal Width: Increased from 400px to 550px for better visibility of configuration fields, especially for AI nodes with long paths and custom prompts.
Link Text Wrapping: Added word-wrap, overflow-wrap, and word-break CSS properties to link display in Block Edit Form to prevent URLs from overflowing container bounds.
Edge Double-Click Editing: Implemented separate onEdgeDoubleClick handler that works in any mode (not just edit mode), allowing users to quickly edit edge labels without entering edit mode first.
Header Box Narrowing: Reduced header/search panel width from 300px to 240px to provide more canvas space for workflow visualization.
Toolbar Responsiveness: Added maxWidth: calc(100vw - 280px) constraint to Edit Mode toolbar to prevent buttons from extending off-screen when Connect/Duplicate/Delete buttons appear.
Compact Button Styling: Reduced padding and font sizes on Settings and Edit Mode toggle buttons for a more streamlined toolbar appearance.

Technical Details

AI Agent execution currently reuses the existing AI Router classifier endpoint by passing the configured tools as categories; no new backend dependency or vector database is required for Phase 1.
A shared slugifyToolName() helper keeps the React node handles (e.g., tool_create-task) and the workflow execution routing logic in sync.
AI Agent routing runs before AI Router routing in followWorkflowExecution so that handle-based decisions are applied first.
Edge click handlers are now separated: onEdgeClick (edit mode only, single-click) vs onEdgeDoubleClick (any mode, double-click).
Link display container gained flexible text wrapping with break-all for long URLs.
Toolbar max-width prevents overflow while maintaining button accessibility.

[0.3.11] – 2025-12-24

Added – AI Router Node (v1) & CSV Export

AI Router Node (Foreground & Background)
Introduced a new aiRouter node type that reads the most recent text-like file from a configured folder (inputFolderPath, filePattern, sortBy) and classifies it using a pluggable AI provider.
Supported providers: Gemini, OpenAI, and Anthropic, with provider-specific model presets and a “Custom” model option per node.
Per-node API key override (aiApiKey) allows nodes to use different keys from global/env settings when needed.
Classification results are normalized to { category, summary, fields } and stored on the node (lastAiCategory, aiSummary, aiFields, aiSourceFile) so both the UI and email/logging can reference them.
Background workflows (workflowRunner.js) gained matching aiRouter handling so headless runs classify and route the same way as foreground runs.
Category-Based Routing via Edge Labels
followWorkflowExecution (frontend) and workflowRunner.followWorkflow (backend) now treat aiRouter nodes specially:
- If a lastAiCategory is present, only outgoing edges whose label matches that category (case-insensitive string match) are followed.
- If there are labeled edges but none match, the branch stops at the AI Router (no implicit fallback).
- If there are no labels on outgoing edges, all outgoing edges are followed (fan-out fallback), providing a safe default for simple workflows.
This design reuses existing handles and keeps routing transparent in the canvas by making edge labels the primary contract.
AI Configuration UI in Block Edit Form
Added a dedicated AI Router configuration section to the Block Edit modal when editing aiRouter nodes:
- Provider dropdown with gemini, openai, anthropic.
- Model presets per provider (e.g., gemini-2.0-flash-exp, gpt-4o-mini, claude-3-5-haiku-latest) plus Custom model textbox.
- Input folder settings: inputFolderPath, filePattern, sortBy (modified or created).
- Per-node API key override that falls back to environment/global config if left blank.
AIRouterNode header now mirrors the effective provider/model selection logic used during execution, so what you see on the node matches what the backend actually calls.
Optional CSV Export for AI Router
New per-node options: “Also save CSV output for this node” (aiCsvEnabled) and CSV directory (aiCsvDir).
Extended /ai-router/classify endpoint to accept nodeId, saveCsv, and csvOutputDir in addition to provider/model and folder settings.
When CSV is enabled and a directory is provided:
- The server resolves the directory (absolute paths used as-is; relative paths resolved against the project root) and ensures it exists.
- It writes a single-row CSV per classification with columns such as timestamp,category,summary,file_path,provider,model,fields_json.
- The generated csvPath is returned to the caller, recorded on the node (aiCsvPath), and appended to the node’s output text so users can quickly locate it.
This enables external scripts (Python, PowerShell, etc.) to watch a folder and react to AI Router decisions via simple CSV ingestion.

Known Limitations (AI Router v1)

No keyword-based fallback yet; if the AI call fails, the node reports an error and the branch stops unless explicit error-routing edges are present.
Confidence scores are not exposed in the UI or used for routing decisions; routing currently trusts the model’s single chosen category.
CSV files are not auto-cleaned; lifecycle management (retention/append) is planned for a future release.

[0.3.10] – 2025-12-23

Fixed – Pre-GTM Critical Bugs

Windows Startup Reliability Hardening
Ensured “Start with Windows” stays in sync with the actual Startup shortcut.
On enable, always creates/refreshes a proper .lnk in the Windows Startup folder pointing to the packaged EXE with --hidden.
On disable, deletes any existing shortcut so users don’t get ghost startups.
Adds safer dev vs packaged checks so dev runs don’t pollute Windows Startup.
Built-in Workflows Missing on Fresh Install
Fixed bug where “Browse Configs” appeared empty on a fresh install because built-in example workflows under src/import-workflow-config/ were not copied into the production build.
Added build-time copy step to include default workflows in the packaged app.
Updated workflow discovery logic so the Config Browser sees both built-in examples and any custom workflow folders on first run.
Background Workflow Cancellation Not Logged
Fixed issue where stopping a background job removed it from Background Jobs but never wrote an Execution History entry.
Replaced a bad call to logger.complete() (non-existent) with logger.saveSummary() in /stop-background-job, so cancelled runs now produce summaries and show up in History.
Added explicit “Workflow cancelled by user” warning log and ensured cancellation no longer throws runtime errors.
stopOnError Checkbox Ignored by Background Runs
Fixed bug where the “Stop workflow when nodes fail without error-handling path” toggle only affected foreground runs; background and scheduled workflows always behaved as if stopOnError were enabled.
Root causes:
- Electron wrote settings to a different path than server.js read (app.getPath('userData') vs ~/.workflow-dashboard), so background runs never saw updated values.
- SettingsModal’s in-memory config object was not updated when the checkbox changed, so a later “Save Settings” action could silently overwrite stopOnError back to its previous value.
Fixes:
- Updated electron.js to use the same config path as server.js (~/.workflow-dashboard/config/settings.json).
- Updated handleToggleStopOnError in SettingsModal.js to build an updatedConfig object, call setConfig(updatedConfig), and persist that object via electronAPI.saveConfig(updatedConfig).
Verified via logs that background jobs now receive and log stopOnError FINAL VALUE: false when the box is unchecked and that workflows continue past failing nodes without error edges.

Added – Live Logs for Background Jobs

View Live Logs from Settings → Background Jobs
Added “View Live Logs” button next to each background job.
Clicking opens the Execution History details view for that job and starts polling live log summaries every few seconds while it’s running.
Uses existing WorkflowLogger summaries so users see node-by-node updates and log output in near real time.
New Backend Endpoint for Live Summaries
Introduced GET /background-jobs/:jobId/logs to expose in-memory log snapshots for running jobs, with a fallback to execution-<jobId>.json on disk when available.
API helper getBackgroundJobLogs(jobId) wires the React UI to this endpoint.

Impact:
– Startup behavior now matches the settings toggle more reliably and avoids ghost startups.
– Fresh installs always ship with a curated set of example workflows visible in the Config Browser.
– Cancelled background jobs are fully auditable in Execution History.
– Long-running background jobs are much easier to monitor via live logs without waiting for completion.

[0.3.9] – 2025-12-21

Added – Workflow Cancellation & Two-Stage Reset

Workflow Cancellation Mechanism: Stop running workflows with proper cleanup
Cancellation Flag: workflowCancelledRef tracks cancellation across async operations
Timeout Tracking: activeTimeoutsRef maintains array of all active setTimeout IDs
Early Exit Checks: executeNode() checks cancellation before execution
Wait Node Interruption: setTimeout callbacks check cancellation before resolving
Recursive Halt: followWorkflowExecution() stops traversal on cancellation
Logger Completion: Cancelled workflows logged with “stopped by user” status
Two-Stage Reset Button: “Reset Run” provides safe, progressive workflow stopping
Stage 1 – Stop Execution (First Click):
- Sets workflowCancelledRef.current = true
- Clears all active timeouts: activeTimeoutsRef.current.forEach(id => clearTimeout(id))
- Does NOT complete logger or send email – leaves logger active for “Finish & Report”
- Keeps node statuses and outputs visible for review
- Button changes to “🧹 Clear Visuals” (amber #f59e0b, pulsing animation)
- Sets workflowStopped state to true
Stage 2 – Clear Visuals (Second Click):
- Resets all node statuses to ‘idle’
- Clears all node outputs
- Removes edge animations and custom colors
- Silently abandons logger without completion (no email sent)
- Resets workflowStopped to false
- Button returns to “🔄 Reset Run” (red #ef4444)
Finish & Report Button: Independent workflow completion with intelligent status detection
Stops workflow execution (sets cancellation flag, clears timeouts)
Detects interrupted workflows: Reports as FAILED if any nodes weren’t executed
Status Logic:
- Interrupted + Errors: FAILED – “Workflow interrupted by user with errors (X nodes not executed)”
- Interrupted only: FAILED – “Workflow interrupted by user (X nodes not executed)”
- Completed + Errors: FAILED – “Workflow finished manually with errors”
- Completed successfully: SUCCESS – “Workflow finished manually”
Sends email notification with accurate status and node details
Keeps visuals intact for review (use “Reset Run” to clear)
Works independently at any time, including after “Reset Run” first click
Visual Feedback:
Button States: Red (ready to stop) → Amber pulsing (ready to clear) → Red (reset)
Tooltip Updates: Dynamic tooltips explain current action
Pulse Animation: CSS keyframes create gentle opacity pulse on amber state

Changed

Workflow Execution Controls: Improved layout and text overflow handling
Container width increased: 160px → 180-220px for better text accommodation
All buttons now have: whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis'
Running status indicator redesigned:
- Separate “RUNNING” label (10px, uppercase, #7cb342)
- Node title display with 2-line clamp and ellipsis
- Border added for better visibility (#c5e1a5)
- Compact layout (11px font, proper padding)
Cancellation Flag Management: Reset in all workflow start functions
executeFullWorkflow(): Sets workflowCancelledRef.current = false
runWorkflowFromNode(): Resets flag for partial runs
continueWorkflowExecution(): Allows resumption after previous cancellation
setWorkflowStopped(false): Clears visual state flag on new run

Fixed

Text Overflow: Workflow control buttons no longer overflow container bounds
Running Status Display: “Running: [node]” text properly contained within box
Button Sizing: All buttons consistent size prevents layout shifts
Visual Consistency: All workflow control buttons follow same styling patterns

Technical Details

Cancellation Check Pattern:
javascript // In executeNode() if (workflowCancelledRef.current) { console.log(`[executeNode] Workflow cancelled, skipping node ${nodeId}`); return Promise.resolve(); }
Timeout Cleanup:
javascript // In resetWorkflowState() first click activeTimeoutsRef.current.forEach(timeoutId => clearTimeout(timeoutId)); activeTimeoutsRef.current = [];
Wait Node Tracking:
javascript const timeoutId = setTimeout(() => { activeTimeoutsRef.current = activeTimeoutsRef.current.filter(id => id !== timeoutId); if (workflowCancelledRef.current) { updateNodeStatus('idle', 'Cancelled'); resolve(); return; } // Continue normal execution }, ms); activeTimeoutsRef.current.push(timeoutId);
Two-Stage State Management:
“`javascript
const [workflowStopped, setWorkflowStopped] = useState(false);

// First click: Stop but don’t clear
if (isRunningFullWorkflow || !workflowStopped) {
workflowCancelledRef.current = true;
// Clear timeouts, complete logger
setWorkflowStopped(true);
return; // Exit early
}

// Second click: Clear visuals
setNodes(/ reset to idle /);
setEdges(/ remove animations /);
setWorkflowStopped(false);
“`

Impact

Reliability: Commands and wait nodes properly interrupted instead of running to completion
User Control: Clear visual feedback on workflow state (running/stopped/cleared)
Data Safety: Two-stage prevents accidental loss of execution results
Debugging: Stopped workflows preserve state for inspection before clearing
Professional UX: Smooth transitions between states with visual cues

Use Cases

Development: Stop test runs immediately when errors appear
Long Waits: Cancel 30-minute wait nodes without waiting for completion
Review Results: Stop workflow, review outputs, clear when ready
Error Recovery: Stop failed workflows without losing diagnostic information

Session Statistics (December 21, 2025)

Duration: ~6 hours (planning, implementation, testing, documentation)
Features Added: 2 (Workflow Cancellation, Two-Stage Reset)
Files Modified: 2 (src/App.js, src/App.css)
Lines of Code: ~150 new, ~80 modified
New State Variables: 2 (workflowCancelledRef, activeTimeoutsRef, workflowStopped)
CSS Animations: 1 (pulse keyframes for amber button state)

[0.3.8] – 2025-12-20

Added – Partial Workflow Execution & UX Improvements

Run from Selected Node: Start workflow execution from any selected node
Selection-Based: Click any node (or Shift+click) to select it for partial runs
New Button: “▶ Run from Selected” in Workflow Execution Controls panel
Live Preview: Shows selected node title in button and helper text below
Smart Enabling: Only enabled when exactly 1 node selected, no run in progress
Full Integration: Uses existing execution engine, retry, logging, email notifications
Selection Tracking: Independent of Edit Mode – works during normal operation
Session-Based Refresh Enhancement: Ctrl+R now reloads active workflow
Smart Reload: Refreshing (Ctrl+R) reloads the currently active workflow, not always the default
Session Persistence: Uses sessionStorage to remember active workflow across refreshes
Default Protection: Never modifies the actual default workflow setting
Dynamic Default Check: Correctly determines isDefaultWorkflow by comparing paths
Session Cleanup: Full app closure clears session and returns to default workflow
New Workflow Reset: Starting a blank workflow clears session memory
Load Default Button: Quick access to reload configured default workflow
Location: Edit Mode toolbar, between “Load Draft” and “📄 New”
Color: Green (#10b981) to match “Add Block” button
Electron Only: Only visible in desktop app where default configs exist
Full Reset: Replaces current canvas with default workflow
Success Notification: Shows toast with loaded workflow name

Changed

Uniform Button Sizes: All Edit Mode toolbar buttons now use consistent sizing
Padding: 4px 8px (previously mixed 4px/6px padding)
Font Size: 13px (previously Settings button was 14px)
Visual Consistency: Cleaner, more professional toolbar appearance
ReactFlow Selection Handler: Added onSelectionChange callback
Tracks single-node selection for “Run from Selected” feature
Independent of Edit Mode selection behavior
Updates selectedRunNodeId state for execution control
Initial Workflow Load: Enhanced to check session storage first
Priority: Session storage → Default workflow → Nothing
Properly saves active workflow path to session on import/load
Maintains backward compatibility with existing default workflow logic

Technical Details

runWorkflowFromNode(startNodeId): New function in App.js
Resets all node statuses to idle
Resets edge animations
Creates new workflow logger job
Executes selected node then calls followWorkflowExecution([startNodeId])
Reuses all existing logic: retry, error handling, condition nodes, etc.
handleSelectionChange(params): New callback in App.js
Receives ReactFlow selection change events
Sets selectedRunNodeId if exactly 1 node selected, else null
Updates UI button enable/disable state and helper text
sessionStorage Integration:
Key: 'lastActiveWorkflowPath'
Set on: Config import, default workflow load
Read on: App mount (before falling back to default)
Cleared on: New blank workflow creation, full app closure
Never modifies actual default workflow config in Electron settings

Impact

Workflow Development: Test specific branches without running entire workflow
Debugging: Start from problem node to isolate issues
Efficiency: Skip already-completed steps when resuming work
Refresh Behavior: Natural refresh that preserves user intent
Visual Polish: More professional, consistent UI appearance

[0.3.7] – 2025-12-20

Added – Automatic Retry on Failure

Node-Level Retry Configuration: Individual nodes can now automatically retry on failure
Enable Retry Checkbox: Toggle retry functionality per node in Block Edit Form
Max Attempts (1-10): Configure how many times to retry before giving up (default: 3)
Initial Delay (ms): Set delay before first retry in milliseconds (default: 1000ms)
Backoff Strategy Dropdown: Choose retry delay growth pattern:
- Fixed: Same delay each time (e.g., 1s, 1s, 1s)
- Linear: Delay increases linearly (e.g., 1s, 2s, 3s)
- Exponential: Delay doubles each time (e.g., 1s, 2s, 4s, 8s) [Recommended]
Visual Retry Indicators:
Badge Display: Nodes with retry enabled show “↻ 3x” badge (showing max attempts)
Tooltip Info: Hover over badge shows full configuration (attempts, delay, strategy)
Amber Color Scheme: Badge uses amber/yellow (#f59e0b) to stand out from status colors
Retry Execution Logic:
Foreground Workflows: Retry loop in App.js executeNode() function
Background Workflows: Retry loop in workflowRunner.js executeScriptNode() function
Logging: Each retry attempt logged to workflow logger with attempt number and delay
Warning Level: Retry attempts logged as ‘warning’ level (yellow in email)
Attempt Tracking: Final result includes actual retry attempts made
Email Notification Enhancements:
Retry Badge in Node Status: Email shows “↻ X attempts” badge for nodes that retried
Amber Badge Styling: Matches canvas badge appearance (#fef3c7 background, #92400e text)
Retry History in Logs: Detailed logs section shows each retry attempt with:
- Attempt number (e.g., “Retry attempt 2/3”)
- Delay before next retry
- Backoff strategy used
- Error that triggered retry
Retry Helper Utilities (new file: src/utils/retryHelper.js):
calculateDelay(attempt, initialDelay, backoff) – Implements backoff strategies
sleep(ms) – Promise-based delay function
executeWithRetry(fn, options) – Generic retry wrapper (for future use)

Changed

BlockEditForm: Added retry configuration section after interactive mode checkbox
Collapsible panel with light gray background (#f9fafb)
Input validation: attempts clamped to 1-10, delay minimum 100ms
Live preview of delay sequence based on strategy selection
CustomNode Header: Retry badge positioned between title and folder icon
Node Data Structure: Added 4 new properties:
retryEnabled (boolean)
retryAttempts (number, 1-10)
retryDelayMs (number, minimum 100)
retryBackoff (string: ‘fixed’, ‘linear’, ‘exponential’)
actualRetryAttempts (number, set after execution, used in emails)
updateNodeStatus Function: Now accepts optional retryAttempts parameter
Stores actual retry count in node.data.actualRetryAttempts
Includes retry attempts in workflow logger event metadata

Technical Details

Retry Algorithm:
“`javascript
for (let attempt = 1; attempt <= maxAttempts; attempt++) {
result = await executeCommand(…);
if (result.success) break; // Success – exit loop

if (attempt < maxAttempts) {
const delay = calculateDelay(attempt, retryDelay, retryBackoff);
await sleep(delay);
// Log retry attempt
}
}
“`
Backoff Formulas:
Fixed: delay = initialDelay
Linear: delay = initialDelay * attempt
Exponential: delay = initialDelay * 2^(attempt - 1)
Integration Points:
Foreground: App.js lines 1560-1660 (retry loop wraps executeCommand)
Background: workflowRunner.js lines 158-230 (retry loop wraps exec)
Email: emailService.js lines 356-373 (retry badge in node status)
UI: App.js lines 4000-4010 (retry form fields)
Visual: CustomNode.js lines 230-245 (retry badge in header)

Impact

Reliability: Automatic recovery from transient failures (network glitches, temporary locks, etc.)
Success Rate: Expected 60-80% reduction in false failures for network/IO operations
User Experience: “Set it and forget it” – no manual re-runs for transient errors
Debugging: Retry logs provide clear history of what was attempted

Example Use Cases

API Calls: Retry network requests that fail due to temporary connectivity issues
File Operations: Retry file writes that fail due to temporary locks or permissions
Database Operations: Retry queries that fail due to connection pool exhaustion
External Commands: Retry scripts that depend on external services starting up

[0.3.6] – 2025-12-20

Added – Smart Error Handling & Workflow Reliability

Edge-Based Error Handling: Workflows now intelligently handle failures based on edge connections
Failed nodes check for error-handling edges (labeled “error” or “fail”)
If error edge exists → follows error recovery path
If NO error edge exists → stops workflow execution (prevents bad data propagation)
Works with both foreground (UI) and background workflows
Stop-on-Error Toggle: User-configurable error propagation behavior
Located in Settings → Gmail Integration → Workflow Error Handling
When ENABLED (default): Stops workflow when node fails without error-handling path
When DISABLED: Continues workflow execution after errors (legacy behavior)
Persists to localStorage and Electron config
Console logging shows decision-making for debugging
Email Notification Enhancements:
Execution Order Display: Nodes now appear in actual execution order (not canvas order)
Execution Path Highlighting: Executed nodes have light green background (#f0fdf4) on canvas
Prominent Error Messages: Error details displayed in red boxes directly under failed nodes
Stale Status Prevention: Node statuses reset at workflow start, non-executed nodes forced to ‘idle’
Interactive Script Detection:
Enhanced error logging for exit code null (timeout/killed processes)
Special error message: “Command timed out or was killed (possibly waiting for user input)”
Comprehensive troubleshooting guide in README for interactive scripts

Changed

Node Status Tracking: executedNodesRef now maintains execution order for accurate email reporting
CustomNode Visual Feedback: Green background indicator for executed nodes during workflow runs
WorkflowRunner Constructor: Added stopOnError parameter (defaults to true)
Error Logging: Extensive console logging for error-handling decisions

Fixed

Email Node Ordering: Nodes in email notifications now show in execution order instead of random canvas order
Stale Node Statuses: Previous workflow run statuses no longer appear in new workflow emails
Ghost Success/Errors: Non-executed nodes no longer incorrectly show success/error from previous runs
Error Message Visibility: Error messages no longer buried in detailed logs section

Technical Details

Error Edge Detection Logic:
“`javascript
// Check for error-handling edges
const errorEdges = outgoingEdges.filter(edge => {
const label = (edge.label || ”).toLowerCase().trim();
return label.includes(‘error’) || label.includes(‘fail’);
});

if (errorEdges.length > 0) {
// Follow error recovery path
} else if (stopOnError) {
// STOP workflow execution
} else {
// Continue (legacy behavior)
}
“`

Execution Tracking:
executedNodesRef.current array maintains chronological execution order
isExecuted prop passed to CustomNode for visual highlighting
Email sorting: nodeStatuses.sort((a, b) => executedIndex[a.id] - executedIndex[b.id])
Configuration Storage:
Setting saved to: localStorage.stopOnError (boolean)
Also saved to: electronConfig.stopOnError for background workflows
Synced when Settings modal closes

Documentation

README.md: Added “Interactive Scripts & Exit Code Null” troubleshooting section
Problem identification and root causes
4 solution approaches with code examples
Detection tips and best practices
Examples for Python, Node.js, and Batch scripts
ERROR-HANDLING-ENHANCEMENTS-PLAN.md: NEW – Planning document for future enhancements
Retry functionality on error edges (automatic transient failure recovery)
Toast notifications for workflow events (real-time UI feedback)
Estimated effort: 3.25 days (1 work week)

[0.3.5] – 2025-12-19

Added – Workflow Scheduler (Phase 1)

Cron-Based Scheduling: Schedule workflows to run automatically using cron expressions
UI-managed scheduling in Settings → Scheduler tab
Human-readable cron descriptions powered by cronstrue
Preset options: hourly, daily, weekly, weekdays, monthly
Custom cron expression input with format help
Schedule labels for easy identification

— Scheduler Backend:
– node-cron 3.0.3 for cron job management
– cronstrue 2.50.0 for human-readable descriptions
– 3 Express endpoints: POST /schedule-workflow, POST /unschedule-workflow, GET /scheduled-workflows
– Disk-backed persistence of schedules in ~/.workflow-dashboard/config/schedules.json
– Automatic restoration of schedules on server startup (dev and production)
– Persistent storage in Electron config (scheduledWorkflows array)
– Automatic schedule restoration on app startup
– Timezone: America/New_York (configurable in future)

Scheduler UI (Settings Modal):
Active Schedules List: Shows all scheduled workflows with:
- Schedule label (custom name)
- Workflow name (from config path)
- Cron expression (e.g., “0 * * * *”)
- Human-readable description (e.g., “At minute 0 past every hour”)
- Created timestamp
- Remove button with confirmation
Add New Schedule Form:
- Workflow selector modal using ConfigFileSelector component
- Respects customWorkflowFolders configuration
- Same UX as Import Configuration for consistency
- Schedule presets dropdown with 6 options
- Custom cron expression input for advanced users
- Label input for naming schedules
Tab Badge: Shows active schedule count on Scheduler tab
Integration with Existing Features:
Scheduled workflows appear in Background Jobs tab during execution
Execution logs saved to Execution History
Email notifications sent if configured
Uses same /run-background endpoint as manual background execution

Changed

SettingsModal Dimensions: Expanded modal from 700px × 85vh to 920px × 90vh to accommodate 9 tabs
Tab Navigation: Added Scheduler tab between Background Jobs and Ports
Workflow Selection Pattern: Scheduler reuses ConfigFileSelector component (no code duplication)

Technical Details

Cron Expression Presets:
javascript hourly: '0 * * * *', // Every hour at minute 0 daily: '0 0 * * *', // Daily at midnight weekly: '0 0 * * 0', // Weekly on Sunday weekdays: '0 9 * * 1-5', // Weekdays at 9 AM monthly: '0 0 1 * *' // Monthly on the 1st
Schedule Metadata:
javascript { id: 'crypto-random-id', configPath: 'E:/path/to/workflow.js', configName: 'workflow', cronExpression: '0 9 * * 1-5', cronDescription: 'At 09:00 on every day-of-week from Monday through Friday', label: 'Morning data sync', createdAt: '2025-12-19T14:30:00.000Z' }
Startup Recovery Flow:
Electron app starts, loads config from settings.json
Server.js starts, receives scheduledWorkflows via IPC
restoreScheduledWorkflows() iterates saved schedules
Each schedule recreates cron.schedule() job
Jobs persist in server memory until app closes
State Management (Frontend):
scheduledWorkflows: Array of active schedules
schedulesLoading: Boolean for async operations
selectedWorkflowPath: String for workflow file path
selectedWorkflowName: String for display name
selectedPreset: String for preset dropdown
customCron: String for custom expression input
scheduleLabel: String for custom label
showWorkflowSelector: Boolean for modal visibility

Limitations & Future Enhancements

Desktop App Only: Requires app to be running for schedules to execute
Timezone: Currently hardcoded to “America/New_York” (future: user-selectable)
No Next Run Time: UI doesn’t show when schedule will next trigger (future enhancement)
No Edit Schedules: Must remove and recreate to modify (future: edit functionality)
No Schedule History: Doesn’t track past executions separately (use Execution History)

Session Statistics (December 19, 2025)

Duration: ~6-7 hours (planning, implementation, UX redesign, testing)
Features Added: 1 major (Scheduler with 5 sub-features)
Files Modified: 4 (SettingsModal.js/css, apiService.js, server.js)
Files Created: 0 (enhanced existing infrastructure)
Lines of Code: ~400 new, ~50 modified
New API Endpoints: 3 (/schedule-workflow, /unschedule-workflow, /scheduled-workflows)
State Variables: 8 new in SettingsModal component
CSS Classes: 15+ new for scheduler UI styling

[0.3.4] – 2025-12-19

Fixed – Windows Startup Integration

Windows Startup Shortcut Method: Replaced app.setLoginItemSettings() with PowerShell COM-based shortcut creation
Issue: Registry-based approach triggered “Open with” dialog on Windows boot
Solution: Creates proper Windows shortcut in Startup folder using WScript.Shell
Benefits: Native Windows behavior, no dialogs, reliable startup
Implementation: electron.js IPC handler set-startup now uses PowerShell to create/remove .lnk files
Hidden Start: Properly passes --hidden argument to shortcut for background startup
Cross-compatibility: Maintains backward compatibility with existing installations

[0.3.3] – 2025-12-18/19

Added – Import Configuration Overhaul, Market Analysis, Discovery Tools & Quick Add Phase 3

Visual Import Preview: “Try before you buy” experience for loading workflows
Mini Canvas: Real-time ReactFlow preview of the selected configuration file
Smart Zoom: Auto-fits workflow to preview window (padding: 0.25, zoom: 0.15-0.5)
Metadata Cards: 3-column grid showing:
- Total Nodes & Connections
- Breakdown by type (Scripts, Conditions, Notes, Wait)
- Badges for “Interactive” and “Email Enabled” workflows
Node List: Collapsible, grouped list of all nodes in the config
Enhanced Import Safety & Modes:
Append Mode: New option to merge imported workflow with current canvas
- Automatically positions new nodes to the right of existing ones (maxX + 400px)
- Pre-selects imported nodes for easy group repositioning
Replace Mode: Classic behavior with new safety rails
- Confirmation Dialog: Warns if unsaved changes or existing nodes will be lost
- “Current Canvas” card shows what will be replaced vs kept
UX Refinements:
Modal Redesign: Expanded to 1400px width with glassmorphism effects (backdrop-filter)
Active Workflow Tracking: “Current Canvas” card displays active workflow name
Visual Hierarchy: Clear distinction between “Config Selector”, “Preview”, and “Action” areas
Search & Discovery (Phase 2 – Initial):
Config Search Bar: Live filter by filename and full path in the left-hand browser
Sort Options: Toggle between Recent first, Name A–Z, and Name Z–A
Category-Aware Filtering: Search applies before folder grouping for easier drilling into large libraries
Documentation:
Market Analysis: Created docs/MARKET-ANALYSIS.md defining ICP (SysAdmins/DevOps) and positioning
Product Naming: Established “ScriptFlow” as primary candidate (internal ref)
Quick Add Phase 3 – Advanced Node Creation:
Drag & Drop to Canvas: Drop folders and files (e.g., Python/Node scripts) from File Explorer directly onto the ReactFlow canvas to auto-create nodes.
Recursive Script Scanning: Optional depth-limited traversal (maxDepth 3, maxScripts 50) for dropped folders to discover scripts in subdirectories while skipping heavy folders like node_modules, .git, and virtual envs.
Project Template Detection (Metadata): Lightweight heuristics in electron.js analyzePath() to flag Node.js (package.json / node_modules), Python (pyproject.toml / requirements.txt / venv), and Git repos (.git), exposed as projectType and projectMarkers for future UI use.
Shared Analysis Pipeline: New generic IPC analyze-paths-for-nodes plus electronAPI.analyzePathsForNodes() so Quick Add, drag-and-drop, and future features reuse the same path-analysis logic without duplication.

Changed

ImportConfigSelector Component: Complete rewrite
Transformed from simple list to split-pane dashboard
Added useMemo hooks for expensive preview calculations
Integrated ReactFlow instance within the modal
App State Management:
Added activeConfigName prop drilling to Import modal
Updated handleConfigImport to support append mode logic
Improved node positioning algorithm for merged workflows

Technical Details

Preview Implementation:
javascript // Isolated ReactFlow instance with locked controls <ReactFlow nodes={previewNodes} edges={previewEdges} nodesDraggable={false} fitView fitViewOptions={{ padding: 0.25, maxZoom: 0.5 }} />
Append Logic:
javascript // Calculate offset based on existing nodes const maxX = Math.max(...existingNodes.map(n => n.position.x)) + 400; const offsetNodes = newNodes.map(node => ({ ...node, position: { x: node.position.x + maxX, y: node.position.y }, selected: true // Auto-select for drag }));

Session Statistics (December 18-19, 2025)

Focus: Import UX Overhaul + Phase 2 Discovery + Quick Add Phase 3
Files Modified: ImportConfigSelector.js/css, App.js, ConfigFileSelector.js/css, electron.js, preload.js
New Features: Visual Preview, Append Mode, Safety Dialogs, Config Search & Sort, Drag & Drop Node Creation, Recursive Script Scanning, Project Template Metadata
Documentation: Market Analysis and Quick Add docs updated

[0.3.2] – 2025-12-08

Fixed – Critical Condition Routing & UX Improvements

Phantom Edge Protection: Backend now filters orphaned edges pointing to deleted nodes
Root cause: When condition nodes are deleted in UI, their edges persist in config
Symptom: Multiple execution paths triggered simultaneously
Solution: Added validation in workflowRunner.js followWorkflow()
Filters nextNodeIds to exclude non-existent node targets
Logs warning: Skipping non-existent node [id] (orphaned edge)
Prevents workflow routing errors from stale configuration data
Condition Logic Type Handling: Fixed else-if chain causing fallthrough
Issue: Status-based conditions executed when logicType was undefined
Changed from else if (parentStatus) to else { if (parentStatus) }
Ensures time-window and day-check logic don’t fall through to status logic
Both frontend (App.js) and backend (workflowRunner.js) updated
Temporal Dead Zone Error: Fixed logicType variable initialization crash
Error: ReferenceError: Cannot access 'logicType' before initialization
Cause: Logger referenced variable before const logicType = ... declaration
Solution: Moved variable declaration above logger call in workflowRunner.js
Classic JavaScript TDZ issue with const/let variables
Port Mismatch in Frontend Execution: Fixed “Failed to Fetch” errors
Issue: Frontend hardcoded port 3501, but dev mode uses different ports
Solution: Updated App.js to use apiService.js functions exclusively
executeCommand() and executeInteractiveCommand() auto-detect correct port
Handles both Electron (3501) and browser dev mode (dynamic port)
Missing Wait-Until-Time Frontend Logic: Implemented time-based pausing
Frontend execution previously skipped wait-until-time nodes
Added calculation and setTimeout logic matching backend implementation
Displays countdown: “Waiting until 19:00 (2h 15m 30s)…”
Updates node status on completion: “Reached target time 19:00”

Added

Double-Click Node Editing: Quick access to Edit Block modal
Double-clicking any node opens edit form directly
Automatically enters edit mode if not already active
Alternative to selecting node then clicking “Edit Block” button
Implemented via onNodeDoubleClick handler in ReactFlow
Finish & Report Button: Manual workflow completion without errors
New button in workflow controls (appears during execution)
Generates execution report even when workflow incomplete
Marks workflow as completed with current node statuses
Useful for workflows with human-in-the-loop steps
Logs final status and completes workflow logger job
Enhanced Backend Logging: Detailed condition routing diagnostics
followWorkflow() logs completed nodes with titles
Each node logs outgoing edge count and targets
Status-based routing logs all edge labels and matching logic
“Next nodes to execute” summary before batch execution
Helps debug complex conditional workflows

Changed

Condition Evaluation Logic: Stricter parent status requirements
When parent status missing for status-based condition: stop branch
Previous: Logged warning but continued with all paths
New: Sets candidateEdges = [] to halt execution
Prevents ambiguous routing when parent node has no status
Frontend Execution Methods: Unified API service usage
Removed direct fetch() calls from App.js
All commands now route through apiService.js
Centralizes port detection and error handling
Consistent behavior between foreground and background execution

Technical Details

Phantom Edge Detection:
javascript // In workflowRunner.js followWorkflow() nextNodeIds = [...new Set(nextNodeIds)] .filter(id => !this.executedNodes.has(id)) .filter(id => { const nodeExists = this.nodes.find(n => n.id === id); if (!nodeExists) { this.logger.warn(`Skipping non-existent node ${id} (orphaned edge)`); return false; } return true; });
Condition Logic Restructure:
javascript // Before: else if (parentStatus && outgoingEdges.length > 0) // After: else { if (parentStatus && outgoingEdges.length > 0) { // Status-based logic only executes in final else block } else if (!parentStatus) { candidateEdges = []; // Stop branch } }
Double-Click Handler:
javascript const handleNodeDoubleClick = useCallback((event, node) => { if (!editMode) setEditMode(true); setSelectedNode(node); setShowEditForm(true); }, [editMode]);

Debugging Session Insights

Orphaned Edges Diagnosis: Phantom edges most likely created when:
User creates condition node with outgoing edges
User deletes/recreates condition node (new ID generated)
Old edges remain in config pointing to deleted node ID
Save operation preserves orphaned edges
Prevention Strategy: Future enhancement could validate on save:
Check all edge targets exist in blocks array
Warn or auto-remove orphaned edges
Add “Clean Config” button to remove stale references
Testing Orphaned Edges: Can simulate by:
Create workflow with condition node
Manually edit config file to add edges to non-existent node
Run workflow and verify warning appears
Confirm only valid paths execute

Session Statistics (December 8, 2025)

Duration: ~4 hours debugging and implementation
Critical Bugs Fixed: 5 (phantom edges, condition logic, TDZ, port mismatch, wait-time)
UX Improvements: 2 (double-click edit, finish & report)
Files Modified: 3 (App.js, workflowRunner.js, apiService.js)
Lines of Code: ~100 new, ~80 modified
Debug Log Additions: ~50 lines of diagnostic logging

[0.3.1] – 2025-12-07

Fixed – Execution History & Email Notifications

Execution History Workflow Names: Fixed “Unnamed Workflow” appearing in logs
Root cause: activeConfigName state not set when importing workflows
Solution: Enhanced executeFullWorkflow() with fallback logic
Now extracts filename from activeConfigPath if activeConfigName is empty
Format: filePath.split('/').pop().split('\\').pop().replace(/\.(js|json)$/, '')
Example: E:\path\to\my-workflow.js → my-workflow
Execution History now displays actual workflow filenames instead of generic placeholder
Detailed Email Notifications: Complete execution reports matching UI
Enhanced HTML Email Template:
- Colored status header: Green (✅ Success) / Red (❌ Failed)
- Execution Summary: Total logs, error count, warning count, success count
- Node Status List: Visual list with icons (✓/✗) showing each node’s final state
- Detailed Logs Section: Full timestamped log dump with command outputs
- Clean, responsive design matching workflow execution UI
Backend Data Flow Updates:
- server.js /complete-workflow-logger: Extracts nodeStatuses from logs
- Passes full log array and execution summary to email service
- emailService.js sendWorkflowNotification(): Complete rewrite
- Generates rich HTML with embedded CSS styling
- Text fallback version for non-HTML email clients
Frontend Logging Enhancement:
- App.js followWorkflowExecution(): Logs final node statuses before completion
- Ensures email service has access to full workflow state
- Final log event includes: nodeStatuses: [{ id, title, status }]
Email Content Details:
- Job ID, start time, end time, duration
- Per-node status with visual indicators
- Complete command execution logs with stdout/stderr
- Error details highlighted in red boxes
- Scrollable log section (max-height: 800px)

Changed

Logger Fallback Logic: executeFullWorkflow() now prioritizes data sources:
activeConfigName (state variable)
Extracted from activeConfigPath (filesystem path)
Fallback to “Unnamed Workflow” (last resort)
Email Service Parameters: sendWorkflowNotification() signature expanded
Added: logs (array), executionSummary (object), nodeStatuses (array)
Backward compatible: All new parameters optional with defaults

Technical Details

State Management Issue:
activeConfigName initialized as 'Default Configuration' in useState
handleConfigImport() correctly sets name, but React batching can delay update
Fallback ensures logger always receives valid name even if state update pending
Email Generation:
javascript // Node status rendering in HTML const nodesHtml = nodeStatuses.map(node => { const color = node.status === 'success' ? '#059669' : node.status === 'error' ? '#dc2626' : '#6b7280'; const icon = node.status === 'success' ? '✓' : node.status === 'error' ? '✗' : '•'; return `<div>${icon} ${node.id} — ${node.title || '(No title)'} → ${node.status}</div>`; }).join('');
Debug Logging: Added console.log statements for troubleshooting
DEBUG handleConfigImport: Setting activeConfigName to: [name]
DEBUG: Creating logger with config name: [name]
Can be removed after verification

Verification Steps

Import workflow via Config Selector
Execute workflow (full run)
Check Settings → Execution History
Verify workflow filename appears (not “Unnamed Workflow”)
If email configured, verify detailed report received

Session Statistics (December 7, 2025)

Duration: ~3 hours debugging and implementation
Issues Fixed: 2 (unnamed workflow, basic email formatting)
Files Modified: 3 (App.js, server.js, emailService.js)
Lines of Code: ~150 modified, ~250 new (email templates)
Debug Messages: 2 (temporary, for verification)

[0.3.0] – 2025-12-05/06

Added – Time-Based Scheduling & System Tray Integration

Wait Until Time Node: New node type for absolute time-based scheduling
Pauses workflow execution until specific clock time (e.g., 09:00, 17:00)
Automatically schedules for next day if target time already passed
Different from Wait/Delay node (duration-based) – complementary features
Visual display shows ⏰ Wait Until | 09:00 on node
Input: 24-hour time picker in edit form
Background Job Tracking System: Full visibility into running workflows
Server-side Map tracks all background jobs with metadata
Job tracking includes: jobId, configPath, configName, startTime, endTime, status, error
Auto-cleanup: Jobs removed 5 minutes after completion/failure
New API endpoints:
- GET /background-jobs – Returns array of all tracked jobs
- POST /stop-background-job – Emergency stop for runaway workflows
Background Jobs tab in Settings modal shows:
- Real-time status updates (auto-refresh every 3 seconds)
- Job name, ID, status badge (running/completed/failed/stopped)
- Start time, end time, duration counter
- Error messages for failed jobs
- Stop button for running workflows
System Tray Integration: 24/7 background operation
Tray icon appears in Windows system tray (near clock)
Minimize to tray: Clicking X hides window instead of closing app
First-time notification explains tray behavior
Background workflows continue running while minimized
Tray context menu (right-click):
- Show/Hide Window – Toggle window visibility
- Running Jobs: X – Shows count of active workflows
- Open Background Jobs – Quick access to monitoring
- Quit – Fully exit app and stop all workflows
Double-click tray icon to show/hide window
Dynamic menu updates with running job count every 3 seconds
Windows Startup Integration: Auto-start with Windows
Settings → System → “Start with Windows” checkbox
Uses Windows login items (registry integration)
When enabled with “Minimize to tray”, app starts hidden
Perfect for 24/7 automated workflow execution
IPC handler set-startup configures Windows auto-start
Enhanced UI Feedback:
“Run in Background” button now shows success alert with Job ID
Alert directs users to Settings → Background Jobs to monitor
System tab added to Settings modal (6 tabs total now)
Helpful tips for 24/7 workflow automation setup
Example Workflow Files: Fixed format issues
All 4 example files converted to ES6 export const format
Added required interactive and links fields to all blocks
Files now pass validation and import successfully:
- example-business-hours-workflow.js
- example-weekday-weekend-workflow.js
- example-error-handling-workflow.js
- example-complex-multi-condition-workflow.js

Fixed

Condition Node Display Persistence: Condition details now survive reload
Extended getConditionInfo() in CustomNode.js to handle all condition types
Blue info box renders for both condition AND wait-until-time nodes
Info persists across page reloads (stored in node data, not modal state)
Examples:
- Time window: ⏰ Time Window | 09:00 - 17:00 | Routes based on current time
- Day check: 📅 Day Check | Mon, Tue, Wed, Thu, Fri | Routes based on day of week
- Wait until: ⏰ Wait Until | 09:00 | Pauses until specified time
Custom Folder Save Permissions: Fixed “cannot save outside project” error
saveConfigFile() in apiService.js now fetches customWorkflowFolders from Electron config
Passes custom folders array to server in save request
Server validates paths against both built-in and custom folder lists
Users can now save to folders added via Settings → Workflow Folders

Changed

Settings Modal Structure: Expanded from 5 to 6 tabs
Editors, Folders, Default, Background Jobs, Ports, System (NEW)
System tab includes:
- Minimize to system tray toggle (default: enabled)
- Start with Windows toggle
- Helpful tips for 24/7 automation setup
Electron Configuration: Added tray and startup support
New config fields: minimizeToTray (default: true), startWithWindows (default: false)
Imports: Added Tray and Menu to electron.js
Global variables: tray, isQuitting for state management
Window close handler: Prevents quit when minimize to tray enabled
Preload API: Added setStartup, updateTray, onOpenBackgroundJobs
Server Background Execution: Enhanced job lifecycle
/run-background endpoint generates unique jobId (crypto.randomBytes)
Stores WorkflowRunner instance reference for emergency stops
Sets runner.isRunning = false to halt execution
WorkflowRunner checks !this.isRunning before each node execution
Job cleanup timer: setTimeout(() => runningWorkflows.delete(jobId), 5 * 60 * 1000)

Technical Details

Wait Until Time Implementation:
javascript // In workflowRunner.js (lines 83-106) const targetTime = node.data?.targetTime || '09:00'; const [targetHour, targetMinute] = targetTime.split(':').map(Number); const now = new Date(); const target = new Date(); target.setHours(targetHour, targetMinute, 0, 0); if (target <= now) target.setDate(target.getDate() + 1); // Tomorrow const waitMs = target.getTime() - now.getTime(); setTimeout(() => resolve(), waitMs);
Tray Menu Updates:
updateTrayMenu(runningJobsCount) called from SettingsModal.js
Auto-refresh every 3 seconds syncs tray with job status
“Open Background Jobs” only enabled when jobs running
Menu shows “Running Jobs: 0” vs “Running Jobs: 3”
Build Size: 131.32 kB main.js (+698 B from previous build)

Session Statistics (December 5-6, 2025)

Duration: ~8-9 hours of development and testing
Major Features: 4 (Wait Until Time, Background Job Tracking, System Tray, Windows Startup)
Bugs Fixed: 3 (example files format, condition display persistence, custom folder saves)
Files Modified: 8 (App.js, CustomNode.js, apiService.js, server.js, workflowRunner.js, SettingsModal.js, electron.js, preload.js)
Files Created: 0 (enhanced existing files)
Lines of Code: ~600 new, ~150 modified
New API Endpoints: 2 (/background-jobs, /stop-background-job)
New IPC Handlers: 3 (set-startup, update-tray, onOpenBackgroundJobs)

0.2.0 – 2025-12-04

Added – Electron Desktop App & Advanced Workflow Features

Electron Desktop Application: Full native Windows desktop app with NSIS installer
Embedded Express server (port 3501) runs as child process
System notifications for workflow completion and errors
IPC communication between main process and renderer
Health check system to verify server startup before opening window
Auto-start server with detailed logging and error handling
Background Workflow Execution: Headless workflow runner
New WorkflowRunner class in services/workflowRunner.js
“Run in Background” button executes workflows without UI
Graph walking algorithm follows edges and condition logic
Native system notifications on completion (success/error)
HTTP endpoint /run-background accepts config file path
Dual format support: config files (node.command) and React Flow (node.data.command)
Time-Based Conditions – Full UI: Visual configuration for workflow routing
Business Hours Conditions: Start/end time inputs (e.g., 09:00-17:00)
Day-of-Week Conditions: Toggle buttons for selecting specific days
Wait/Delay Nodes: Duration input with unit selector (seconds/minutes/hours)
Condition Display: Nodes show parameters at a glance:
- ⏰ Time: 09:00 - 17:00 for time windows
- 📅 Days: Mon, Tue, Wed, Thu, Fri for day checks
- ✓/✗ Status-based for traditional routing
Edge Label Hints: Guidance text for labeling condition edges
Logic Type Dropdown: Select status/time-window/day-check in edit form
UI Layout Improvements:
Workflow control buttons reorganized into 3 rows:
- Row 1: Run Full Workflow | Run in Background
- Row 2: Checklist Converter | Browse Configs
- Row 3: Reset Run
All edit mode buttons reduced in size (4px×8px padding, 13px font)
Cleaner, more compact interface with better visual hierarchy

Fixed

IPv6 Connection Issues: Changed all localhost references to 127.0.0.1
Fixed in electron.js waitForServer() function
Fixed in electron.js run-background IPC handler
Prevents “ECONNREFUSED ::1:3501” errors on IPv6-enabled systems
Electron Packaging Issues:
Fixed package.json main entry pointing to wrong file (was src/index.js, now electron.js)
Removed !node_modules exclusion from files array
Added node_modules/**/* to asarUnpack for server dependencies
Server can now find express, cors, and other runtime dependencies
108MB installer successfully includes all production dependencies
Server Dependency Issues:
Replaced dynamic import('node-fetch') with native Node.js http module
Eliminates external dependency for internal config loading
More reliable in packaged Electron environment
Config Format Compatibility:
WorkflowRunner now supports both config file format and React Flow format
Checks node.command || node.data.command for dual compatibility
Also checks workingDir, duration, logicType in both locations
Allows background execution of any workflow source
ESLint Warnings:
Added // eslint-disable-next-line no-new-func for necessary Function constructor usage
Fixed unnecessary escape character in regex: /[\\\/]/ → /[\\/]/
Clean compile with no warnings

Changed

Server Port: Standardized on port 3501 for both dev and production
Electron Main Entry: Updated package.json main to point to electron.js
Build Configuration: Added electron-builder config with custom files array and asarUnpack settings
Condition Node Display: Updated bottom text from “Routes based on previous node status” to “Routes based on edges”

Technical Details

electron-builder 24.13.3: Professional Windows packaging with NSIS
Build Config: extends: null to avoid react-cra preset conflicts
ASAR Unpacking: server.js, services/**/*, and node_modules/**/* unpacked for runtime
IPC Architecture: Main process ↔ server via process.send/on(‘message’), main ↔ renderer via ipcMain.handle/ipcRenderer.invoke
Preload Script: Exposes secure electronAPI to renderer via contextBridge

Known Issues & Solutions

Issue: Electron window doesn’t open
Solution: Verify package.json main points to electron.js, not React entry
Issue: Server fails with “ECONNREFUSED ::1:3501”
Solution: Use 127.0.0.1 instead of localhost to force IPv4
Issue: Packaged app can’t find node_modules
Solution: Include node_modules/**/* in asarUnpack, remove !node_modules from files array
Issue: Background workflow commands don’t execute
Solution: Ensure WorkflowRunner checks both node.command and node.data.command
Issue: ESLint complains about Function constructor
Solution: Add // eslint-disable-next-line no-new-func – necessary for parsing JS config files

Build Commands

# Development mode (React + Electron)
npm start                    # Start React dev server
npm run electron-dev        # Start Electron (requires React server running)

# Build for production
npm run build               # Build React app to build/ folder
npm run electron-build-win  # Package Windows installer to dist/

# Development (browser mode)
node server.js              # Start server on port 3501
# Visit http://localhost:3501

File Structure Changes

workflow-dashboard-enhance/
├── electron.js              # NEW: Electron main process
├── preload.js              # NEW: IPC bridge for renderer
├── server.js               # MODIFIED: Added /run-background endpoint
├── services/
│   └── workflowRunner.js   # NEW: Headless workflow executor
├── src/
│   ├── App.js              # MODIFIED: Added Run in Background button, time condition UI
│   ├── ConditionNode.js    # MODIFIED: Display logic type and parameters
│   └── components/
│       └── ConfigFileSelector.js  # FIXED: ESLint warnings
├── package.json            # MODIFIED: Added electron-builder, updated main
└── dist/                   # NEW: Build output directory
    ├── Workflow Dashboard Setup 0.1.0.exe  # 108MB installer
    └── win-unpacked/       # Unpacked application files

Session Statistics

Duration: ~6-7 hours of development
Major Features: 3 (Electron app, background execution, time conditions UI)
Bugs Fixed: 6 (IPv6, packaging, dependencies, config format, ESLint)
Files Modified: 8
Files Created: 3
Lines of Code: ~500 new, ~200 modified

0.1.0 – 2025-10-30

Added

Initial stable release with custom workflow folders, parameterized execution, inline script editor, quick save, default workflow selection, external editor integration, visual workflow management.
Browser Mode: Production build served by backend for use in any standard browser.
External Link Handling: http/https links open in system browser tabs.
Minimal Context Menu for editable fields (Cut / Copy / Paste / Select All).
Enhanced Zoom Range (0.1–2.5) and Node Layout (wrapped descriptions, max width).
Broad .exe command support with optional whitelist tightening.

Security

Expanded command validation to allow any first-token .exe (documented optional whitelist revert path).
External links routed to system browser to reduce nested window complexity.

Documentation

Updated main README and distribution README.txt with new feature explanations and usage notes.
Added release notes sections and executable whitelist guidance.

Planned / Future

System tray background mode.
Extended node context menu (duplicate/delete/copy ID).
Configurable zoom presets and viewport restoration.
Fine-grained executable allow-list configuration UI.