ConnectMyApps Canvas for VS Code

Build, debug, and manage ConnectMyApps Canvas workflows locally using VS Code's full development environment. This extension provides a headless iPaaS experience — leveraging Canvas's cloud infrastructure while giving you local editing, debugging, diffing, and API testing tools.

Compatible with VS Code and forks such as Cursor and Kiro.

Features

• Download workflows and edit block code locally with full IntelliSense
• Debug workflows block-by-block or end-to-end in VS Code's debugger
• Push code and configuration changes back to Canvas
• Compare local code against Canvas using the native diff editor
• Test application connector APIs without managing workflows
• Read and write workflow and account vaults directly, and import vault CSV exports
• Write local one-off scripts against real account apps, with an optional linked workflow vault
• Load run results and webhook data from Canvas for local inspection
• Search across workflow data (outputs, logs, sessions)
• Scaffold AI coding assistant instructions for your preferred tool (Copilot, Cursor, Claude Code, etc.)

Prerequisites

Node.js 22.14.0 or higher is required for debugging and running block scripts.

node -v

If you need to install or upgrade, download the latest version from nodejs.org.

Installation

Install ConnectMyApps from the VS Code Marketplace:

1. Open the Extensions view (Ctrl+Shift+X)
2. Search for "ConnectMyApps"
3. Click Install

Alternatively, install from a .vsix file: Extensions menu > ... > "Install from VSIX".

Getting Started

1. Log in — Open the command palette (Ctrl+Shift+P) and run cma: Log In. Enter your Canvas consumer key and secret key. Credentials are stored securely in your OS keychain.
2. Initialize workspace — Run cma: Init Workspace. Choose a folder (recommended: inside your user home directory to avoid permission issues). This creates the workspace structure, config files, and package.json.
3. Install dependencies — Open a terminal in your workspace root and run:

   npm install
   

4. Download a workflow — Run cma: Get Workflow, select an account and workflow. Local files are created for all blocks.
5. Debug — Open a block .mjs file and press F5 to launch the VS Code debugger.

Workspace Structure

After initialization your workspace contains:

workspace/
  workflows/         — Workflows downloaded from Canvas accounts
  scripts/           — Local one-off scripts (scripts/<account>/<name>/), formerly blocks/
  requests/          — REST API request/response files for app connectors
  proxy_modules/     — Runtime modules that emulate Canvas functions locally (do not edit)
  .vault-audit/      — Local log of vault writes made from this workspace (gitignored)
  package.json       — Dependencies managed by the extension
  .workspace-config.json — Configuration (see below)
  .gitignore         — Pre-configured ignore patterns

Workspaces created before v1.9.0 have a blocks/ folder. Init Workspace (and the update check after an extension update) renames it to scripts/ automatically; blocks/ and templates/ are reserved for future template management.

The package.json includes managed dependencies required for local execution: @cma/prism, @cma/util, axios, date-fns, jose, underscore, utf8, uuid, and xml-js. You can add your own dependencies — the extension will never remove them.

Commands

All commands are prefixed with cma: in the command palette (Ctrl+Shift+P / Cmd+Shift+P).

Setup & Authentication

Workflows

Pushing Changes to Canvas

Comparing with Canvas

Workflow Tags

cma: Add Workflow Tag and cma: Remove Workflow Tag change tags on the live Canvas workflow after confirming the account, workflow, and exact tag. Tags are case-sensitive. If Canvas does not return a list of tags on the workflow, enter the exact value to remove; Canvas does not report an error for a missing tag. These commands do not manage tags on accounts, applications, or templates.

Blocks

Scripts

Vault

Requests (API Testing)

Email and Secure Share

cma: Send Email or Secure Share asks for recipient email addresses, a subject, a single-line plain-text message, and optional local files. It sends using your signed-in Canvas profile; you do not need to select an account. For a longer or multi-line message, load a UTF-8 text file instead. Separate multiple recipients with commas or semicolons. cma: Send Email or Secure Share (This Account) addresses the account of the active workflow, script, or request file. If no account can be detected, enter recipients manually.

Each secure-share upload gets a random six-digit code unless the email module supplies one explicitly. Canvas includes the code in the notification email, so it is not a separately delivered authentication factor. When files and multiple recipients are selected, choose either separate secure shares (one upload per recipient) or one shared secure share. For a shared share, the first recipient is addressed directly and the rest are passed as a comma-separated CC list, as in the existing email proxy module. Recipients can see one another. The API documentation describes a CC address but does not confirm multi-address CC support; the upload API does not confirm individual delivery. The message is included as a note in the notification email. Without files, the command sends a regular email, not a secure share. The command shows the recipients and filenames for confirmation before sending. If some requests cannot be confirmed, check before retrying: a request may have succeeded even if its response was lost.

Webhooks

Run Results & History

The Canvas Run History Explorer view shows the selected workflow's run records, search progress, and grouped match counts. Its toolbar refreshes or filters the list and opens search-task management. Click a run for details, result download, local-history storage, or a historical configuration diff. Download actions can overwrite the selected local output/history files and ask for confirmation. Opening a workflow from the local workspace, or selecting an already-downloaded workflow, supplies the account and workflow context.

For a completed content search, choose Save matching runs to history… in the view. The extension collects every matching page using the current view filters, then saves only those runs under history/run-<number>/. Choose all blocks or specific blocks, and either skip existing run folders or overwrite their matching files. The download is cancellable and stops after approximately 1 GB; incomplete runs are reported so they can be retried. Results are fetched using the current local manifest and the workspace's run-result settings.

Search terms and tasks are stored on Canvas. Creating, cancelling, and deleting tasks requires confirmation; clearing all tasks can affect other users. Hiding the view stops local progress polling but does not cancel or delete the server task. The server reports matching runs and grouped counts, not exact matching lines. cma: Search Workflow Data is separate: it searches downloaded local files and supports regular expressions. Canvas content searches require a non-empty text term; saving search matches does not itself test whether a block ran or its response was non-empty.

Editor Context Menu

Right-click a file and open Canvas for actions relevant to that file: workflow block actions and block results in block files; workflow, run-history, webhook and tag actions within workflows; script and vault actions within scripts; request actions on request files; and workspace tools on root files and proxy modules. Deploy Workflow remains available from the command palette.

Search & Utilities

Workspace Configuration

The .workspace-config.json file in your workspace root controls extension behavior. It is created automatically during initialization and can be edited manually.

{
    "version": "1.3.1",
    "initialized": "2026-07-01T10:00:00.000Z",
    "request": {
        "defaultNamingMode": "smart",
        "defaultBaseUrl": "https://canvas.connectmyapps.com/api/ApiSend",
        "defaultResponseCodes": [200, 201, 404],
        "requestBodyOverride": {},
        "smartNaming": {
            "maxPathLength": 20,
            "preserveNumericIds": true
        },
        "archiveOrphanedFiles": true
    },
    "runtime": {
        "outputCleanup": "canvas",
        "sessionCleanup": "canvas",
        "updateLocalDateLastRun": true,
        "runResults": {
            "onWorkflowGet": "prompt",
            "includeOutput": true,
            "includeLog": true,
            "includeSession": true,
            "archiveOnCleanup": true
        }
    },
    "diff": {
        "viewMode": "active"
    },
    "vault": {
        "importConcurrency": 4
    }
}

Request Settings

Runtime Settings

Diff Settings

Vault Settings

Other Settings

Smart Request Naming

When using "resultsPage": "smart" in request files, the extension generates descriptive filenames based on request content.

Filename Format

{APP}_{verb}_{urlPath}_{hash}_req.json
{APP}_{verb}_{urlPath}_{hash}_res.json

Examples:

• QUIN_get_employees_a1b2_req.json
• MYST_post_orders_c3d4_res.json
• FTP_get_files_documents_e5f6_req.json

How It Works

1. On execute: The extension generates a filename from the request content (verb, URL path). If it differs from the current filename, the request file is renamed and any orphaned responses are archived.
2. Duplicate detection: If the generated filename matches an existing file, the existing file is replaced and your editor tab stays open with the renamed file.
3. Archiving: Orphaned responses are combined with their originating request into an archive/ subfolder as a single { request, response } JSON file. A hidden archive/.pending/ record captures the request at execution time so pairing is always correct. Set archiveOrphanedFiles: false to delete instead.

URL Path Truncation

Long URL paths are intelligently truncated to fit within maxPathLength:

• First and last path segments are prioritized
• Middle segments are removed if needed
• Numeric IDs can be preserved or replaced with "id" based on settings

Important Concepts

dateLastRun

The dateLastRun variable represents the timestamp of the last successful workflow execution.

Local behavior:

• Loaded from the workflow's manifest.json into the global dateLastRun variable when blocks execute, enabling incremental sync patterns. Get/Refresh Workflow sets it to the Canvas value at the time of the pull.
• A local run "completes" when the last block finishes, or when a block calls fx.stopAfterThisBlock(true). By default this updates dateLastRun in the local manifest.json to the run's time, like a completed Canvas run.
• Set runtime.updateLocalDateLastRun to false in .workspace-config.json to keep the value from the last pull (or your manual edit), so you can re-run the same delta window. The setting covers both triggers: with false, neither the last block nor fx.stopAfterThisBlock(true) writes dateLastRun; with true, both do.
• fx.stopAfterThisBlock() / fx.stopAfterThisBlock(false) stops the run without advancing dateLastRun.
• You can manually edit the value in manifest.json for testing.
• Local changes to manifest.json never reach the Canvas server's dateLastRun.

Canvas sync (optional):

• By default, local runs do NOT update dateLastRun on Canvas (prevents local debugging from affecting production).
• Set "syncDateLastRun": true in manifest.json to set the Canvas dateLastRun to the current time after each completed local run (same two triggers). This is independent of runtime.updateLocalDateLastRun: it syncs even when the local value is not updated.

Local Webhook Testing

Webhook batch behavior is configured locally in a workflow's manifest.json and does not change Canvas settings:

{
  "isBatch": true,
  "batchSize": 5,
  "archiveProcessedWebhooks": true
}

• isBatch defaults to false when Canvas settings are unavailable. When available, the downloaded Canvas batch settings initialize isBatch and batchSize; later manual edits are preserved on refresh.
• batchSize defaults to 1. Use cma: Configure Local Webhook Batch to edit these values, or edit the manifest directly.
• cma: Load Webhook Batch downloads up to batchSize payloads from the Canvas queue, history, or sandbox. Queue/history downloads paginate automatically and are stored in deterministic order under webhooks/batch/.
• In batch mode, blocks receive the selected payloads as webhooks, and webhook is the first selected value (webhooks[0]). Singular mode continues to read webhooks/webhook.json directly.
• With archiveProcessedWebhooks: true, successful local workflow completion moves consumed queue/history batch files to webhooks/history/, simulating Canvas queue consumption without altering remote data. Sandbox snapshots remain pinned across runs.
• Saving a remote workflow run to history/run-{number}/ also downloads its matching webhook-history payload when the run was webhook-triggered. The payload is saved as webhook.json with webhook-meta.json beside the block artifacts.

Vault

myVault is a key-value store per workflow (get, set, contains, remove, setOnComplete) and per account (the *Global variants). The vault commands read and write it directly, so you don't need to add a block to a production workflow and run it.

Everything is live. Local runs, the vault commands and the CLI all read and write the real Canvas vault. Set and Remove always show the account, vault, key, current value and new value in a confirmation first.

Which vault a command uses is worked out from the active file every time; nothing is remembered between commands:

The prompt title always names the vault, and title-bar buttons switch between the workflow and global vault or choose another one.

Values: type JSON (123 is a number, "123" with quotes is text, {"a":1} an object); anything that isn't valid JSON is stored as text. Values keep their exact type. null, undefined and '' never blank a value: Canvas keeps an existing value (and set returns false), and a missing key is created without a value (contains is true, get is null). The commands reject empty values for that reason; to blank a value store {}, [] or a marker value, or remove the key.

Key suggestions in the key prompt are only typing aids: keys recently used from this workspace and string keys referenced in local code. There is no way to list a vault's keys (the platform has no list endpoint).

Audit log: every write made from this workspace (extension or CLI) is appended to .vault-audit/audit.jsonl, including the previous value. The log only covers operations performed from this workspace and does not reflect vault contents: production flows write to vaults all the time. It is gitignored because it may contain vault values.

CSV import (cma: Vault: Import from CSV, canvas-cli vault import) imports a DevOps vault export ("Id","Tag","Value") into one vault, for example when migrating a flow:

• Copy values from source vault (exact), the default when the source vault still exists: the CSV only supplies the key list, and every value and type is read from the source.
• Use CSV values when the source is gone. Exports unwrap one JSON layer, so a cell like 123 or true can be a typed value or text; you choose per kind (numbers, booleans, objects, arrays), optionally after checking a sample against the source.
• Raw export (exact) when every cell is the stored JSON text.
• Empty cells create missing keys without a value; they never blank an existing value. You can also import only keys that don't exist yet.
• You confirm by typing the target name. Imports show progress, can be cancelled and resumed, failed rows can be retried, and each run is logged in .vault-audit/imports/ (without values).

Scripts

Scripts (scripts/<account>/<name>/, created with cma: New Script) are local one-off .mjs files for testing, probing, reporting, data fixes and vault maintenance against an account's real apps. They are not workflow blocks and are never pushed.

• Globals: api, fx, logger, myVault, email, Datasource, dateFNS, utf8, xmlJS, jose, uuid, prism, util. Workflow-only globals (getVariables, getWorkflowVariables, session, webhook(s), dateLastRun) are not available; hardcode configuration or read it from input/.
• input/ → Datasource: every file in the script's input/ folder (alphabetical, no dotfiles) becomes one Datasource entry; .json files are parsed, other files are passed as text.
• Vault linking: myVault.*Global uses the account's global vault. get/set/contains/remove/setOnComplete use the workflow vault linked in the script's manifest.json (choose one when creating the script, or run cma: Link Script to Workflow Vault). Without a link they throw an error that explains this. Each run starts by logging which vaults it uses.
• setOnComplete writes are saved when the script finishes without an error. Scripts don't write run history, session.json or dateLastRun, and fx.stopAfterThisBlock has no effect.
• The script's return value is written to output/output.json, and logs to output/logger.json.

Renaming Blocks and Workflows

Edit names directly in manifest.json:

• Block name: Edit the name property of the block in the blocks array.
• Workflow name: Edit the name property at the root level.

When you push code or config, updated names are sent to Canvas and local folders are automatically renamed (sanitized for filesystem-safe characters).

Changing Block Order

Add or reorder blocks in the Canvas web UI, then use cma: Get Workflow to re-download. Local block order changes are not synced.

Known Limitations

Workflows

• Schedule management: No commands for changing or toggling a workflow's schedule. Use the Canvas web UI.

Workflow and Block Templates (Workbench)

• Workflow and block templates cannot be fetched or updated via the extension. Only registered (deployed) workflows are accessible.
• Pushing code to a block created from a workbench template will mark it as "customized" and it will no longer receive template updates.

Functions (fx)

• Functions cannot be created or modified through the extension. Use cma: Update FX Functions to pull the latest function definitions from Canvas into your local fx.js.

Webhooks

• The extension cannot actively listen for incoming webhooks — they must be fetched manually.
• Local webhook archiving never moves remote Canvas queue items to history.

Feedback

Send feedback and feature requests to support@connectmyapps.com.