Celigo

Works in VS Code and Cursor (and other VS Code-based editors that install from Open VSX).

Visualize, inspect and edit Celigo integrator.io flows, APIs and tools as the Flow Builder canvas — the Flow Canvas — from the tree the Celigo CLI pulls: step components, mappings and scripts, lint findings, live errors, and push.

Pull an account with the CLI (celigo pull), open a flow's flow.json and press Cmd/Ctrl+Shift+V: the flow renders the way integrator.io's Flow Builder draws it — sources on the left, destinations and lookups to the right, branchings with their branch names, merge points, and every step's step components (filters, transformation, mapping, hooks, results/response mapping, error handling) as chips in the positions the builder shows them. Tools (tool.json) and API builders (api.json) render with their own shapes.

The graph comes from the CLI's own engine (celigo flows graph), a port of the Flow Builder's graph algorithm, so what you see here is what the product would show for the same document.

What it does

• Reads the tree, not just the file. Every step is resolved through the pulled tree's manifest: names, categories, the application behind the connection, the step components. Works with symlink and pointer trees and with celigo pull --neutral trees (bindings resolve connection names).
• Follows the editor. Unsaved edits re-render as you type; moving the caret in the JSON highlights the step it is in; double-click a step (or Go to step in flow.json in its ⋯ menu) to jump to its definition; Open export file / Open import file (named for the step's type — Open AI agent file, Open lookup file) opens the document behind it.
• Shows — and edits — the JSON. The details panel carries a JSON editor: the selected step's own object in the flow (Step), the export/import document it references from the tree (Resource), or the whole document when nothing is selected. Read-only in view mode; in Edit mode changes stay local until Apply (or Cmd/Ctrl+S; Esc reverts), are linted inline, run through the same guards as the canvas edits (instance flows, the responseMapping wrapper), and are written as canonical JSON over exactly the step's range in the document — or the resource file's full text — leaving the document dirty for you to save. If the document changes underneath unapplied edits, a banner offers Reload or Keep mine. The panel is sections — Facts, Live, Step components, Related and the JSON section — each folding from the chevron in its header (the JSON section's header keeps its tabs and Open in editor while folded; a fold hides, so unapplied edits stay), and the sections above the editor scroll as one. Drag the grip on the divider above the JSON section to split the panel where you want it (neither side under 120 px; arrow keys move it 16 px; double-click for the half-and-half default) — it is remembered as the editor's share of the height, so it looks the same in a taller or shorter window. Drag the grip on the panel's left edge to resize it (240 px minimum, up to what leaves the canvas 320 px; double-click the grip for the 380 px default), or collapse the panel to a slim rail with the chevron in its Details header, View › Show details panel, or Cmd/Ctrl+\ — the rail's chevron opens it again. Width, collapse, the folded sections and the split are remembered.
• Follows what a step touches. A Related tree above the JSON lists everything the selected step reaches in the tree, in Flow Builder order: the step entry, one item per step component (filters, transformations, mappings, response mapping; hooks expanded per stage with their script beneath), the export/import document with its connection and every other reference — and, for an AI agent or guardrail step, its Instructions: the instructions.md the tree keeps the system prompt in — and the flow-level links (_runNextFlowIds, an instance's abstract flow). JSON items load into the editor as their own tab — pointer-exact, with the same guards as a step edit, in whichever tree file they live. A script loads as a Script tab — its script.js with JavaScript highlighting, opened at the function the hook names — and an agent's instructions as an Instructions tab — its instructions.md with Markdown highlighting (headings, emphasis, links, inline code), opened at the top; both are editable in Edit mode, with Apply (or Cmd/Ctrl+S) writing the whole file back verbatim, and the row's open in editor link still opens the file in a full editor beside the canvas. Flows drill down; a reference the tree cannot resolve shows its id, muted, with a where it's written link to the referencing field. Clicking a step component chip on a card does the same as its tree item. Arrow keys move between items.
• Shows the tree's state. celigo status badges (modified / missing / untracked) on the flow and on each step's document, and celigo lint findings on the steps they concern.
• Drills down. Flows started by this one (_runNextFlowIds) and an instance's abstract flow open in their own canvas.
• Live overlay (opt-in). With celigo.canvas.liveOverlay on, the canvas reads the bound account through the CLI in read mode: open-error counts per step, whether the flow is enabled on the server and its last run, and whether the server copy changed since the pull. The overlay itself writes nothing; the only account writes the canvas runs are the Live errors list's explicit Retry / Resolve (below). The toolbar sums it up beside the flow's name — a red 139 open errors badge and an amber remote changed badge when there is something to say (live unavailable when the CLI could not read), each opening the details panel's Live section. Remote changed means a confirmed content difference: when the server's lastModified differs from the token the tree pulled, the extension runs celigo diff <path> — the CLI's own comparison, volatile fields ignored — and shows the badge only when the diff reports differences (how many, in the badge's tooltip and the Drift row). A lastModified the platform bumped for a flow run or a debug toggle, with the content unchanged, is no badge at all: the Drift row reads timestamp moved — … the content matches your file, and if the comparison could not run it says the content was not compared with the CLI's reason and the celigo diff line to run yourself. The Live section lists the steps with errors as links and, under the Drift row, what to do about it — Pull latest takes the server's copy of this document (celigo pull --force <path>, run by the extension through the CLI; a document with local edits since the last pull asks first, an unsaved editor buffer offers Save and continue or Revert and continue, and the CLI's summary line becomes the section's note while the canvas re-renders from the pulled file and the badge clears; under a timestamp moved drift the same button only refreshes the pulled token, the file already matching), Compare runs the quoted celigo diff line in a terminal, and, for a confirmed change, Pull everything runs the incremental celigo pull of the whole tree in a terminal, local edits kept. A celigo pull you run in a terminal is picked up on the next refresh — the pulled token is re-read from the tree's manifest each time. The Live button at the right carries a status dot (grey until the first read, green clean, red errors, amber for a confirmed change) and refreshes on click; while the canvas is visible and the window focused the overlay also refreshes on its own every celigo.canvas.liveRefreshSeconds (60 by default; 0 for on demand only), the same two read-mode CLI calls each time — the diff only while the tokens differ, and once per state — with the wait doubling up to ten minutes after a failed read. Click a step's error count (on its card, or the Open errors row of the step's Live section in the details panel) to list the step's open errors in a Live errors section under it — code, classification, retryable or not, when it occurred, the message, the errorId and trace key — read through celigo flows errors; the newest 50 are shown and the section names the terminal line for the rest. Open › on an error shows what Error Management shows for it, read-only: its fields (Error), its retry data — the record as the step saw it when it failed — as JSON (Record), and the stored HTTP request and response with method, URL, status, headers and body (Request, Response), each read through celigo flows error when its tab is first opened; Copy JSON and Open in editor give you the whole payload (the panel shows up to 512 KB), and header or query values that look like credentials are masked. The flow's Live section lists every step with open errors as the same links. The list acts, too: Retry on a row (an error that can be retried — its record is sent through the step again, no confirmation) and Resolve, the same two in the error view, Retry all / Resolve all over every open error on the step — the CLI pages them all, not only the 50 listed — and, with rows checked, Retry selected / Resolve selected. Anything bulk and every resolve asks first in a modal that names the count, the step and the profile (Resolve 158 open errors on Update job tracker? Resolved errors leave the open list and cannot be reopened.). Each runs celigo flows retry-errors or resolve-errors through the CLI under the profile's own permission mode: a read-mode profile sees the CLI's refusal in the panel with the terminal line to run instead, never a silent nothing. The CLI's outcome is the list's note — Retry queued for 3 record(s). (job …), since a retry is a job whose open count drains as it runs; Resolved 158 error(s). — and the list and the step's count are read again. Assignment, comments and the resolved-error history stay in Error Management.
• Edits the graph. Edit turns on the Flow Builder affordances: + on any edge adds a step or a branching, step menus add and remove steps and toggle error handling (a dashed Add destination / lookup or Add source placeholder has the same ⋯, with Remove step / Remove source), the details panel's Move left / Move right reorder a step within its branch (offered only where there is a step to move past), branch ends merge into a merge point or another branch (and remove a branch that has no steps), merge points unmerge, branchings gain branches and names, the Enabled / Disabled switch beside the flow's name toggles disabled (a read-only badge outside edit mode). Every edit is written to the document as canonical JSON through the CLI's own mutation rules (the same JSON the builder saves) — undo works, celigo status sees exactly the change — and Push runs celigo push --dry-run, then celigo push, for this flow and its changed step documents and scripts, in a terminal: the flow's document first, then every file its steps reference that has local changes — an import edited in the Resource tab, a hook's script.js, an AI agent's instructions.md, a modified connection — each named on the terminal's line, so nothing the canvas wrote is left behind. Canvas and JSON edits are ordinary unsaved edits to the document: Cmd/Ctrl+Z undoes them one at a time, File: Revert File drops them all, and Pull latest replaces the saved file with the server's copy. Push sends what is on disk, so a document or related file with unsaved edits asks first — Save all and continue, or Cancel.
• Finds nodes. The Find node field in the toolbar (Cmd/Ctrl+F while the canvas is focused) matches step names, applications, resource types, resource and connection names and branch names, every word you type; Enter / Shift+Enter walk the matches, which are selected and centred at the current zoom; Esc clears. Non-matches step back so the matches stand out.
• Lays out either way. Left to right as Flow Builder does, or top to bottom: View › Vertical layout in the toolbar flips one canvas, and celigo.canvas.direction sets the default. The vertical layout is the Flow Builder layout transposed — same rules, same spacing — with the step component chips in columns above and below each card and the sources in a row centred over the trunk, each dropping to one join line. View › Fit to screen shows the whole graph however large it is.
• Exports. The toolbar's Export menu saves a PNG or SVG image of the canvas, or copies a Mermaid diagram that renders natively in a GitHub pull request description, reading in the canvas's direction (flowchart LR or TD).

Restricted Mode

The extension supports untrusted workspaces with limits: the canvas renders, the details panel and the JSON editor work and edits are written to the open document, but nothing spawns the celigo CLI — lint findings, the live overlay, push and the offer to install the CLI stay off (Live and Push say so in their tooltips) until you trust the workspace, at which point open canvases refresh on their own. celigo.cliPath is a restricted setting: a workspace's own value is ignored until the workspace is trusted.

Requirements

• VS Code 1.104+ or Cursor.
• The Celigo CLI on your PATH for lint findings, the live overlay and push (npm install -g @celigo/celigo-cli). Rendering and editing work without it.

Installation

• In the Extensions view, search for Celigo by the publisher Celigo (the Visual Studio Marketplace in VS Code, Open VSX in Cursor and other editors) and click Install.
• Or install a downloaded VSIX from the terminal: code --install-extension celigo.vsix in VS Code, cursor --install-extension celigo.vsix in Cursor.

Usage

Open a flow:

1. Pull a tree with the CLI: celigo pull.
2. Open a flow.json, api.json or tool.json from the tree.
3. Press Cmd/Ctrl+Shift+V, or click the preview icon in the editor title, to open the canvas beside the editor.
4. Or run Celigo: Open Flow Canvas from the Command Palette (also on the editor's and the Explorer's context menu) to open it in the current editor group.

Settings

Commands

Celigo: Open Flow Canvas, Celigo: Open Flow Canvas to the Side (Cmd/Ctrl+Shift+V), Celigo: Copy Flow as Mermaid, Celigo: Push Flow with celigo (plan first), Celigo: Refresh Live Overlay.

Three commands exist for their keybindings, which apply while a canvas is the active editor — wherever focus sits inside it — and can be rebound in Keyboard Shortcuts: Celigo: Apply the JSON Panel's Edits (Cmd/Ctrl+S), Celigo: Find Node on the Canvas (Cmd/Ctrl+F) and Celigo: Show or Hide the Details Panel (Cmd/Ctrl+\, Split Editor's key, which a webview panel has no use for). Command IDs are celigo.<name> (celigo.open, celigo.openToSide, celigo.copyMermaid, celigo.push, celigo.refreshLive, celigo.applyJson, celigo.findNode, celigo.togglePanel).

Support

• Documentation for the extension and the CLI — guides, the command reference and the changelog: developer.celigo.com/cli.
• Extension bugs, feature requests, and integrator.io questions: Celigo Support. Include the extension's version, your VS Code or Cursor version and operating system, the output of celigo --version when the CLI is involved, and a minimal reproduction. Never post API tokens, credentials, customer data, or complete request or response payloads.
• Security vulnerabilities: email security@celigo.com rather than a public channel.

Contributing

The extension is developed in the Celigo CLI's repository, alongside the CLI, as an npm workspace; the CONTRIBUTING.md there covers building it, the dev harness and releasing.

License

MIT; the LICENSE file ships with the extension.

The canvas is set in Inter: the extension ships Inter 4.1's InterVariable.woff2, © The Inter Project Authors and licensed under the SIL Open Font License 1.1, whose text (LICENSE.txt) travels beside the font in the VSIX.

The icon is Celigo's monogram. Celigo and the Celigo logo are trademarks of Celigo, Inc. — the icon identifies this extension in the Marketplace and is not covered by the MIT license.