A Shortcut is the container for your automation. It has a name, an icon colour, a category, and an ordered list of Steps. Think of it like a named function — you call it, it executes its steps in sequence, and produces a final result.

An Action is a registered capability — like a function signature — defined in the Action Registry (src/actions/). Each action has a type, a set of parameters it accepts, and an outputType describing what it produces.

{
  type:       "ai-prompt",          // unique key
  title:      "AI Prompt",          // display name in the palette
  desc:       "Send a prompt…",     // shown as a tooltip
  icon:       "sparkles",           // Lucide icon name
  color:      "#FF375F",            // badge colour
  outputType: "text",               // text | image | audio | file | list | null
  defaults:   { prompt: "{{result}}", … },
  params:     [ { name, label, kind, options? } ]
}

When you add an action to a workflow, a Step is created — a copy of the action definition merged with its defaults, ready to be customised.

Every action receives and can modify a shared context object. Understanding this is the key to composing powerful pipelines.

{
  result:    string | null,   // ← output of the last step (most important)
  clipboard: string,          // ← system clipboard content at launch time
  vars:      { [name]: any }, // ← named variables (set with "Save to Variable")
  log:       string[]         // ← per-run trace log
}

Any string parameter that has acceptsVars: true in its definition supports double-brace template syntax. Before an action executes, the engine replaces placeholders with live context values.

Click the {v} button next to any parameter field to open the Variable Picker, which shows all available tokens in real time.

Every action declares an outputType. This determines how the result is rendered and what downstream actions should expect as input.

The most important variable is {{result}}. It is a single slot — like a register in a CPU. Every action that produces output overwrites it. The diagram below shows a realistic pipeline:

Notice how Save to Variable was used after step 1 — because after Firecrawl ran, result was replaced. The original URL was preserved in vars.url.

The Run Shell Command action expands {{…}} tokens before passing the command to Bash. This lets you build dynamic shell pipelines:

wc -w "{{result}}"

scp "{{vars.filePath}}" user@server:/backups/

mv /tmp/draft.txt "/home/user/notes/{{result}}.txt"

Every time a shortcut runs — whether manually or via cron — an entry is appended to the Traces view. Each trace shows:

If a cron task silently fails, check the Traces view — it will contain the error message and which step threw it.

Every action is a plain JavaScript object in one of the files under src/actions/. To add your own:

{
  type:       'my-api-call',          // unique string ID
  title:      'My API',               // shown in the palette
  desc:       'Calls My API → result', // tooltip description
  icon:       'globe',                // any Lucide icon name
  color:      '#0A84FF',              // hex accent colour
  outputType: 'text',                 // text|image|audio|file|list|json|null
  defaults: {
    url: 'https://api.infodev.ovh',
    param: '{{result}}',
  },
  params: [
    { name: 'url',   label: 'Endpoint URL', kind: 'text' },
    { name: 'param', label: 'Query param',  kind: 'text', acceptsVars: true },
  ],
}

Then register the executor in the main process (IPC handler) — the action type maps 1:1 to an IPC channel. That's the full contract.

Actions are executed in Electron's main process (Node.js environment) via IPC. The renderer sends a message and awaits the result:

const result = await window.electronAPI.runAction({
  type:    step.type,          // e.g. "shell"
  params:  resolvedParams,     // after {{var}} substitution
  context: { result, clipboard, vars }
})

ipcMain.handle('run-action', async (event, { type, params, context }) => {
  if (type === 'my-api-call') {
    const data = await fetch(params.url + '?q=' + params.param)
    return { result: await data.text() }
  }
  // … other handlers
})

Return { result: string|null }. Throw an Error to mark the step as failed — it will be caught, logged to traces, and the pipeline will halt.

Shortcuts are stored as JSON and can be exported/imported via the toolbar. The format is a self-describing array — each shortcut is fully portable across installations as long as both have the required action types registered.

[
  {
    "id": 42,
    "name": "Summarise Clipboard",
    "icon": "sparkles",
    "color": "bg-pink",
    "category": "ai",
    "favorite": false,
    "steps": [
      { "type": "clipboard-read", "title": "Read Clipboard" },
      {
        "type": "ai-prompt",
        "title": "Summarise",
        "prompt": "Summarise in 5 bullets:\n\n{{result}}",
        "systemPrompt": "You are a helpful assistant.",
        "outputFormat": "list"
      },
      { "type": "show-result", "title": "Output", "label": "Summary" }
    ]
  }
]