> For the complete documentation index, see [llms.txt](https://developer.celigo.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.celigo.com/changelog/2026.md).

# 2026

Notable changes to the Celigo developer platform across the REST API, CLI, and Platform MCP.

{% updates format="full" %}
{% update date="2026-10-28" tags="mcp,feature,breaking" %}

## October Platform MCP updates

Connected clients pick these up automatically; full details are in [Tools](https://developer.celigo.com/mcp/tools).

* **Breaking:** `patch_flow` refuses a path beneath `/schedule`, such as `/schedule/cron`, before the request. The platform answered `204` to those paths and kept the old schedule; replace `/schedule` with the whole cron string.
* **Breaking:** `list_tags` returns `{ items, hasMore }` instead of a bare array. `hasMore: true` means the tags didn't fit one page; call it again with a higher `limit`.

**Skills**

* The server serves Celigo's 30 skills, the step-by-step guides the Celigo CLI installs for coding assistants. `get_skill` lists them, returns a skill's `SKILL.md` with `name`, and another of its files with `path`. See [Skills](https://developer.celigo.com/mcp/tools#skills).
* Each skill's `SKILL.md` is a resource at `skill://celigo/<name>/SKILL.md`, and its other files are readable at `skill://celigo/<name>/<path>`.
* Clients that support the MCP Skills extension (`io.modelcontextprotocol/skills`) list the skills with `skills/list` and read one with `skills/get`. The server's instructions name every skill.

**Connections and users**

* `upsert_connection` keeps a stored secret whose `******` mask you send back, so a connection read with `list_connections` saves as read, without `force: true`.
* `upsert_connection` re-sends a stored secret the body leaves out of an object it keeps, such as `http.auth.basic` without `password`, and lists it in `keptSecrets`.
* `upsert_connection` refuses a body that drops a whole object holding secrets, such as all of `http.auth` or the `netsuite` block, instead of clearing them and taking the connection offline.
* `manage_user` with `update_permissions` keeps the user's MFA requirement unless the body sets `accountMFARequired`. `list_users` shows `accountMFARequired` and `accountSSORequired` for each invited user.

**Writes**

* An `upsert_*` body can carry what a read returned: fields the platform manages, such as `createdAt` and `lastModified`, are dropped and listed in `_strippedFields`. A body `_id` on a create, or one that differs from the `_id` argument, is refused.
* `upsert_flow`, `upsert_integration`, `upsert_export`, and `upsert_import` refuse a malformed `settingsForm`, such as a `fieldMap` beside `form`, before anything is saved. The platform stored it as sent, and the form showed nothing.
* `update_flow_error_retry_data` refuses a body with an empty or missing `data`, which would have wiped the error's record.
* A write that fails with a `5xx` or a network error is no longer retried by the server, because it may have run. Reads and `429` responses are still retried. Check whether a write landed before you call it again.

**Runs and errors**

* `list_flow_runs` defaults `type` to `flow` when you pass `_flowId` or `_integrationId`, and a flow id passed as `_id` returns that flow's runs with a `_hint` instead of a `404`.
* `cancel_flow_run` sends nothing for a run that is already canceling or has finished, and returns `changed: false` with its `status`.
* `list_current_jobs` pages with `cursor`. The second page used to fail.
* `list_flow_errors` reports errors on lookup steps and on steps inside router branches.
* `triage_flow_errors` with `retryAll` or `resolveAll` acts on every error open on the step when you call it. It used to send an empty body, which retry refused and resolve ignored.
* `list_flows` with `includeErrorCounts` marks a flow whose count couldn't be read `errorCountUnavailable: true` instead of reporting `0`, and `hasOpenErrors` keeps it.

**Errors and paging**

* A validation error names the argument or body field that isn't allowed.
* A request body over 8 MB gets a `413` that names the limit and points file content to `upsert_storage_item`'s `presignedUpload`.
* `get_schema` with `target: "connector"` and an HTTP connection's id says to pass its `http._httpConnectorId`; HTTP connections have no native metadata.
* `list_mcp_servers` pages past the first page.

**Corrections**

* Correction to the July 14 entry: `list_execution_logs` reads any logged run, not only runs with debug logging armed. The job's `logMode` sets how much each stage holds, and a debug run adds the mapping, hook, and filter stages.
  {% endupdate %}

{% update date="2026-10-27" tags="cli,feature,breaking" %}

## CLI 2026.10.2

`@celigo/celigo-cli` 2026.10.2 is on npm: chat with an AI agent, MCP server request logs, Handlebars and filter evaluators that run in read mode, every EDI file route, and a refusal of the router `script: null` that crashes Flow Builder.

```bash
npm install -g @celigo/celigo-cli
```

**Changes that can break scripts**

* **Breaking:** `processors invoke` needs operate mode. Read mode allowed it, yet the catalog's `javascript` processor runs a hook whose integrator-api calls write for real. In read mode, use `processors parse`, `generate`, `render` and `filter`. See [processors](https://developer.celigo.com/cli/commands/processors).
* **Breaking:** every write refuses a router whose `script` is `null`, with no override: `create`, `update`, `set`, `add-processor`, `remove-processor`, `add-generator`, `remove-generator`, and `push` and `promote` at plan time. The platform stores it, but Flow Builder crashes opening that router. `set <id> 'routers[<n>].script=null'` deletes the key. See [flows](https://developer.celigo.com/cli/commands/flows).
* **Breaking:** `set` refuses a bare rules array for an export's or import's filter (`'filter=[...]'`). The platform answered `200`, stored no filter, and dropped the step's own, so every record passed. Send `{"type": "expression", "expression": {"version": "1", "rules": [...]}}`.
* **Breaking:** `workspace-users invite` exits `1` when any address was not invited, one that already has access included. A refused address's result carries the platform's reason. See [workspace-users](https://developer.celigo.com/cli/commands/workspace-users).
* **Breaking:** `syncs update` refuses a body that changes `_integrationId`, `_id` or `_userId`, and `workspace-users update` one that changes `userType`. The `PUT` refuses those fields, so `update` dropped them, and the platform answered `200` with nothing changed.

**New commands**

* `ai-agents chat [id]` sends an AI agent one message and prints the turn: the reply, the tools it ran, the files it produced, token usage and AI-credit cost. Without an id, an unsaved agent document answers and is never saved. `--conversation <key>` keeps a history. Needs operate mode: every turn is a billed run whose tools act for real. See [ai-agents](https://developer.celigo.com/cli/commands/ai-agents).
* `ai-agents model-health` lists the AI agents and guardrails on a refused or deprecated model, with the models the platform suggests instead. `--integration <id>` keeps the ones that integration's live flows use.
* `mcp-servers request-history`, `log-detail`, `request-log-filters` and `purge-request-logs` read and purge an MCP server's request logs: the calls MCP clients made, and each stored request and response, `Authorization` masked. See [mcp-servers](https://developer.celigo.com/cli/commands/mcp-servers).
* `processors render` renders a Handlebars template against a JSON object, and `processors filter` runs records through a step's filter rules. Both run in read mode, so a template or a filter is checked before it is saved on a step.

**Security**

* `mcp-servers set` no longer approves changed upstream definitions as a side effect. A `PUT` that carries `upstreamMcpConnections` approves every upstream tool, prompt and resource definition that changed since an administrator approved it, and `set`'s GET + PUT always carries it. While a row is flagged `changedSinceApproval`, `set` refuses that `PUT` and names the rows.
* `push` and `promote` refuse the same MCP server update, at plan time and again before the `PUT`. `--force-remote` does not lift it. See [Push changes](https://developer.celigo.com/cli/local-tree/push).
* Behind a proxy (`HTTPS_PROXY`, `HTTP_PROXY`), a server that renegotiates TLS 1.2 with another certificate no longer crashes the CLI.

**Also in this release**

* `--stack-id <id>` on `integrations`, `flows`, `exports`, `imports` and `tools clone`, and on `templates install`, sends the stack the resource's hooks or wrapper connections run on. Without it the platform refuses such a clone with `400 stack_not_found`.
* `syncs run --resync` drops the delta checkpoint and reloads all data, and `--datasets <ids>` runs only the datasets named. See [syncs](https://developer.celigo.com/cli/commands/syncs).
* `flows execution-logs --status` (`success`, `error`, `ignore`) and `--trace-key-prefix` filter a run's log index on the server.
* `edi-transactions download-file` reaches every EDI file route: a document number narrowed by lookup filters, the latest match of the filters alone, or a transaction's own file with `--id`. With `--fa`, it returns the functional acknowledgement. See [edi-transactions](https://developer.celigo.com/cli/commands/edi-transactions).
* `edi-transactions list` takes `--sender`, `--receiver`, `--fa-status` and `--page-token`, and prints the next page's token on stderr.
* `set` sends a JSON-looking value as text where the spec types the field as a string, such as an export's `http.body`. It sent the parsed object, which an export ignored and an import stored in the template's place.
* `exports invoke` prints a streamed answer — the records, then the error that stopped paging — as one `{data, dataURIs, errors}`, instead of refusing it as invalid JSON.
* `imports invoke` counts records by cause on stderr: rejected by the destination, failed before sending, failed after sending (the destination may already hold them), and ignored. `ai-agents invoke` and `guardrails invoke` print the same count.
* `celigo lint` bundles `@celigo/api-specs` 0.2.198 (764 schema definitions, the 2026-10-27 spec build), and the `create`, `update` and `set` checks use it too. See [Lint and resolve](https://developer.celigo.com/cli/local-tree/lint-and-resolve).
* The `handlebars-syntax` lint rule also checks a NetSuite lookup's `expression` and an API step's response-mapping `extract`, and it checks an HTTP lookup's `body` instead of `postBody`, which the platform drops on save.
* `templates preview` and `templates install` point an MCP server template at `mcp-servers install-template`, the command that installs one.
* `metadata types` shows a NetSuite record type's `scriptId`, the name `metadata fields` takes.

**Fixed**

* `edi-profiles create --tp-connector` stores a blank ISA02/ISA04 as `""` and the partner's interchange id unpadded. The connector's form pads them, and a profile that copied the padding failed every inbound file with `422`.
* `event-reports create` refuses a `flowIds`, `flowId` or `_flowId` key before the request and names `_flowIds`, the only key the create reads.
* `connections create --connector` names `accessScope` for the Celigo APIs connector. The platform refuses that connection without it (`422`), though the connector's form lists no field.
* With Node 24 on Windows, a failed command exits `1` instead of crashing with `Assertion failed: !(handle->flags & UV_HANDLE_CLOSING)`.
* An API error whose message doesn't name the field it refused prints it after the message, such as `(field: name)` on a script update without `name`.
* Correction to the CLI 2026.9.1 note below: `file-definition-rules` jobs are capped at 10 `generate` and 10 `parse` an hour per user, not 10 an hour per account, and the account owner and administrators are not capped.
* Correction to the CLI 2026.9.6 note below: `subscriptions api-usage-summary` returns the current month and the 13 months before it, one row each.

Full command reference in the [Celigo CLI](https://developer.celigo.com/cli) section.
{% endupdate %}

{% update date="2026-10-27" tags="api,feature,breaking" %}

## October API updates

Everything below is live in production and documented in the [API reference](https://developer.celigo.com/api).

**AI agents**

* **Breaking:** saving an AI agent or guardrail import checks its model against the platform's model catalog. A model that is not in the catalog, switched off, not offered for the credential type, or retired is refused with `422` on the model field (`ai_model_not_in_catalog`, `ai_model_disabled`, `ai_model_not_available`, `ai_model_retired`). The save used to accept any model, and the first run failed. See [AI Agents](https://developer.celigo.com/api/api-reference/ai-and-mcp/ai-agents).
* A run on such a model fails with `Run blocked:` before any model call. A deprecated model still saves and runs until its `retiredAt`.
* `GET /v1/aiagents/aiModelHealth` lists the AI agent and guardrail imports on a refused or deprecated model, with `lifecycle.suggestedNextModels`. `GET /v1/integrations/{_integrationId}/aiModelHealth` keeps the ones that integration's live flows use.

**Endpoints**

* MCP server request logs: `GET /v1/mcpservers/{_id}/logs` lists the calls MCP clients made to a server, `GET /v1/mcpservers/{_id}/logs/{key}` returns one stored request and response, and `POST /v1/mcpservers/{_id}/logs/purge` deletes stored payloads in a time window, up to 10,000 per call. See [MCP Servers](https://developer.celigo.com/api/api-reference/ai-and-mcp/mcp-servers).
* `GET /v1/mcpservers/logs/filter-options` lists the values the request-log `method` and `status` filters take.
* `/v1/alerts` manages long-runtime alerts that notify recipients when a flow runs past a threshold. `PATCH /v1/alerts/bulk/recipients` adds or removes recipients across alerts. See [Alerts](https://developer.celigo.com/api/api-reference/monitoring/alerts).
* `POST /v1/flows/{_flowId}/runs/stats` returns a flow's runtime statistics, the data behind an alert's threshold chart.
* `GET /v1/ediTransactions/{_ediTransactionId}/ediFile` answers a short-lived signed URL for a transaction's file (`type=nonFa`) or its functional acknowledgement (`type=fa`). See [EDI Transactions](https://developer.celigo.com/api/api-reference/b2b-manager/edi-transactions).
* `GET /v1/edi/documents/ediFile` returns the latest EDI file that the lookup filters match, with no document number.
* `POST /v1/integrations/{_integrationId}/flows/{_flowId}/connections/{_connectionId}/import` runs an import document through a connection as a step of that flow, with the integration's and the flow's settings. The `tools/{_toolId}` and `apis/{_apiId}` forms do the same for a tool or an API.

**Connections and exports**

* MySQL connections support real-time CDC listeners: an RDBMS export with `type: "stream"` reads the binary log. See [Exports](https://developer.celigo.com/api/api-reference/exports-imports-and-tools/exports).
* Google Cloud Storage connections support OAuth 2.0, through Celigo's published iClient or your own. `http.unencrypted.googleProjectId` is required on that auth type (`422 project_id_missing`). See [Connections](https://developer.celigo.com/api/api-reference/connections-and-http-connectors/connections).
* A masked `"******"` value sent back on an encrypted field that already holds a secret keeps the stored secret, on connections, iClients and MCP OAuth providers. Send the mask back to keep a secret: a `PUT` clears most secrets it leaves out.

**Now documented**

These routes already worked, and now have reference pages:

* `POST /v1/imports/{_id}/aiagents/chat` and `POST /v1/aiagents/chat` stream one turn of a conversation with a saved AI agent, or with an unsaved agent document.
* `POST /v1/processors/handlebars` renders a Handlebars template, and `POST /v1/processors/filter` evaluates filter rules against records, without a flow. See [Parsers & Generators](https://developer.celigo.com/api/api-reference/b2b-manager/parsers-and-generators).
* `POST /v1/connections/{_id}/export` and `POST /v1/connections/{_id}/import` run an export or import document through a connection without saving it.

**Corrections**

* The reference drops four operations that never answered on `/v1`: `POST /v1/storage/files/refresh-urls`, the flow-scoped `imports/preview`, and the UI-only `GET /v1/integrations/{_id}/clonefamily` and `iLMIgnore`.
  {% endupdate %}

{% update date="2026-10-22" tags="mcp,feature" %}

## Platform MCP in the Cursor Marketplace and Grok Bot

* Celigo's plugin is in the Cursor Marketplace. It installs the Platform MCP server with Celigo's skills and slash commands, such as `/celigo-troubleshoot`. See [Cursor](https://developer.celigo.com/mcp/connect/cursor).
* The Cursor plugin asks for your **Celigo region** when you install it, so EU, AU, and CA accounts sign in through it too.
* Grok Bot lists the same plugin under **Connect apps**. After one sign-in, every Bot on your account can use the Celigo tools. See [Grok Bot](https://developer.celigo.com/mcp/connect/grok-bot).
* The Grok Bot listing uses `https://api.integrator.io/celigo-mcp` (US). EU, AU, and CA accounts add their region's endpoint as a custom MCP server instead.
  {% endupdate %}

{% update date="2026-10-17" tags="cli,feature,breaking" %}

## CLI 2026.10.1

`@celigo/celigo-cli` 2026.10.1 is on npm: OAuth sign-in, Event Streams topics in the local tree, logic rules in `celigo lint` that `push` and `promote` enforce, and new commands for network policies, proactive alerts, the hosted SFTP file server, and any API path the command groups do not cover.

```bash
npm install -g @celigo/celigo-cli
```

**Changes that can break scripts**

* **Breaking:** nine verbs need full mode instead of operate: `environments enable`/`disable`, `workspace-users enable`/`disable`, `stacks rotate-token`, `on-premise-agents rotate-token`, and `storage create-folder`, `move` and `copy`. So does `imports invoke` without an id, which writes through `POST /v1/imports/preview`. See [Profiles & regions](https://developer.celigo.com/cli/getting-started/profiles).
* **Breaking:** read mode refuses every operate-level verb (runs, invokes, error management, debug toggles, data loads) before any request, where they used to run their reads first. In operate mode, `set` takes only the group's own operational fields.
* **Breaking:** `CELIGO_MODE` only tightens a profile's mode — a session runs in the stricter of the two — so `CELIGO_MODE=full` no longer lifts a `read` or `operate` profile. Raising a stored mode with `config set mode` (or `config unset mode`) needs a person at a terminal who types the new mode back.
* **Breaking:** `storage download`, `storage query -o`, `storage query-results -o`, `jobs download-files -o`, and `download` on `integrations`, `apis`, `tools` and `mcp-servers` refuse to replace an existing file unless `--force`.
* **Breaking:** `set` exits `1` when the server's reply still holds a field's previous value — a `not stored` line on stderr, or one line naming the fields an Integration App locks — where it printed the unchanged document and exited `0`. `update` reports an app's kept fields the same way.
* **Breaking:** `flows set <id> schedule.cron=…`, and any other path beneath `schedule` or `timezone`, is refused before the request; assign `schedule` whole. The old form never changed the flow.
* **Breaking:** `-v` and `--version` print the version only as the first argument, so a subcommand's own `--version` (`connections create`, `http-connectors catalog` and `endpoint-detail`) reaches it.
* **Breaking:** `on-premise-agents rotate-token` asks for confirmation, as `stacks rotate-token` does; pass `-y` in scripts.
* **Breaking:** `state --resource-type` takes only `exports`, `imports` or `integrations`.
* **Breaking:** `recycle-bin list --type storageitems` prints the bare item array instead of `[{"items": […]}]`.
* **Breaking:** `jobs run-stats` no longer takes `--status`.
* **Breaking:** `--limit`, `--since`, `--offset`, `--timeout` and `--page` take whole numbers only (`--timeout 5m` is refused).
* **Breaking:** a create, clone, install, run or invoke is no longer resent after a timeout or a 5xx (a 429 still is); check whether one that timed out landed before you retry it.
* **Breaking:** a local tree that holds a topic is written in manifest layout 6, which CLI 2026.9.6 cannot read; upgrade every CLI that works on the tree.

**Sign-in and profiles**

* `celigo login` signs in through the browser with OAuth (authorization code with PKCE), as an alternative to an API token; `--device` uses the device grant and is chosen on its own without a terminal. `celigo logout` revokes the session, and `profile add --login` creates a profile and signs it in. See [login](https://developer.celigo.com/cli/commands/login).
* `login` without `--profile` or `CELIGO_PROFILE`, and a nameless `profile add`, name the profile after the account and environment `GET /v1/tokenInfo` reports — `<company>-<environment>`, for example `acme-corp-production`. `profile rename <old>` without a new name does the same. A name another profile has is never taken or suffixed, and existing profiles keep their names.
* A profile holds one credential, an OAuth session or an API token, and is bound to one environment: a later sign-in into another environment is refused unless `--allow-account-mismatch`, and a session is sent only to the host it was issued for. API tokens are unaffected, so env-only CI keeps working.
* `celigo config unset <key>` clears a key so its default applies again — the way to clear one, since `config set` refuses an empty value. See [config](https://developer.celigo.com/cli/commands/config).
* `profile whoami` answers from `GET /v1/tokenInfo` for a sign-in too, adding the session's `_auth`, `_issuer`, `_expires_at` and `_scope`.
* Under `profile_pin_policy = strict`, `config`, `profile show`/`add`/`delete`/`rename`, `login` and `logout` refuse a pinned profile like every other command.

**New commands**

* `celigo platform get <path>` sends one GET to any `v1/` path the command groups do not cover, with the profile's token, in every mode. See [platform](https://developer.celigo.com/cli/commands/platform).
* `network-policies` manages the IP allow and deny lists that restrict where API tokens, MCP servers and account sign-in may connect from; `delete` refuses an assigned policy unless `--force`. See [network-policies](https://developer.celigo.com/cli/commands/network-policies).
* `alerts` manages proactive long-runtime alerts, with `add-recipients` and `remove-recipients` across many alerts at once; `flows run-stats <id>` returns the runtime statistics behind the threshold chart. See [alerts](https://developer.celigo.com/cli/commands/alerts).
* `file-server` manages the environment's Celigo-hosted SFTP server (`get`, `enable`, `disable`) and its partner accounts (`accounts list`, `get`, `create`, `set`, `set-password`, `delete`); a password is prompted for or read with `--password-stdin`, never taken as a flag value. See [file-server](https://developer.celigo.com/cli/commands/file-server).
* `exports invoke --connection <id>` reads an export's records through another connection and saves nothing, in every mode; `imports invoke --connection <id>` writes records through another connection (full mode), and `--integration` with `--flow`, `--tool` or `--api` runs it as a step of that parent. See [imports](https://developer.celigo.com/cli/commands/imports).

**The local tree and lint**

* `celigo pull` writes Event Streams topics to `topics/<Name>/topic.json`; `push` creates a topic before the steps bound to it and refuses a draft topic or a `--prune` delete of one a step still binds; `promote` carries topics into the target with their bindings remapped. See [Pull a tree](https://developer.celigo.com/cli/local-tree/pull).
* `celigo lint` adds six logic rules — `hook-function`, `script-syntax`, `lookup-reference`, `router-reference`, `handlebars-syntax` and `topic-binding` — and `push` and `promote` run them at plan time: an error in a new or edited file refuses the item unless `--allow-lint-errors`. See [Lint and resolve](https://developer.celigo.com/cli/local-tree/lint-and-resolve).
* `push --allow-connector-settings` saves the settings values edited in an Integration App's `integration.json` through the app's own save, then reads the integration back and checks every field. See [Push changes](https://developer.celigo.com/cli/local-tree/push).
* A folder moved into a `.celigoignore`d directory is parked, never pushed or pruned; a pull or push that was interrupted leaves its resources `unfinished` until the next run finishes them; a document an editor only reformatted reads as clean.

**Write checks**

* `create`, `update` and `set` check the body against the published API schemas before sending and print what they find as stderr warnings, which never block. The bundled pack is `@celigo/api-specs` 0.2.105 (739 definitions).
* `create`, `update` and `set` refuse the `responseMapping` object wrapper before the request, as `push` already did. Every create refuses a masked `******` value, and a mask is now four or more asterisks, so a lone `*` is a value.
* No write sends a value that is not a string in a field the platform encrypts: `create`, `update`, `set`, `push` and `promote` refuse it with no override.

**Also in this release**

* `tools logs --method`/`--status-code` and `topics list --external-id` take several values, as their help said.
* `integrations clone <id> <environmentId>` and `apis clone --environment` create the clone in that environment; it used to land in the token's own.
* `connections ping` exits `1` when the ping fails, and `flows run` when the platform refuses every export, where both reported success.
* Text a server or a cloned tree supplies loses its terminal control sequences before it is printed; JSON and `--jq` output keep the server's bytes.
* A request that carries the token never follows a redirect, and npm and npx run without the CLI's API tokens in their environment.
* A profile name can no longer reach a path outside `~/.celigo`.

Full command reference in the [Celigo CLI](https://developer.celigo.com/cli) section.
{% endupdate %}

{% update date="2026-10-17" tags="vscode,fix" %}

## Celigo VS Code extension 1.1.2

Version 1.1.2 of the **Celigo** extension (`Celigo.celigo`) is on the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=Celigo.celigo) and [Open VSX](https://open-vsx.org/extension/Celigo/celigo): security and bug fixes, including those of 1.1.1, which was not published on its own.

* A name or path from a pulled tree can no longer break out of the command lines the canvas types into a terminal for *Compare*, *Pull everything* and *Push*: quoting is fixed for PowerShell, cmd.exe and fish, and a line holding a control character is refused with the reason.
* The details panel, the JSON editor, *Open export/import file* and *Open Flow* refuse a tree file reached through a symbolic link; a document `_id` that is not a platform id never reaches a CLI argument; on Windows the CLI is never looked up in the tree's own folder.
* The request and response panels mask more credential names — presigned-URL signatures, `key`, `sig`, `subscription-key`, `passwd`, `session` and others — and the password in a `user:password@host` URL.
* A document whose folder was moved is badged *moved*, not *untracked*, and its *Pull latest* points at `celigo pull`; a document an interrupted pull or push left half-done reads *unfinished*, with the command that finishes it.
* `celigo.cliPath` accepts a path with spaces or quotes and a command with arguments (`pnpm dlx …`, `wsl celigo`), and a change applies to open canvases without reopening them.
* The canvas offers no structural edit on a tool or an API — edit their steps in the JSON; the enable switch and the JSON panel stay.
* The JSON panel no longer applies a draft over text that changed underneath it, keeps what you type while an apply is being written, and its undo covers only your own typing; CRLF documents keep their line endings.

See [VS Code extension](https://developer.celigo.com/cli/vscode-extension).
{% endupdate %}

{% update date="2026-09-30" tags="mcp,feature,breaking" %}

## Platform MCP 0.12.0

* **Breaking:** `search_knowledge_base` is now `search_docs`, and the old name no longer resolves. Refresh the tool list in any client that cached it.
* `list_jobs`, `cancel_job`, and `deploy_template` are now `list_flow_runs`, `cancel_flow_run`, and `install_template`. Only the new names are listed, but a client that cached the old ones can still call them. See [Tools](https://developer.celigo.com/mcp/tools).
* `submit_feedback` files a structured report about a tool — a wrong schema, a misleading description, a missing capability — with Celigo. `dry_run: true` validates the report without filing it.
* `list_edi_transactions` with `_id` and `includeFiles: true` returns `ediFileSignedURL`, a download URL for the raw EDI file that expires in about 15 minutes. List mode rejects `includeFiles`.
* `search_docs` answers list each source's `url` and `excerpt`.
  {% endupdate %}

{% update date="2026-09-25" tags="cli,feature" %}

## CLI 2026.9.6

`@celigo/celigo-cli` 2026.9.6 is on npm: the CLI side of the September API sync — Topics, Storage Query, Tool run history, MCP server connections, custom HTTP connector authoring, and a credential-free way to change a connection's concurrency.

```bash
npm install -g @celigo/celigo-cli
```

**Topics**

* `topics` is a new command group for Event Streams topics — durable, account-level message channels that a topic import step (or `topics publish`) appends to and every subscribed topic export step reads from its own position. Standard verbs plus `dependencies` and `audit`; `set` PATCHes `name` and `description` (the server's whitelist), every other field round-trips through `PUT`. Creating a topic counts against the license's `topics.topicsAllowed`; the message routes need the Event Streams entitlement (`topics_subscription_required`). See [topics](https://developer.celigo.com/cli/commands/topics).
* `topics messages <id>` lists the retained messages oldest first (`{timestamp, payload}`) without moving any listener's read position, cursor-paged with `--after-offset`. `topics publish <id>` appends `{"messages": [...]}` — each message any JSON object of at most 1 MiB; HTTP 200 means the body was valid, so check `responses[].statusCode` per message. `topics purge-messages <id>` drops every retained message and keeps the topic, its retention and its subscriptions. `topics offsets <id> <exportId>` reports a listener's read position (`{hasCursor, offset}`).
* `integrations register-topics` / `deregister-topics <id> <topicIds...>` manage `_registeredTopicIds` like the lookup-cache twins; `topics list --integration <id>` shows an integration's registrations, and `lookup-caches list --integration <id>` now does the same for caches. See [integrations](https://developer.celigo.com/cli/commands/integrations).

**Storage Query**

* `storage query [sql]` runs one read-only SQL `SELECT` over files in Celigo Storage — CSV/TSV, JSON, NDJSON and Parquet; a storage path is the table name (`FROM "orders/sept.csv"`; a folder path ending in `/` reads its same-format files as one table) — submitted as a job, waited for, and printed. Up to 1,000 rows print inline; past that the job envelope (`rowCount`, `columns`, `truncated`) prints instead, with the ways to get the rows. A read-only POST, so it works in read mode; needs the Storage Query entitlement. See [storage](https://developer.celigo.com/cli/commands/storage).
* `-o <path>` saves the whole result set to a file — CSV for a `.csv` path (header in `SELECT` column order), otherwise a JSON array — one page in memory at a time; `--all` prints every row regardless; `--page <n>` prints one page; `--no-wait` prints `{jobId, status}` right after the submit; `-f <file>` reads the SQL from a file. `BIGINT` and `DECIMAL` values arrive as strings.
* `storage query-status <jobId>` and `storage query-results <jobId>` (the same `-o`, `--all` and `--page`) pick a job up later — the rows stay on the server, nothing is resubmitted. `storage download <id> --folder` downloads a folder and everything beneath it as one zip.

**Tool run history and logs**

* `tools request-history <id>` lists a Tool's recorded runs (the UI's Request history panel; the last 5 minutes by default, with `--time-gte`/`--time-lte`, `--status`, `--invoker-type`, `--invoker-id`, `--invoker-integration-id` and `--trace-key-prefix`). `tools execution-logs <toolId> <executionId>` prints one run's trace, and `--details` adds each step's decoded data, fanned-out children and a short-lived download URL for oversized payloads; `tools delete-execution-logs <id> --time-gte <iso> --time-lte <iso>` queues deletion of a range. Runs are recorded for invocations that had logging on and for `tools invoke --log-mode debug`; recording requires the Tool-logging entitlement. These commands were parked in 2026.8.7 while the platform feature was unreleased. See [tools](https://developer.celigo.com/cli/commands/tools).
* `tools logs <id>`, `log-detail <id> <key>` and `delete-logs <id> <keys...>` read and delete the Tool-level request/response envelopes (the store `apis logs` reads for APIs); `tools delete-debug-requests <id> <exportOrImportId> <keys...>` deletes one step's captured debug requests.
* `tools replace-connection <id> <connectionId> <newConnectionId>` and `apis replace-connection` repoint every export and import step that uses a connection in one call, and `apis connections <id>` lists the connections a builder-mode API's steps use. `tools set name=`, `description=` and `aiDescription=` apply as atomic PATCHes. See [apis](https://developer.celigo.com/cli/commands/apis).

**Connections**

* `connections set` changes concurrency without touching credentials: `<adaptor>.concurrencyLevel` and `<adaptor>.targetConcurrencyLevel` (the adaptor block is the connection's `type` — `http.concurrencyLevel`, `netsuite.targetConcurrencyLevel`), `_borrowConcurrencyFromConnectionId` (`=null` clears it), `autoRecoverRateLimitErrors` and `endUserProvidedFields` join the PATCH whitelist. Until now each was refused, because the `GET` + `PUT` round-trip would have re-sent the connection's masked secrets. See [connections](https://developer.celigo.com/cli/commands/connections).
* `connections ping <id> --distributed` pings the Celigo distributed adaptor behind a NetSuite or Salesforce connection; `connections suiteapp-status <id>` reports whether the Celigo SuiteApp and legacy bundle are installed in the connected NetSuite account, and their versions; `connections debug-logs <id> --resource <exportOrImportId>` narrows the shared debug stream to one step's traffic.

**MCP servers and end users**

* `mcp-servers connections <id>` lists the connections a server attaches (its own and its tools' overrides) as full documents; `--end-users` lists instead the end users' own `mcpChild` copies — the credentials each end user supplied for a connection with `endUserProvidedFields` — the only route that serves them. See [mcp-servers](https://developer.celigo.com/cli/commands/mcp-servers).
* `end-users connection <connectionId>` reads one of those copies (masked) and `end-users delete-connection <connectionId>` soft-deletes it so the end user reconnects with fresh credentials; the account's own connection is untouched. See [end-users](https://developer.celigo.com/cli/commands/end-users).
* `mcp-servers download <id>` saves a server as a template ZIP — the server, its prompts, its tools and their dependencies, the artifact a marketplace MCP-server template is authored from (a server that publishes APIs or file resources is refused). `mcp-servers install-template <templateId>` installs a published one from `templates marketplace --kind mcpserver`, the typed catalog that carries each entry's `type`. `mcp-servers set policies=` and `_networkPolicyId=` apply as atomic PATCHes.

**Custom HTTP connectors**

* `http-connector-resources` is a new group with the standard verbs for the resources (API groupings) of a custom connector created with `http-connectors create`, which the nested `http-connectors resources` / `resource` reads only browse. Create the connector first and name it as `_httpConnectorId`; `update` is a full replace, so prefer `set`. See [http-connector-resources](https://developer.celigo.com/cli/commands/http-connector-resources).
* `http-connector-endpoints` is its twin for the endpoints (method + relative URI operations) under those resources, which the nested `http-connectors endpoints` / `endpoint` reads only browse. Create the resources first and list them in `_httpConnectorResourceIds`; `update` is a full replace here too. See [http-connector-endpoints](https://developer.celigo.com/cli/commands/http-connector-endpoints).

**Also in this release**

* `subscriptions api-usage-summary` returns monthly API invocation totals for the last thirteen months across every environment, and `api-usage-environments` this month's counters per environment; both also fold into `subscriptions usage`. `integrations revision-errors <id> <revisionId>` says why a pull or revert revision failed. `edi-transactions export [--file-type X12|EDIFACT] [--start] [--end]` exports the transaction log (the last 24 hours by default) as a CSV behind a 15-minute signed URL. See [subscriptions](https://developer.celigo.com/cli/commands/subscriptions).
* A `[y/N]` confirmation — `delete`, the purge and cancel verbs, `push --prune`, `promote --prune` — that cannot be asked because stdin is not a terminal is refused with: `Confirmation needs a person, and stdin is not a terminal. An agent must not answer for the person: ask them in the conversation, and re-run with --yes only once they have approved this exact command. Scripts and CI pipelines pass --yes.` The previous refusal, `pass --yes to proceed`, was an instruction an agent could follow on its own. The exit code (1) and `--yes` are unchanged. See [Scripting patterns](https://developer.celigo.com/cli/using-the-cli/scripting).
* `celigo lint` bundles `@celigo/api-specs` 0.2.14 (704 schema definitions, the 2026-09-12 spec build); no finding in the test corpus changes.

Full command reference in the [Celigo CLI](https://developer.celigo.com/cli) section.
{% endupdate %}

{% update date="2026-09-14" tags="vscode,feature" %}

## Celigo VS Code extension 1.1.0

Version 1.1.0 of the **Celigo** extension (`Celigo.celigo`) is on the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=Celigo.celigo) and [Open VSX](https://open-vsx.org/extension/Celigo/celigo): the live overlay's error counts open the errors themselves, and retry, resolve and pull-latest run from the canvas through the CLI.

* Clicking a step's live error count lists its open errors in the details panel's *Live* section — code, classification, whether it can be retried, when it occurred, the message, the `errorId` and trace key — read through `celigo flows errors` in read mode; the newest 50, with the terminal line for the rest. *Open ›* on an error opens an error view: an **Error** tab with every field, a **Record** tab with the retry data, and **Request** / **Response** tabs with the stored HTTP pair (header and query values whose name reads as a credential are redacted). The panel shows at most 512 KB of a payload — past that only its size — and *Open in editor* opens the whole payload as an untitled JSON document.
* **Retry** and **Resolve** act on one error, the checked errors, or every open error on the step; anything bulk and every resolve asks first, in a modal naming the count, the step and the profile. Each runs `celigo flows retry-errors` or `celigo flows resolve-errors` under the tree's profile in that profile's mode — a read-mode profile gets the CLI's refusal in the panel — and the CLI's outcome line is the list's note. Retry data, requests and responses never reach a log, a modal or a command line.
* *remote changed* is now a confirmed content difference: when the server's `lastModified` differs from the pulled token, the extension runs `celigo diff <path> --format json` and shows the badge only for reported differences. A token moved by a flow run or a debug toggle with identical content is *timestamp moved* — no badge. A diff that could not run says so instead of claiming either.
* **Pull latest** under the drift note takes the server's copy of the document (`celigo pull --force <path>`, this file only; never `--prune`), asking first when the document has local edits or an unsaved editor buffer (*Save and continue* / *Revert and continue*); **Compare** runs the quoted `celigo diff` line in a terminal and **Pull everything** the plain incremental pull. *Push* on an unsaved buffer offers **Save all and continue**.
* The live overlay refreshes on its own every `celigo.canvas.liveRefreshSeconds` (new setting; default `60`, values below `15` raised to `15`, `0` for on demand only) while the canvas is visible and the window focused. The toolbar shows quiet *N open errors* and *remote changed* badges and a *Live* button with a status dot in place of the old summary pill.
* The details panel collapses to a rail (**Cmd/Ctrl+\\**, `Celigo: Show or Hide the Details Panel`), every section folds from its header, and a splitter sets the JSON editor's share of the height; the resize handle is now visible. Placeholder steps and empty branches can be removed from their `⋯` menus, and *Move left* / *Move right* are offered only where a neighbouring step exists.

Lint findings, the live overlay, retry, resolve, pull latest and push need the [Celigo CLI](https://developer.celigo.com/cli) 2026.9.1 or later; rendering and editing work without it. See [VS Code extension](https://developer.celigo.com/cli/vscode-extension).
{% endupdate %}

{% update date="2026-09-14" tags="cli,feature" %}

## CLI 2026.9.5

`@celigo/celigo-cli` 2026.9.5 is on npm: a profile pinned away from the machine's active profile is announced on every command that targets it, and a machine-wide policy can refuse it. Versions 2026.9.2 through 2026.9.4 were never published; this release carries their content.

* A `--profile` or `CELIGO_PROFILE` value that differs from the machine's active profile is announced by every command that targets it, reads included, with the divergence in the line — `celigo: profile 'acme-sandbox' → api.integrator.io (pinned with --profile; the active profile is 'acme-prod')` — once per invocation, on stderr. A pin that names the active profile prints nothing extra. This is the shape of an agent session whose `--profile` did not follow a `celigo profile use` typed in another terminal. See [Profiles & regions](https://developer.celigo.com/cli/getting-started/profiles).
* `celigo config set profile_pin_policy strict` (machine-wide; the default is `allow`) turns that announcement into a refusal: a pinned profile that differs from the active one fails before any request, exit 1, and the message tells an agent not to run `profile use` or change the policy to get past it — `celigo profile use` becomes the only way an account is selected on the machine. `profile whoami --profile <name>` still answers; `config`, `profile`, `skills`, the offline tree verbs and `promote --to` are unaffected. Loosening `strict` to `allow` needs a person at a terminal typing `allow` back; off a terminal it is refused. See [Configuration reference](https://developer.celigo.com/cli/getting-started/configuration).
* A managed policy file — `/etc/celigo/policy.json` on macOS and Linux, `%ProgramData%\Celigo\policy.json` on Windows, containing `{"profile_pin_policy": "strict"}` — forces `strict` from outside the user's account and locks the user-level key (`config set` refuses it; `config get` prints `(managed by …)` and `config show` adds `profile_pin_policy_managed_by`). It is tighten-only: `allow`, an absent key or no file changes nothing. The CLI never writes it; a malformed file is reported once on stderr and ignored.
* `celigo profile use` now says which sessions the switch does not reach — those pinning a profile with `--profile` on each call or with `CELIGO_PROFILE` — with the `profile_pin_policy strict` line that refuses such pins, and whether the shell it was typed in has `CELIGO_PROFILE` exported to another profile.

Full command reference in the [Celigo CLI](https://developer.celigo.com/cli) section.
{% endupdate %}

{% update date="2026-09-13" tags="vscode,feature" %}

## Celigo VS Code extension 1.0.0

The **Celigo** extension (`Celigo.celigo`) is on the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=Celigo.celigo) and [Open VSX](https://open-vsx.org/extension/Celigo/celigo): the Flow Builder canvas in VS Code and Cursor for the tree `celigo pull` writes. Full details in [VS Code extension](https://developer.celigo.com/cli/vscode-extension).

```bash
code --install-extension Celigo.celigo
```

Or search **Celigo** (publisher Celigo) in the Extensions view, or type `ext install Celigo.celigo` in Quick Open.

**The Flow Canvas**

* Open a pulled tree's `flow.json`, `tool.json`, or `api.json` and run `Celigo: Open Flow Canvas`, or press Cmd/Ctrl+Shift+V in the editor to open it beside the document: sources, destinations and lookups, branchings with their branch names, merge points, terminals, and each step's step components (filters, transformation, mapping, hooks, response mapping, error handling) as chips, laid out the way integrator.io's Flow Builder draws them. The graph is the CLI's own `celigo flows graph` engine. See [flows](https://developer.celigo.com/cli/commands/flows).
* Steps resolve through the tree, not just the file: names, categories, the application behind each connection, and the bindings of a `celigo pull --neutral` tree. `celigo status` badges (`modified`, `missing`, `untracked`) mark the flow and each step's document; `celigo lint` findings sit on the steps they concern.
* The canvas follows the editor — unsaved edits re-render as you type, the caret's step is highlighted, a double-click jumps to the step's definition — and drills down: flows started by this one (`_runNextFlowIds`) and an instance's abstract flow open in their own canvas.
* *Find node* (Cmd/Ctrl+F) matches step, application, resource, connection, and branch names; Enter / Shift+Enter walk the matches.

**The details panel**

* The selected step's JSON in an editor: its object in the flow (*Step*), the export or import document it references (*Resource*), or the whole document when nothing is selected. In *Edit* mode, *Apply* (Cmd/Ctrl+S) writes canonical JSON over exactly the value's range, linted inline and refused for instance flows and the `responseMapping` wrapper — the canvas's own guards.
* A *Related* tree lists everything the step reaches, in Flow Builder order: one item per step component (hooks per stage, each with its script), the export or import document with its connection and other references, and the flow-level links. Clicking a step component chip on a card opens the same item.
* Scripts and prompts load as their own tabs: a hook's `script.js` opens at the function the hook names; an AI agent's or guardrail's `instructions.md` opens with Markdown highlighting. Both are editable in *Edit* mode and written back verbatim.

**Editing and push**

* *Edit* turns on the Flow Builder affordances: `+` on an edge adds a step or a branching; step menus add, remove, and reorder steps and toggle error handling; branch ends merge, merge points unmerge, branchings gain branches and names; the *Enabled* / *Disabled* switch toggles `disabled`. Every edit is written to the document as canonical JSON through the CLI's mutation rules, so undo works and `celigo status` sees exactly the change.
* *Push* runs `celigo push --dry-run`, then `celigo push`, in a terminal for the flow and every referenced file with local changes — an import edited in the *Resource* tab, a hook's `script.js`, an AI agent's `instructions.md`. `--prune` is never passed. The extension holds no token: anything that needs credentials runs the installed `celigo` binary, and `celigo push` stays the only writer.

**Layout, export, live state**

* `celigo.canvas.direction` (`horizontal`, the default, or `vertical`) lays the canvas out left to right or top to bottom; *View › Vertical layout* flips one canvas without changing the setting. The vertical layout is Flow Builder's layout transposed — same rules, same spacing — with the sources in a row centred over the trunk.
* *Export* saves a PNG or SVG of the whole graph, or copies a Mermaid diagram (`flowchart LR` or `TD`, following the canvas) that renders natively in a GitHub pull request description.
* With `celigo.canvas.liveOverlay` on (off by default), 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 moved since the pull. Nothing is written.

**Requirements and Restricted Mode**

* VS Code 1.104+ or Cursor. Rendering and editing work without the CLI; lint findings, the live overlay, and push need the [Celigo CLI](https://developer.celigo.com/cli) 2026.9.1 or later — the release that introduced `celigo pull` and the tree the canvas opens — on `PATH` (`npm install -g @celigo/celigo-cli`) or at `celigo.cliPath`. When no `celigo` answers, the extension offers once per session to run it through `npx`, pinned to that version.
* In an untrusted workspace (Restricted Mode) the canvas, 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, and push stay off until you trust the workspace (*Live* and *Push* say so in their tooltips), then open canvases refresh on their own. `celigo.cliPath` is a restricted setting.
* Settings: `celigo.cliPath` (`celigo`), `celigo.canvas.lint` (`true`), `celigo.canvas.liveOverlay` (`false`), `celigo.canvas.showComponents` (`true`), `celigo.canvas.direction` (`horizontal`). Commands: `Celigo: Open Flow Canvas`, `Celigo: Open Flow Canvas to the Side`, `Celigo: Copy Flow as Mermaid`, `Celigo: Push Flow with celigo (plan first)`, `Celigo: Refresh Live Overlay`.
  {% endupdate %}

{% update date="2026-09-13" tags="cli,feature" %}

## CLI 2026.9.1

`@celigo/celigo-cli` 2026.9.1 is on npm: the account as a local file tree you pull, edit, diff, and push back; promotion of that tree into another account or environment; flow graphs from the terminal; connector-first HTTP connections; Integration App settings; and EDI file definition rules generated from a specification PDF.

```bash
npm install -g @celigo/celigo-cli
```

**Profile safety**

* A `--profile` (or `CELIGO_PROFILE`) that names no profile is an error before any request — `Profile 'x' does not exist. Available: a, b (run 'celigo profile list').` — even when `CELIGO_API_TOKEN` or `--token` would supply a token. It used to resolve to an empty profile and fail later. See [Profiles & regions](https://developer.celigo.com/cli/getting-started/profiles).
* `CELIGO_PROFILE` binds a shell, agent session, or CI job to one profile. Resolution is `--profile`, then `CELIGO_PROFILE`, then the active profile; `celigo profile use <name>` prints the `export CELIGO_PROFILE=<name>` line to paste.
* Every command that writes names its target first on stderr — `celigo: profile 'acme-sandbox' → api.integrator.io` — and confirmation prompts carry the same label. Reads print nothing, stdout is untouched, and there is no opt-out.

**The local tree**

* `celigo pull` writes the account, or one integration with `--integration <id>`, as a file tree: one folder per resource holding a fixed-name document (`exports/<Name>/export.json`, `integrations/<Name>/flows/<Flow>/flow.json`), typed subfolders of links to everything the document references, and editable companions beside it — a script's `script.js`, a lookup cache's `data.json`, an AI agent's `instructions.md`. Pulls are incremental, a server-side rename is a folder move, and locally edited files are never overwritten without `--force`. Read mode. See [The local tree](https://developer.celigo.com/cli/local-tree).
* `celigo status` lists `modified`, `missing`, `untracked`, and `moved` files offline; `celigo diff` compares the tree with the live account field by field, with JSON-pointer paths, and never prints a secret (a replaced `******` renders as `(set)`). Both take `--exit-code` for CI gates. See [Status and diff](https://developer.celigo.com/cli/local-tree/status-and-diff).
* `celigo push` writes edits back: `PUT` for modified documents, create for new files, delete only with `--prune`. The plan prints before anything is sent, and `--dry-run` exits `1` when any item is refused, so a CI gate cannot pass a payload the push would refuse. Full mode. See [Push changes](https://developer.celigo.com/cli/local-tree/push).
* Every write holds a per-file optimistic lock — one `GET` before each `PUT` or `DELETE`, refused when the server copy changed since the pull (`celigo pull --force <path>` to take theirs, `push --force-remote` to overwrite).
* New files reference each other by relative path (`"_connectionId": "connections/_new-store.json"`) and are created in dependency order, so an import is never sent before its export's id exists.
* Push refuses, with no override, a document whose `_id` is not the tracked resource's, a `connections`/`iclients`/`mcp-oauth-providers` payload still holding `******`, and the `responseMapping` object wrapper — the platform accepts it and erases the step's mappings.
* Interrupting a push is safe: creates record their intent before the `POST`, so the next push adopts what landed as `recovered` instead of creating it twice; Ctrl-C finishes the requests on the wire and exits `130`.
* A tree is bound to the account it was pulled from — API host plus the token owner's user id — not to a profile name. `pull`, `diff`, and `push` refuse another host or another token owner however the profile was selected; `--allow-account-mismatch` on `pull` and `push` is the only override. See [Teams, git, and CI](https://developer.celigo.com/cli/local-tree/workflow).
* `celigo pull --neutral` writes an environment-neutral tree: no `_id`s, every reference as a tree path, and per-environment resources (connections, iClients, stacks, on-premise agents) as `@bindings/` keys (`"_connectionId": "@bindings/connection/shopify"`) resolved from an untracked `.celigo/bindings.json`, so one git branch per environment merges cleanly. Decided at the first pull; a standard tree is not converted in place. See [Neutral trees](https://developer.celigo.com/cli/local-tree/neutral-trees).
* `celigo lint` validates the tree offline against the platform's published schemas — the `@celigo/api-specs` package, pinned into the release and refreshed from npm at most once a day (`CELIGO_NO_SPEC_UPDATE=1` or `celigo config set specs_auto_update false` opts out). It reports unknown fields, type mismatches, enum misses, masked placeholders, unresolved references, and scope violations; a shape the account already exhibits downgrades to a warning, the `responseMapping` wrapper never does; `--strict` promotes warnings to errors. See [OpenAPI specs](https://developer.celigo.com/api/using-the-api/openapi-specs).
* `celigo resolve <ref>` maps a link, tree path, `type:id`, bare id, or `@bindings/` key to the real document; `--open` launches it in VS Code. See [Lint and resolve](https://developer.celigo.com/cli/local-tree/lint-and-resolve).
* `pull`, `diff`, and `push` run their requests `--concurrency <n>` at a time (1–16; `CELIGO_CONCURRENCY`; default 8). A `.celigoignore` in the tree root keeps parts of the account out of the tree, in gitignore syntax.
* Integration App documents are pull-only, and a tree pulled as one integration never writes into another (`--allow-dependencies` overrides). Celigo Storage is pull-only too; `--storage-files` downloads file contents.

**Promote**

* `celigo promote --to <profile>` writes the tree into another account or environment — Sandbox to production inside one account, or account to account. State per target lives in a committed `.celigo/targets/<name>.json` (source id → target id, lock token, how each connection resolved), so the second promote is an update, not a second copy. Plan first, `--dry-run`, `--prune` for deletes, `--force-remote` for a target copy edited since the last promote. Full mode on the target profile; neutral trees are not promotable in this version. See [Promote to another account](https://developer.celigo.com/cli/local-tree/promote).
* Connections, iClients, stacks, and on-premise agents are never promoted with credentials: each resolves to a `--map connection/<source>=<target-id>` pin, a same-name resource in the target, or a credential-less shell created with `--create-connections` (masked values become `REPLACE-IN-UI` placeholders you fill in through the target's UI or `connections update`). `--adopt-by-name` maps hand-built namesakes instead of refusing the create.
* `celigo diff --target <name>` shows what promote would send, in any mode of the target profile.
* In CI the target has its own token: `CELIGO_TARGET_API_TOKEN` and `CELIGO_TARGET_BASE_URL`. `CELIGO_API_TOKEN` and `--token` belong to the source session and never reach the target; a target with neither a stored token nor the variable is refused.

**Flow graphs from the terminal**

* `celigo flows graph [ref]`, `apis graph`, and `tools graph` render a flow's, API's, or Tool's builder graph from the local tree, offline — the same sources, steps, branchings, merges, and terminals the Flow Builder canvas draws, each step with its step components (filters, transformation, mapping, hooks, response mapping, error handling). No profile or token needed. See [flows](https://developer.celigo.com/cli/commands/flows).
* Output is `--as json` (default), `--as mermaid` (renders natively in GitHub pull requests), or `--as dot`; `--status` adds each step's local-tree state, `--no-components` leaves the step component chips out of the mermaid and dot output, and `--file` renders any document (`-` for stdin).
* The same graph opens as an interactive Flow Builder canvas in VS Code and Cursor through the [Celigo extension](https://marketplace.visualstudio.com/items?itemName=Celigo.celigo) 1.0.0, released the same day (see its entry above).

**Connector-first HTTP connections**

* `http-connectors match <url|name>` names the pre-built connector for an API and what its connection form prescribes: `authTypes` and `defaultAuth`, the `globalIClientId` when Celigo ships a shared OAuth app, the fields you `mustSet`, `scopes`, the version, and the base URIs. A URL is confirmed against the name-related connectors with detail requests; `--scan` confirms every connector. See [http-connectors](https://developer.celigo.com/cli/commands/http-connectors).
* `http-connectors list --search <term>` filters by name or legacy application id, and the table gains a `legacyId` column.
* `connections create --connector <id|name>` scaffolds the connection the connector's own form saves — `type`, `assistant`, the connector, API, and version ids, its default `http.auth.type`, and every applicable pre-configured field — and merges your body over it (`--api`, `--version`, `--auth-type`, `--name`, `--dry-run`). The fields the form makes you set are listed on stderr, never invented. See [connections](https://developer.celigo.com/cli/commands/connections).
* A hand-written `type: http` connection whose base URI a pre-built connector serves is refused before the `POST`, naming the connector (`--allow-raw-http` proceeds deliberately), and so is a connector connection whose `http.auth.type` the connector's form does not offer (`--auth-type <type>` confirms it). The API accepts both shapes silently; neither authorizes the way the connector expects.
* `connections get` explains an empty `http._iClientId` on a connector OAuth connection: a stderr note says whether it authorizes through Celigo's global iClient or still needs your own.
* `edi-profiles create --tp-connector <id|name>` scaffolds the partner's EDI profile from its trading partner connector (file type, X12 version, ISA/GS flags and qualifiers) and lists the interchange and group identifiers left to you; `connections create --tp-connector <id|name>` links the connection (`_tpConnectorId`), refuses a transport the connector does not provision, and lists the fields its form requires. A hand-written `as2`/`ftp`/`s3`/`van` connection or EDI profile named after a partner that has a connector gets a stderr note, never a refusal. See [edi-profiles](https://developer.celigo.com/cli/commands/edi-profiles).

**Integration App settings**

* `integrations settings <id>` lists an Integration App's settings form flat — field name, type, current value, section, store id, `flowId` — with `--store`, `--section`, `--refreshable`, and `--field-name` for one field's full definition. `integrations refresh-settings-metadata <id> --field-name <name>` re-pulls a field's option list through the app's connector code. See [integrations](https://developer.celigo.com/cli/commands/integrations).
* `integrations persist-settings <id> <fieldName>=<value>…` saves through the connector, nests a multi-store app's values under the store id (`--store <id>`), and re-reads the document to report each field `saved`, `unchanged`, or `not-saved` — the platform answers `success: true` even when it saved nothing, so the exit code follows the field report. A body nothing on the form can locate is `unverified` and exits `1` unless `--allow-unverified`. Full mode.

**EDI file definition rules from a specification PDF**

* `file-definition-rules generate <pdf> --document-type <n>` generates X12 or EDIFACT file definition rules from an implementation guide and returns both artifacts: `generationFdr`, a complete file definition body, and `parsingFdr`, wrapped as `{resourcePath, fileDefinition}` for an export or import. `parse` returns the parsing rules only, `document-types` lists the supported transaction sets, and `status <requestId>` reads a job (`--wait`). See [file-definition-rules](https://developer.celigo.com/cli/commands/file-definition-rules).
* Jobs poll to completion by default (`--timeout`, 420 s; `--no-wait` prints the `requestId`). Submissions are capped at 10 per hour per account, so a missing or non-PDF file, a file over 50 MB, or a document type outside the catalog is refused locally before anything is sent. Nothing is persisted — pipe the result into `file-definitions create`, adding the `globalId` the generator does not emit. Read mode blocks the submissions; operate mode allows them. See [file-definitions](https://developer.celigo.com/cli/commands/file-definitions).

**Also in this release**

* The HTTP client honors a 429's `Retry-After` (delay-seconds or an HTTP-date, capped at 60 s) instead of an exponential guess, and a request that times out says so before it retries — a write that timed out may still have landed.
* Richer `--help` for `flows`, `apis`, `tools`, `guardrails`, `ai-agents`, `lookup-caches`, and `edi-profiles`, and one-line group summaries in `celigo --help`.
* `exports invoke <id>` states that a `--file` or piped body is ignored when an id is given — the saved export is invoked exactly as stored. See [exports](https://developer.celigo.com/cli/commands/exports).

**Fixed**

* `flows retry-errors`, `resolve-errors`, `assign-errors`, `unassign-errors`, and `delete-resolved-errors` report what the API did, not how many keys were sent: retry names the job it queued (`Retry queued for N record(s). (job <id>)`), assign and unassign count the ids the API echoes, resolve and delete count only ids that are gone. Keys that matched nothing go to stderr, a run that changed nothing exits `1`, and `retry-errors` rejects an all-digit key (an `errorId`, not a `retryDataKey`) up front.
* `edi-profiles list`, `environments list`, `lookup-caches list`, `mcp-oauth-providers list`, and `tags list` work again by default. Their endpoints reject the `include` projection every projected `list` has sent since 2026.8.1, so only `--fields all` worked. Rows are now trimmed client-side to the same columns.
* `set` never `PUT`s a `******` mask it did not ask for: the GET + modify + PUT fallback refuses when the fetched document itself carries masked credentials and points at `update` with the real values. In operate mode, `set` can no longer restructure an allowed scalar through a dotted path (`disabled.foo=1`).
* `apis set timeoutPeriod=…` and `apis set pagination.enabled=…` go through the whitelisted atomic `PATCH`, the route on which a full `PUT` silently drops API fields. See [apis](https://developer.celigo.com/cli/commands/apis).
* On Windows, the background skills install no longer opens a console window, and `celigo skills install`, `list`, and `update` no longer fail with `EINVAL`.
* Two `list` columns that could never populate are gone: `http-connectors list` shows `lastModified` instead of `published`, and `syncs list` drops `lastExecutedAt` — run timing lives on `sync-jobs list`.
* Correction to the CLI 2026.8.8 note below: the camelCase `/v1/mcpServers` route did affect reads — the projected `GET` that `mcp-servers list` issues returned `422`, so 2026.8.7's `mcp-servers list` failed on every call. The 2026.8.8 switch to the documented lowercase path fixed it.

**Security**

* An id argument cannot change the request path. A positional id (`<id>`, `<flowId>`, …) holding `/`, `?`, `#`, or whitespace is refused before any request; interpolated into a path, `int1?x` turned a settings `PUT` into a `PUT` on the integration document itself — the verb that erases every field it omits.

Full command reference in the [Celigo CLI](https://developer.celigo.com/cli) section.
{% endupdate %}

{% update date="2026-08-31" tags="api,feature" %}

## OpenAPI specs on npm

* `@celigo/api-specs` (MIT) publishes the 44 OpenAPI documents behind the API reference, one self-contained file per resource under `dist/` with no cross-file `$ref`s. Install with `npm install --save-exact @celigo/api-specs`. See [OpenAPI specs](https://developer.celigo.com/api/using-the-api/openapi-specs).
* Every document declares `openapi: 3.2.0`, the four regional `servers` (US, EU, AU, CA), and the `bearerAuth` security scheme. Tools that parse only OpenAPI 3.0 or 3.1 may reject the documents.
* The specs are prescriptive: internal operations, deprecated fields, and retired enum values are removed before publishing. A request that validates against them is supported; the live server accepts more than the specs describe.
  {% endupdate %}

{% update date="2026-08-29" tags="cli,feature" %}

## CLI 2026.8.8

`@celigo/celigo-cli` 2026.8.8 is on npm.

```bash
npm install -g @celigo/celigo-cli
```

* **New: `exports reset-cursor <id>`** resets the CDC cursor on a stream (Debezium) export — the platform deletes the stored offset and restarts the stream consumer, no flow toggle required. The server refuses a reset while the saved `cdc.snapshotMode` is `initial_only`; `--snapshot-mode when_needed` flips the mode and resets in the same save, re-arming a one-shot snapshot export without cloning and deleting it. The save is fail-soft (HTTP 200 either way): the CLI reads the `_cursorResetStatus` verdict and exits non-zero on refusal. See [exports](https://developer.celigo.com/cli/commands/exports).
* **Fixed:** `mcp-servers` now calls `/v1/mcpservers` (lowercase), exactly as the API reference documents. Reads were never affected, but writes through the undocumented camelCase path could leave a live MCP server serving a stale `tools/list` for 15+ minutes after Tool schema edits. If you script against the REST API directly, use the documented lowercase path. See [mcp-servers](https://developer.celigo.com/cli/commands/mcp-servers).
  {% endupdate %}

{% update date="2026-08-23" tags="api,feature" %}

## AU and CA data centers

Data and tokens never cross a region boundary, so each region needs its own token and base URL.

* REST API base URLs `https://api.au.integrator.io` (AU) and `https://api.ca.integrator.io` (CA) join the existing US and EU hosts. Sign in at `au.integrator.io` or `ca.integrator.io`. See [Environments & regions](https://developer.celigo.com/api/getting-started/environments).
* Platform MCP answers at `https://api.au.integrator.io/celigo-mcp` and `https://api.ca.integrator.io/celigo-mcp`. OAuth sign-in routes to the tenant that matches the endpoint you configure. See [Connect a client](https://developer.celigo.com/mcp/connect).
* The CLI targets a region through a profile's base URL: `celigo profile add au --api-token "$AU_TOKEN" --api-base-url https://api.au.integrator.io`. See [Profiles & regions](https://developer.celigo.com/cli/getting-started/profiles).
* AU data stays in Australia and CA data stays in Canada, the same in-region residency the EU data center provides.
  {% endupdate %}

{% update date="2026-08-23" tags="cli,feature" %}

## CLI 2026.8.7

`@celigo/celigo-cli` 2026.8.7 is on npm: 34 new commands across end-user management, MCP server access, documentation search, product feedback, and API request logging.

```bash
npm install -g @celigo/celigo-cli
```

**Breaking and renamed**

* **Breaking:** `subscriptions usage` returns one combined object covering account, API, entitlement, historical monthly, EDI label-printing, storage, and syncs usage; license-gated sources appear inline as `{"error": ...}` entries. Anything parsing the old bare output should pipe `--jq .usage`, which returns exactly the previous payload. See [subscriptions](https://developer.celigo.com/cli/commands/subscriptions).
* `users` is now `workspace-users`: your team's account collaborators, distinct from the new `end-users` — external people who sign in to use your MCP servers. `users` is retained as a hidden alias, so existing invocations keep working.

**End-user management**

* `end-users` manages external MCP end users: `list` (with `--provisioned-by invite|jit`), `effective-access` for one user's compiled MCP access with each grant's source, `invite --email` (one address, or up to 100 per call), and `revoke`. Invitations send real emails.
* `groups` and `roles` bundle MCP grants for assignment: standard CRUD, plus `groups add-members` / `remove-members`.
* `mcp-servers effective-access <id>` lists every end user who can reach a server and their effective tools. `assign-end-users` and `assign-groups` bulk-assign a server's capabilities (`tool:`, `api:`, and `pset:` capability-set handles) to up to 100 targets per call; an assignment replaces each listed target's grant for that server. See [mcp-servers](https://developer.celigo.com/cli/commands/mcp-servers).

**Docs search and feedback**

* `docs search` asks Celigo's product documentation a question and returns an AI-generated answer with cited sources. `--thread` continues a conversation. Allowed in read mode.
* `feedback submit` sends structured product feedback (`--category`, `--severity`, `--command`, `--expected`, `--actual`), with the CLI version and runtime context attached automatically — never command arguments or payload data. Works in every mode, and `feedback submit --help` includes a worked incident-report example.

**API Builder request logging**

* `apis request-history <id>` lists an API's logged request executions — recorded while `logging.mode` is anything but `no_logging` — with time, status-code, method, trace-key-prefix, remote-IP, and URI filters.
* `apis execution-logs <apiId> <executionId>` prints one execution's trace; `--details` adds decoded step payloads, fan-out children, and payload download URLs. `apis delete-execution-logs` queues deletion of a date range.
* `apis set` applies `logging.mode`, `logging.debugUntil`, and `traceKeyTemplate` atomically via `PATCH` — the server ignores `logging` on a full `PUT`. See [apis](https://developer.celigo.com/cli/commands/apis).

**Also in this release**

* `tools invoke <id>` runs a Tool synchronously; `--log-mode debug` records the run. `tools clone` copies a Tool into a target integration — Tools that reference connections require a `connectionMap`. See [tools](https://developer.celigo.com/cli/commands/tools).
* `storage get <ids...>` fetches metadata for up to 100 files in one call, `storage move` moves up to 100 items (`--name` renames a single item as it moves), and `storage cancel-upload` aborts a stuck multipart upload. See [storage](https://developer.celigo.com/cli/commands/storage).
* `http-connectors catalog` and `http-connectors endpoint-detail` read the staged form-metadata summaries and scoped detail documents. See [http-connectors](https://developer.celigo.com/cli/commands/http-connectors).
* `integrations register-lookup-caches` and `deregister-lookup-caches` attach and detach lookup caches. Registering also writes an `aliases[]` entry, which must be removed before deregistering. See [integrations](https://developer.celigo.com/cli/commands/integrations).
* `flows get --merge-instance` returns an instance flow's effective config, and `flows list` adds `--name`, `--disabled`, `--include-instances`, `--abstract-flow-id`, and `--sort-by lastExecutedAt`. See [flows](https://developer.celigo.com/cli/commands/flows).

Full command reference in the [Celigo CLI](https://developer.celigo.com/cli) section.
{% endupdate %}

{% update date="2026-08-22" tags="api,feature" %}

## August API updates

Everything below is live in production and documented in the [API reference](https://developer.celigo.com/api).

* End-user management joins the reference: [End Users](https://developer.celigo.com/api/api-reference/account-and-admin/end-users), Groups, and Roles cover listing end users, compiling one user's effective MCP access, single and bulk invites (up to 100 addresses), revocation, group membership, and role CRUD.
* MCP servers document `permissionSets[]` — embedded capability sets (`accessLevel: read|write`, `_toolIds`, `_apiIds`) referenced in grants as `pset:<_id>` — plus per-server effective access and bulk capability assignment to end users or groups, up to 100 per call. See [MCP Servers](https://developer.celigo.com/api/api-reference/ai-and-mcp/mcp-servers).
* MCP server `prompts[]` entries document their server-generated `_id`.
* Tool invocation documents the `x-log-mode` header: only `debug` takes effect on a direct call; `basic`, `standard`, and `detailed` apply when an AI agent or MCP server invokes the Tool.
* Integrations document the lookup-cache registration endpoints' alias side effect: registering writes an `aliases[]` entry per cache, and deregistering fails with `400` until the alias is removed.
* Corrections to the APIs spec: mapping `dataType` is documented as required, `hardCodedValue` casing is fixed, and `logging` is writable only via `PATCH` — the server ignores it on `PUT`.
  {% endupdate %}

{% update date="2026-08-11" tags="mcp,feature,breaking" %}

## Platform MCP 0.11.0

Connected clients pick these up automatically. Full details in [Tools](https://developer.celigo.com/mcp/tools).

* **Breaking:** `list_jobs` without `_id` requires `type` plus a scope — `_integrationId` or `_flowId` for flow runs, `_flowJobId` or `_parentJobId` for export and import jobs — and returns 25 jobs unless you set `limit`. The `status_in`, `_exportId`, and `_importId` filters are removed.
* **Breaking:** `delete_lookup_cache_data` without `key` or `keys` is rejected unless you pass `all: true`, which purges every entry.

**New tools**

* `list_current_jobs` lists the jobs in flight right now — queued, running, or canceling.
* `patch_flow` changes single flow fields with JSON Patch `replace` — enable or disable, rename, arm debug logging — without a full-document `upsert_flow`.
* `list_storage_items`, `upsert_storage_item`, `get_storage_file_download_url`, `restore_storage_item`, and `cancel_storage_upload` manage Celigo Storage files and folders. Inline uploads are capped at 4 MB; `presignedUpload` streams larger files from disk.
* `list_users` and `manage_user` list account users, invite them, change their permissions, and disable or enable them. Both require owner or administrator access.

**Changes**

* `delete_resource` takes `storage-items`: a soft delete into the recycle bin, reversible for 30 days with `restore_storage_item`.
* `triage_flow_errors` takes `retryAll` or `resolveAll` to act on every open error on a step without listing ids.
* The endpoint serves MCP revision `2026-07-28` alongside 2025-era clients, without protocol sessions: it issues no `Mcp-Session-Id`, and `GET` returns `405`.
* Correction to the July 14 entry: `delete_resource` runs its dependency pre-flight for every resource type, not only connections. Warnings still never block the delete.
  {% endupdate %}

{% update date="2026-08-03" tags="cli,feature" %}

## CLI 2026.8.2

`@celigo/celigo-cli` 2026.8.2 is on npm and includes everything in 2026.8.1.

```bash
npm install -g @celigo/celigo-cli
```

**Renamed and removed options**

* **Breaking:** date and time options now name the field they bound, as `--*-gte` and `--*-lte`. `audit list` and `scripts debug-logs` take `--time-gte` and `--time-lte`, `edi-transactions list` takes `--modified-gte` and `--modified-lte`, and `flows delete-execution-logs` takes `--started-gte` and `--started-lte`. The former names no longer resolve.
* **Breaking:** `flows run` takes `--start-time` and `--end-time` for a delta window override, replacing `--start-date` and `--end-date`. The window accepts a full timestamp, which the former names read as a calendar date.
* **Breaking:** `--sandbox` is removed from `jobs current`, `jobs run-stats`, and `edi-transactions list`. The environment comes from the profile's token, so use a profile that targets the Sandbox environment.
* `tp-connectors` is now `trading-partner-connectors`. The former name is retained as an alias, so existing scripts keep working. See [trading-partner-connectors](https://developer.celigo.com/cli/commands/trading-partner-connectors).

**Projected list output**

* `list` requests server-side field projection by default. Each row carries `_id`, `name`, and the group's table columns instead of the complete document. On one account `exports list` went from 12.9 MB to 183 KB, and `flows list` measured 7.5× smaller.
* Table output and `get` are unchanged. `jobs`, `sync-jobs`, `recycle-bin`, `storage`, `audit`, the error listings, and `account snapshot` are never projected.
* `--fields all` returns complete documents. `--fields default` names the built-in projection explicitly. `--fields <a,b,c>` requests a specific set, with dot notation for nested fields.
* An explicit `--fields` list is a floor, not an exact shape. `_id` and `name` accompany every projection, as does any field the command filters on internally.
* `--jq` fetches complete documents on its own, so existing `jq` pipelines are unaffected. Precedence is `--fields`, then `--jq`, then the profile's `list_fields`, then the built-in default. Pairing `--jq` with an explicit `--fields` projects, and the expression can read a `null`. See [Global flags](https://developer.celigo.com/cli/getting-started/global-flags).
* `celigo config set list_fields all` makes complete documents the default for a profile. The key is per-profile and accepts `all` or `default`. See [Configuration reference](https://developer.celigo.com/cli/getting-started/configuration).
* `--limit <n>` returns at most `<n>` rows from a single page. It is available on the standard `list` verb. `ai-agents`, `guardrails`, `notifications`, `stacks`, `http-connectors`, `trading-partner-connectors`, and `templates marketplace` accept `--fields` without it.

**New command groups**

* `celigo storage` manages files and folders in Celigo Storage: `list`, `search`, `upload`, `download`, `replace`, `create-folder`, `set`, `move`, `copy`, `merge`, and `delete`. See [storage](https://developer.celigo.com/cli/commands/storage).
* `celigo datasets` selects which tables or objects a sync replicates, with `list`, `get`, and batch `upsert`. `datasets available <connectionId>` and `datasets fields <connectionId> <datasetName>` read the source catalog. See [datasets](https://developer.celigo.com/cli/commands/datasets).
* `celigo processors` runs the stateless parsers and generators: `list`, `invoke <name>`, `parse <csv|edi|xml>`, and `generate <csv|edi>`. Nothing on the account is created or changed, so these run in a `read`-mode profile. See [processors](https://developer.celigo.com/cli/commands/processors).

**Syncs**

* `syncs` adds `list` (with `--integration`), `get`, `create`, `update`, `set`, and `delete` beside the existing `run`, `audit`, and `cancel-jobs`. See [syncs](https://developer.celigo.com/cli/commands/syncs).
* `syncs events <syncId>` lists schema drift and data catalog events, filtered by `--type`, `--resource-name`, `--run`, or a time range.
* `syncs usage` reports records loaded per sync, per month with entitlement history, or per environment.

**AI assistant skills**

* The CLI installs the official Celigo skills in a detached background process, at most once every 24 hours, so an AI assistant driving the CLI has them without a manual step. It never blocks or fails the command that triggered it, and is skipped in CI. See [AI assistant skills](https://developer.celigo.com/cli/using-the-cli/skills).
* The background process installs only when the `celigo/ai` skills repository has moved since the last install. When it has not, the CLI installs nothing and prints nothing.
* `celigo skills install`, `celigo skills list`, and `celigo skills update` run the installer on demand. Nothing is installed at npm install time.
* Opt out with `CELIGO_NO_SKILLS_INSTALL=1` or `celigo config set skills_auto_install false`.
* `celigo config set skills_auto_install_exclude writing-sql,writing-handlebars` keeps named skills out of the background install, which then requests the rest by name instead of `--all`. An explicit `celigo skills install` ignores the list.
* `auto_update`, `skills_auto_install`, and `skills_auto_install_exclude` are machine-wide, stored outside the profiles rather than on one of them.

**Also in this release**

* `flows error-summary` makes one request to the per-step rollup endpoint instead of one request per flow step, and reports each step's `lastErrorAt`. The `stepType` column is gone — the rollup does not return it.
* `apis download` and `tools download` save a builder-mode API or a Tool as a template `.zip`. The API archive includes every resource it references; script-mode APIs cannot be exported. `apis clone --dry-run` validates the target version and route without creating anything.
* `audit list` and `audit download` accept multiple `--resource-type`, `--source`, and `--action` values, plus `--resource <type>:<id>` pairs. Each filter matches any of its values. See [audit](https://developer.celigo.com/cli/commands/audit).
* `storage merge <id> --to <destinationId>` merges one folder into another and removes the source. Requires `full` mode.
* JSON output is compact when stdout is a pipe or a file, and pretty-printed only at an interactive terminal.
* `mcp-oauth-providers` guards masked credentials the way `connections` and `iclients` do. `set` refuses every field on the group, which has no `PATCH` whitelist, and points at `update` with the real values.
* Commands behind a confirmation prompt exit `1` when there is no TTY, instead of exiting `0` after refusing to act.
* The background self-update names the exact command it runs, so the notice is auditable. `celigo config set auto_update false` downgrades it to a notify-only hint; `CELIGO_NO_UPDATE=1` disables the check entirely.

Full command reference in the [Celigo CLI](https://developer.celigo.com/cli) section.
{% endupdate %}

{% update date="2026-07-20" tags="mcp,feature" %}

## OAuth sign-in for Platform MCP

Add the [Platform MCP](https://developer.celigo.com/mcp) endpoint to your client with no credentials and it opens a browser sign-in — no more creating and copying API tokens. Per-client setup in [Connect a client](https://developer.celigo.com/mcp/connect).

```json
{
  "mcpServers": {
    "celigo": {
      "url": "https://api.integrator.io/celigo-mcp"
    }
  }
}
```

* The server implements OAuth 2.1 with PKCE and dynamic client registration. Clients that follow the MCP authorization spec discover the sign-in automatically — current releases of Claude, Cursor, VS Code, Windsurf, and ChatGPT all do.
* Sign-in uses your Celigo credentials, including SSO and MFA where your account requires them. The session acts as you, in the account and environment you pick at sign-in.
* Clients refresh the session automatically. You sign in again only if access is revoked, you switch account or environment, or the session goes unused for an extended period.
* API tokens and personal access tokens still work for CI, scripts, and clients without OAuth support — pass one in the `Authorization` header, same as before.
* The endpoint is region-specific: `https://api.eu.integrator.io/celigo-mcp` signs in against `eu.integrator.io`. To switch account or environment, disconnect the server and sign in again.
  {% endupdate %}

{% update date="2026-07-14" tags="api,feature" %}

## Personal access tokens

A personal access token (PAT) is a bearer token you create yourself that acts with your own user permissions — no admin provisioning, no scopes. Full details in [Authentication](https://developer.celigo.com/api/getting-started/authentication).

* Create one under **Resources → API tokens** → **+ Generate token** → **Personal access token**. Manage and Monitor roles get self-service API access for the first time; for them it is the only token type offered.
* The token inherits your permissions and follows role changes. Disabling your user blocks the token; deleting your user revokes it.
* Admins can see and revoke every PAT on the account, but cannot view a token value they didn't create.
* PATs auto-purge after 90 days by default, configurable from 1 hour to never.
* A PAT works anywhere an API token works: REST API calls, `CELIGO_API_TOKEN` in the CLI, and the `Authorization` header on Platform MCP.
  {% endupdate %}

{% update date="2026-07-14" tags="mcp,feature" %}

## Platform MCP: nine new tools

Connected clients pick these up automatically — the catalog is fetched at runtime. Full details in [Tools](https://developer.celigo.com/mcp/tools).

**B2B EDI**

* `list_edi_profiles` / `upsert_edi_profile` manage trading-partner interchange envelopes (X12 ISA/GS, EDIFACT UNB).
* `list_file_definitions` / `upsert_file_definition` manage parsing and generation rules for CSV, fixed-width, X12, and EDIFACT files.
* `list_edi_transactions` queries the EDI transaction log by document type, direction, document number, or date window; `includeFaDetails` / `includeMdn` add acknowledgment detail.
* `update_edi_fa_status` marks acknowledgments `accepted` or `rejected` in bulk.

**Marketplace and debugging**

* `list_marketplace` browses published templates or previews one template's full blueprint; `deploy_template` installs it as a new integration mapped to your connections.
* `list_execution_logs` reads a run's debug logs: the index, one record's step timeline, or request/response payloads per stage. Requires debug logging armed on the flow.

**Existing tools**

* `list_flow_errors` with no arguments returns an account-wide summary of every erroring flow and step.
* `list_flows` adds `hasOpenErrors`, `includeErrorCounts`, and `numError_gte`.
* `run_flow` takes optional overrides: `export.startDate` / `export.endDate` for backfills, `_exportIds` to run a subset of source exports.
* `list_jobs` with `includeFiles: true` returns short-lived download URLs for files a run produced.

**Fixes**

* Every tool declares MCP tool annotations (read-only, destructive, idempotent).
* `run_flow` and `cancel_job` take `_id`, matching every other tool (previously `id`).
* `update_flow_error_retry_data` advertises the correct body schema — the retry-data envelope, not the flow schema. `list_lookup_cache_data` drops a stray `body` parameter.
* `delete_resource` states that its dependency pre-flight runs for connections only and that warnings never block the delete; `resourceType` adds `edi-profiles` and `file-definitions`.
* `list_environments` returns an empty list with a warning on accounts without the feature. `list_jobs` returns `[]` instead of `null` when nothing matches.
  {% endupdate %}

{% update date="2026-07-14" tags="api,feature" %}

## July API updates

Everything below is live in production and documented in the [API reference](https://developer.celigo.com/api).

**AI agents**

* AI agent and guardrail imports support Anthropic Claude: set `provider: "anthropic"` with a Claude model id in `litellm.model` and Claude settings in `litellm._overrides.anthropic` (required `systemInstruction`, extended thinking via `thinkingConfig`, Claude tools including web search). `temperature` is capped at 1 and `responseFormat.type` must be `text` or `json_schema`.
* All three providers accept a `resources` array — read-only reference content (policies, schemas, documentation) pinned from connected MCP servers.
* OpenAI reasoning effort adds `none` and `xhigh`; OpenAI configs support `topLogprobs`; the LiteLLM `maxCompletionTokens` default rose from 1000 to 5000.

**Endpoints**

* The Syncs reference now covers the full build surface, not just running and monitoring: sync CRUD, dataset CRUD, schema-drift events, source and destination metadata catalogs, and usage endpoints.
* `POST /v1/connections` accepts `__integrationIds` (up to 100) to create a connection and register it on integrations in one call; post-save registration failures are reported in `__failedIntegrationRegistrations` without rolling back the connection.
* The step error endpoints (`GET /v1/flows/{_id}/{_stepId}/errors` and `.../resolved`) add filters: `_flowJobId` (paired with `occurredAt_gte` or `resolvedAt_gte`), occurred/resolved date bounds, `tags` (including `untagged`), and `resolvedBy` (including `auto`).
* `GET /v1/apis/{_id}/template` and `GET /v1/tools/{_id}/template` export a builder-mode API or Tool and everything it references as an installable `.zip` via a short-lived signed URL.
* `POST /v1/apis/{_id}/clone/validate` dry-runs a clone and returns `canClone`, catching version/route conflicts before anything is created.
* MCP servers (the `mcpservers` resource) accept a `resources` array: Celigo Storage files served to MCP clients through `resources/list` and `resources/read`.

**Also in the reference**

* Integration clone previews include Tool resources; the `tools_not_supported` rejection is gone.
* The recycle bin supports the `storageitems` resource type (list-only).
* License responses document `storage` entitlements (`maxAllowedUsage`, `disableOverage`) and EDI `labelPrinting` entitlements.
* Trading-partner connectors carry new `type` (`FTP`, `AS2`, `S3`) and `region` fields.
  {% endupdate %}

{% update date="2026-06-18" tags="mcp,feature" %}

## Celigo Platform MCP is generally available

The Celigo Platform MCP is now live at `https://api.integrator.io/celigo-mcp`. It's a hosted remote MCP endpoint that lets AI agents read, run, and troubleshoot your integrator.io account: no local process, no sidecar, a bearer token and any MCP-compatible client.

### Who it's for

Anyone working with AI coding agents: Claude Code, Claude Desktop, Cursor, VS Code with Copilot, Windsurf, or any client that speaks Streamable HTTP. Point the client at the endpoint, hand it an API token, and the agent can operate on your integrator.io account directly.

### What agents can do today

* **Inspect everything.** List and get connections, integrations, flows, exports, imports, scripts, agents, guardrails, APIs, tools, MCP servers, lookup caches, iClients, jobs, and audit entries.
* **Build and edit resources.** Create or update any resource with a single `upsert_*` tool, and delete any resource with `delete_resource`, which reports dependents as advisory warnings but doesn't block. A masked-credential guard keeps agents from overwriting stored secrets.
* **Run flows and triage errors.** Trigger a flow, wait for the job, inspect per-step results, then retry, resolve, tag, or assign failed records, all in one conversation.
* **Use built-in prompts.** Guided workflows ship with the server: account health audits, flow troubleshooting, connection diagnosis, integration planning, flow config review, and Handlebars/SQL writing assistance. The `search_knowledge_base` tool answers product questions straight from the Celigo Knowledge Base.
* **Load reference resources.** The server exposes a product glossary, tool usage guide, error pattern reference, connector catalog, and API reference as MCP resources: context the agent pulls on demand. (Full connector and resource schemas come from the `get_schema` tool, not a resource.)

### Get started

```json
{
  "mcpServers": {
    "celigo": {
      "url": "https://api.integrator.io/celigo-mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_TOKEN>"
      }
    }
  }
}
```

Full setup, authentication details, transport options, and the complete tool catalog live in the [Platform MCP section](https://developer.celigo.com/mcp).

<details>

<summary>Notes</summary>

* Requires a full-access API token
* Region-aware: use `https://api.eu.integrator.io/celigo-mcp` for EU accounts

</details>
{% endupdate %}

{% update date="2026-06-17" tags="cli,feature" %}

## CLI 2026.6.1

`@celigo/celigo-cli` **2026.6.1** is on npm. A large release: seven new command groups, file-based input across every write command, credential-safe `set`, actionable error hints, and a round of command renames that align the CLI surface.

```bash
npm install -g @celigo/celigo-cli
```

### New command groups

* `celigo connectors`: base CRUD plus `install-base`, `install`, `push-update`, and `connectors licenses` CRUD.
* `celigo state`: read and write resource and account state with `list`, `get`, `set`, `delete`, `purge`. Global by default; scope to a resource with `--resource-type` and `--resource-id`.
* `celigo syncs`: `run`, `audit`, `sources`, `destinations`, `cancel-jobs`.
* `celigo sync-jobs`: `list` (auto-paginated per sync, newest first, with `--created-gte` / `--created-lte`), `get`, `errors`, `cancel`.
* `celigo recycle-bin`: `list`, `get`, `restore` (with `--cascade`), `purge`.
* `celigo mcp-oauth-providers`: full CRUD for MCP OAuth providers.
* `celigo event-reports`: `list`, `get`, `create`, `signed-url`, `cancel`.

### New subcommands on existing groups

* HTTP connectors: `create`, `update`, `delete`, `resources`, `resource`, `endpoints`, `endpoint`.
* Templates: `templates install` to install from a local `.zip` or by id with a connection map, plus `list`, `get`, `create`, `update`, `delete`.
* EDI transactions: `fa-detail`, `mdn-detail`, `update-fa-status`, `download-file --document-type`.
* APIs: `set-group` / `unset-group`, plus `create-api-group` / `delete-api-group` / `api-groups`.
* Flows: `error-summary`, `delete-execution-logs --started-at --end-at`, `cancel-jobs`, `set-group` / `unset-group`.
* Connections: `applications` (external apps in use, filterable with `--application`), `delete-debug-logs`, `purge-messages`.
* Scripts: `audit`, `delete-debug-logs`.
* Tools and partners: `tools connections`, `tp-connectors create/update/delete`.
* Across resources: `dependencies` (alias `used-by`), `audit`, `profile whoami`, `on-premise-agents installer-url --os`, `notifications list`, `stacks audit`, `users enable/disable`, `environments enable/disable`.

### File-based input

`-f, --file <path>` now works on every `create`, `update`, and `install` command (`--file -` still means stdin). And `set` accepts `file://<path>` assignment values to load multi-line content such as script source or SQL without escaping:

```bash
celigo exports create -f ./export.json
celigo scripts set 64a... content=file://./transform.js
```

This avoids shell input redirection, which is unreliable when driven by an agent and unsupported in PowerShell.

### Credential-safe writes

* `set` uses atomic JSON-Patch whitelists. Whitelisted fields PATCH cleanly; masked-credential endpoints (connections, iClients) refuse non-whitelisted edits rather than round-tripping a GET then PUT that would wipe stored secrets.
* `update` refuses payloads that still contain the masked `******` placeholder unless you pass `--force`.
* `profile delete` now confirms before deleting (`-y, --yes` to skip).

### Better errors

* Actionable hints mapped from API error codes (`inactive_flow`, `feature_not_enabled`, `invalid_ref`, `access_restricted`) now appear in the formatted error.
* Empty required positional arguments are rejected up front, catching unset shell variables like `celigo jobs get "$ID"` before they hit the API blind.
* `--limit` is validated as a positive integer instead of silently coercing bad input.

### Renamed and restructured commands

* `account deps` is now `account dependencies`.
* `<resource> debug-enable` / `debug-disable` are now `enable-debug` / `disable-debug`.
* `exports` / `imports` `test-run-step` is now `test-run-step-results`.
* `flows flow-group-create` is now `create-flow-group`; `flow-group-assign` is now `set-group` (with a new `unset-group`).
* `flows execution-logs-enable` / `-disable` are now `enable-execution-logs` / `disable-execution-logs`.
* `flows execution-log-query` is now `query-execution-logs`; `execution-log-data` is now `execution-log-detail`.
* `integrations snapshot` is now `create-snapshot`; `integrations files` plus `download` are now `download-files`.
* `agents` / `scripts` `logs` is now `debug-logs`.
* `usage historical` is now `historical-usage`.
* Token verbs consolidated: `system-token` / `display-token` to `token`; `recycle-token` / `change-token` to `rotate-token`.
* Error commands now take explicit ids: `resolve-errors` is now `error` (flow, step, and error ids passed as arguments), `error-analyze` is now `error-analysis`, `update-error-data` takes the error id explicitly, and `assign-errors` gained an explicit step argument.
* Templates: `templates list` (marketplace) is now `templates marketplace`; `invoke` and `preview` take an optional id.
* The interactive REPL was removed; running `celigo` with no arguments no longer opens a shell.
* The `account-info` group was removed; its `applications` listing is now `connections applications`.

### Fixes and internals

* `connections purge-messages` treats the API's "queue already empty" `404 Not Found` as a successful no-op.
* `users` and `environments` `enable/disable` read current state before toggling, so the verbs are honest and idempotent.
* `account dependencies` orphaned-script detection walks `_scriptId` references recursively, catching flow-level and nested refs.
* New `createdAt` cursor pagination with a truncation warning when the safety cap is hit (used by `sync-jobs list`).
* The account index staleness window tightened from 4 hours to 15 minutes.
* All 124 bundled skill schemas re-synced from the platform's published API specs, the drift check is now line-ending tolerant, and the legacy `rest` / `simple` schemas were removed (use `HTTPExport` / `HTTPImport` instead).
  {% endupdate %}

{% update date="2026-04-05" tags="cli,feature" %}

## CLI 2026.4.5 — generally available

`@celigo/celigo-cli` **2026.4.5** is now generally available on npm. This is the launch release: a first-party command-line tool for driving integrator.io from your terminal, your scripts, your CI pipelines, and the AI coding agents you already work with.

### Who it's for

Developers and AI coding agents who live in a terminal. If the integrator.io UI is the right tool for your day-to-day, keep using it — the CLI exists for the workflows where a UI slows you down: scripted bulk edits, version-controlled configuration, CI checks, and long-horizon agents that need to read and write live integrator.io state without burning context on a GUI.

### What you can do

* **Drive every resource.** Anything in the REST API maps to a `celigo <resource> <verb>` command — integrations, flows, connections, exports, imports, scripts, agents, guardrails, EDI profiles, on-premise agents, and more.
* **Manage multiple accounts.** Profiles switch between prod, sandbox, and EU regions without juggling tokens. `celigo profile use eu` is the whole context switch.
* **Lint your account.** `celigo account lint` runs static analysis across integrations, flows, and scripts — broken references, missing required fields, common script errors — before you push to production.
* **Snapshot, search, diff.** `celigo account snapshot` pulls every resource into a local index for full-text search (`celigo account search`), dependency graphs (`celigo account deps`), and per-resource stats.
* **Pipe-friendly output.** Every command supports `--format json|yaml|table|csv` and `--jq`, so results flow cleanly into shell scripts and other tools.

### AI assistant skills, included

Installing the CLI globally also installs a set of AI assistant skills for Claude Code, Cursor, and Windsurf — domain-specific guides plus OpenAPI-derived schemas the assistant loads on demand. Ask "build a Shopify → NetSuite flow" and the assistant pulls the `building-flows` skill and writes JSON that actually validates against integrator.io, instead of guessing field names. Skills update atomically when you upgrade the CLI.

### Get started

```bash
npm install -g @celigo/celigo-cli
celigo profile add prod --api-token "$CELIGO_API_TOKEN"
celigo integrations list --format table
```

Full install options, profile setup, region targeting, and skills coverage live in the [CLI section](https://developer.celigo.com/cli).

<details>

<summary>Notes</summary>

* Requires Node.js 22+
* MIT licensed
* Region-aware — pass `--api-base-url https://api.eu.integrator.io` for EU accounts, or scope it per profile

</details>
{% endupdate %}
{% endupdates %}