@orbito/omm (2.1.0)
Installation
@orbito:registry=https://git.kozminski.net.pl/api/packages/orbito/npm/npm install @orbito/omm@2.1.0"@orbito/omm": "2.1.0"About this package
OMM — OrbitoModulesManager
CLI for Orbito modules:
- registry (
modules.orbito.pl) — pack and publish modules, thenpm publishof Orbito modules, and business solutions (module sets with automation templates); - Orbito Core (
v2.orbito.pl) — install a module version in your test company, read its logs and problems, call its methods and update it — the build/test loop without the web panel.
The package identity (module code and version) comes only from module.json
in the module directory. The module card in the registry is created by omm init
(or in the developer panel) — omm publish never creates it.
Installation
npm config set @orbito:registry https://git.kozminski.net.pl/api/packages/orbito/npm/ # once per machine
npm i -g @orbito/omm
@orbito/omm and @orbito/api-lib are not on npmjs.org: they live in the Orbito npm
registry, which allows anonymous downloads (no token) but needs the @orbito scope mapped
in ~/.npmrc:
@orbito:registry=https://git.kozminski.net.pl/api/packages/orbito/npm/
Without this line npm i -g @orbito/omm and npm install in a module fail with 404.
Requires Node.js >= 18.13. To work on the CLI itself: npm install && npm link
in the repo directory.
Publishing a new CLI version: bump version in package.json and run npm publish
(the registry is set in publishConfig).
Usage
Account and login (omm login)
One Orbito account (the one you use at v2.orbito.pl) logs in to both Orbito Core and the
module registry — the registry has no passwords of its own. No account yet? Sign up at
https://v2.orbito.pl.
omm login # e-mail + password: core session + publish token in the registry
omm login --core http://localhost:3003 --registry http://localhost:3005 # other servers
omm login --token <core JWT> # instead of a password: an existing core JWT (logs in to both)
omm login --token omm_abc... # registry only: an existing publish token (CI)
omm whoami # registry account and its namespaces with your role
omm whoami --core # core account and working company
omm logout # revoke the publish token, remove it and the core session
omm login [--core <url>] [-r, --registry <url>] [-t, --token <token>]
omm loginsigns in to Orbito Core (POST /auth/signin) and saves the core session (JWT, 48 h, refreshed automatically). With the same core JWT it then creates a long-lived publish token in the registry (POST /developer/auth/tokens, namedomm-<hostname>) and saves it. Both are written only when both steps succeed.--coreand--registryonly choose the servers (defaults: last used,OMM_CORE/OMM_REGISTRY, thenhttps://v2.orbito.pl/apiandhttps://modules.orbito.pl/api). A bare--core(the omm 1.x syntax) means the default core.- The working company (
omm company use) is kept when you log in again to the same account. --token omm_...logs in to the registry only (verified withGET /developer/publish/whoami); core commands then needomm loginorOMM_CORE_TOKEN.omm logoutrevokes the publish token in the registry (DELETE /developer/publish/token) and removes it and the core session from the config. The core JWT cannot be revoked — it simply expires.--json:loginprints{ email, core, expiresAt, companyId, companies, registry, tokenName }({ registry, email }with--token omm_...),whoamiprints{ registry, id, email, name, namespaces: [{ id, name, role }] },logoutprints{ registry: { url, loggedOut, revoked }, core: { url, loggedOut } }.
Upgrading from omm 1.x: log in again with omm login (the registry no longer accepts its
own passwords). The old username and devToken entries in the config are not used any more;
devToken is removed on the next config write. omm company dev-token is gone — see
Drafts.
Namespaces (omm namespace)
A module belongs to a namespace, not to a person: its code is <namespace>/<slug>
(e.g. acme/hello). Every member of the namespace can do everything with its modules (create
cards, publish, set secrets and the repository link); only the owner manages members.
omm namespace list # your namespaces with your role (owner / member)
omm namespace create acme # a-z, 0-9, -, 3–30 characters, globally unique
omm namespace members acme # owner, members and pending invitations
omm namespace invite acme anna@acme.pl # owner only
omm namespace remove acme anna@acme.pl # owner only: remove a member or cancel an invitation
inviteadds the person right away when they have already used the registry (logged in once); otherwise it records an invitation that turns into membership on their first login. No e-mail is sent — tell them yourself.removelooks the e-mail up among members (removed by their account id) and invitations. The owner cannot be removed; there is no transfer of ownership and no deleting a namespace.- Every command accepts
-r, --registry <url>.--jsonprints the list forlistand the namespace details for the others:{ id, name, role, owner, members: [{ id, email, name, addedAt }], invitations: [{ email, createdAt }], createdAt }.
New module (omm init)
omm init "Hello" # create the module card in your namespace + scaffold ./hello
omm init "Hello" --namespace acme # choose the namespace (needed when you have several)
omm init "Hello" --description "Greets people" --dir my-hello
omm init "Hello" --code acme/hello # the card already exists: scaffold only, no registry call
omm init <name> [--dir <dir>] [--namespace <name> | --code <namespace/name>] [--description <text>] [-r, --registry <url>]
<name>is the display name of the module card.- Without
--codethe command creates the module card in a namespace in the registry (POST /developer/modules, needsomm login); the registry assigns the module code<namespace>/<slug of the name>. The namespace is--namespace, otherwise your only namespace (fromGET /developer/auth/me); with several namespacesomm initasks in a terminal and fails in scripts and with--json(pass--namespace). Without any namespace it fails with a hint:omm namespace create <name>. - With
--codethe card must already exist and the registry is not called. --dirdefaults to the name part of the code (acme/hello→hello). The directory must not exist or must be empty.- The module is created from the template built into
omm(the same code as thehello-moduleexample in the docs):module.json,package.json,index.js,pages/hello.yamland.gitignore, with the module code put into every file and--descriptionintopackage.json.npm installis not run. --jsonprints{ code, dir, files, cardCreated }.
Next: cd <dir> && npm install, then follow the build loop:
https://orbito.pl/docs/agents/build-loop.html
Registry
omm pack --dry-run # show what goes into the package
omm pack # build the ZIP locally (no upload)
omm publish # pack + upload a DRAFT + wait for the Docker build
omm publish --release # as above + publish in the registry (draft → published)
omm publish --no-wait # upload a draft and do not wait for the build
omm publish --changelog "..." # with release notes
omm secrets list # module secrets with their status (never values)
omm secrets set ALLEGRO_CLIENT_ID # set a value (hidden prompt)
omm secrets unset ALLEGRO_CLIENT_ID # remove a value
omm repo # link to the module's git repository (only namespace members see it)
omm repo set # set it from `git remote get-url origin` of the current directory
omm repo set git@github.com:acme/hello.git # or the given URL
omm repo unset # remove it
By default publish uploads a draft — for testing. Publishing in the registry
(visible to all companies) requires an explicit --release.
The version of a new publish is bumped by editing version in module.json
(it must be a semver higher than the last published version). A draft of the
same version can be uploaded again — it overwrites the previous draft.
Orbito Core (test loop)
The core session comes from omm login (see above).
omm company list # your companies (* = working company)
omm company use <id> # set the working company (id or list number)
omm company use # choose interactively
omm install # install the version from module.json (+ dependencies)
omm install --name "Shop B" # a second instance of a non-singleton module
omm instances # instances of the module in the company
omm logs # module logs of today
omm logs --since 2026-10-13T10:00:00Z
omm logs --day 2026-10-12
omm logs --container # Docker stdout/stderr of the module container
omm problems --status waiting # problems reported by the module
omm call getOrders --params '{"limit": 5}' # call a module method, print its result
omm update # update the instance to the version from module.json
# (same version: reload the container with a fresh image)
A typical loop: omm publish (draft) → omm install → omm logs / omm problems / omm call → fix → omm publish (overwrites
the draft) → omm update (reload) → … → omm publish --release. The version does not have
to be bumped while you iterate on a draft.
- The module code (and, for
install/update, the version) is read frommodule.jsonin the current directory (-C <dir>for another one).instances,logs,problemsandcallalso accept--module <namespace/name>. update,logsandcallact on the only active instance of the module in the working company. With more instances the command fails and lists their ids — choose one with--instance <id>.installalways installs missing dependencies too (withDependencies).updatecompares the instance version withmodule.json. A different version updates the instance (POST /m/i/:id/update); the same version reloads it instead (POST /m/i/:id/reload): the container is stopped and its next start pulls the image again, so an overwritten draft takes effect.--jsonprints the core response plus"action": "update"or"action": "reload".callruns the method with the permissions of the logged-in user; the core wraps the result in a one-element array —ommprints the element itself.- The core JWT is valid for 48 h and is refreshed automatically before a core command when
less than 24 h are left. An expired session ends with an error asking for
omm login. - Every core command accepts
--core <url>and (exceptcompany list/use)--company <id>.
Drafts and access to unpublished modules
A draft version (and a module that has never been published) is available only to members of
the module namespace and to companies granted access to the module. When a namespace
member installs a draft in a company (omm install, omm update or the panel), the core
records the grant for that company, so the module keeps working there — also after a container
restart and for the other users of the company. A grant for another company can be added in
the developer panel of the registry. There is no developer token any more.
When the core cannot find the version (HTTP 404), install and update add a hint about this
(hint in --json): check with omm whoami that you are logged in as a member of the module
namespace.
Company automations (omm automation)
Automations of the working company: browse them, write their graph as a JSON file, enable them and diagnose their runs — without the editor in the web panel.
omm automation list --enabled --query invoice # ID, ENABLED, NAME, TRIGGERS, ACTIONS, BLOCKING
omm automation get <id> # graph (in the file format below) + blocking elements
omm automation elements --kind action --query label # triggers and actions available in the company
omm automation element set_var # full definition as JSON: params, outputs, emits/requires
omm automation create -f graph.json # create a DISABLED automation (validated by the core)
cat graph.json | omm automation create -f - # the graph from stdin
omm automation update <id> -f patch.json # replace the given graph fields
omm automation enable <id> # enable it (separate step, see below)
omm automation disable <id>
omm automation duplicate <id> # disabled copy
omm automation delete <id> --yes # also removes its runs and problems
omm automation runs --automation <id> --status errored --event 12345
omm automation run <runId> # run header, event params and steps
omm automation var list
omm automation var get <key>
omm automation var set <key> <value> # values are text
The graph file (create needs all of it, update any subset of the fields):
{
"name": "Label for new orders",
"desc": "Optional description",
"triggers": [{ "type": "<trigger type>", "params": {} }],
"actions": {
"a1": {
"type": "<moduleCode>:<action code>",
"params": { "__instanceId": "<instance id>" },
"branches": { "next": null }
}
},
"startActionId": "a1"
}
typeis the element type fromomm automation elements; module elements are<moduleCode>:<code>and needparams.__instanceId(the instance that runs them).branchesmaps the action outputs (next, or e.g.true/falseof a condition) to the next action id ornull.- Draft → enable.
createalways saves a disabled automation andupdatenever changesisEnabled; a graph file withisEnabledis rejected. Enable it explicitly withomm automation enable <id>— the core then checks that every element is available and the action params are valid. - The output of
omm automation get <id> --jsoncan be edited and fed back toomm automation update <id> -fonceisEnabledis removed — read-only fields (_id,validation,generatedName, …) are dropped before sending. createandupdatesend?strict=true: the core validates the whole graph (elements, params, branches, template variables) and rejects an invalid one with HTTP 422. The errors are printed one per line aspath: message (CODE); for a rejectedenablethe blocking elements (triggers.0: <type> (<status>)) and invalid action params. With--jsonthey are in thevalidationfield of the error on stderr:
{"error":"Automation graph is invalid","status":422,"validation":{"errors":[{"path":"actions.a1.params.__instanceId","code":"REQUIRED","message":"..."}]}}
--jsonprints{ automationId, name, isEnabled }forcreate,update,enable,disableandduplicate, the core response for the other commands, and a list of elements withkind(trigger/action) forelements.elementprints JSON also without--json.listshows up to 50 automations,runsup to 20 runs (--limit, the core caps runs at 50).- Validation messages come from the core as they are.
Business solutions (omm solution)
A business solution is a curated set of published modules with automation templates — a company
installs it in Orbito in one click and gets the automations as disabled drafts. Solutions are
published only by members of the core namespace (Orbito); for anyone else the registry answers
403 and omm points to omm whoami.
omm solution publish ./sklep-b2b # publish (or update: same slug) from the solution directory
omm solution publish # the current directory
omm solution list # SLUG, NAME, MODULES, AUTOMATIONS, INSTALLS, PUBLISHED (also unpublished)
omm solution unpublish sklep-b2b # hide it in the registry and in Orbito; publish again to restore it
The solution directory:
sklep-b2b/
├── solution.yaml # manifest (required)
├── README.md # description on the solution page (optional)
├── cover.png # cover: cover.png, cover.jpg or cover.webp, max 2 MB (optional)
└── automations/
└── label-after-payment.json # automation graphs — the `omm automation create -f` file format
slug: sklep-b2b # a-z, 0-9, -, 3-60 characters; page /solutions/sklep-b2b
name: Sklep B2B # max 80 characters
summary: Orders from PrestaShop, invoices in wFirma and InPost labels # max 200
tags: [b2b, shipping] # optional
modules: # at least one published module, in display order
- code: core/orders
role: One list of orders from all channels # max 120 characters
- code: core/wfirma
role: Invoices for paid orders
required: false # default true; false = the company may skip it
automations: # optional, paths relative to the solution directory
- automations/label-after-payment.json
- Each automation file is read exactly like
omm automation create -f(JSON,isEnabledrejected, read-only fields dropped), so a working automation from your test company moves into a solution withomm automation get <id> --json(removeisEnabled). Do not keepparams.__instanceId— the core sets the instance of the installed module. - omm parses
solution.yaml(the registry does not read YAML), checks the basic shape (slug,name,summary, non-emptymodules, automation files exist, one cover at most) and reports all problems at once before sending anything. Everything else (lengths, module codes, modules published) is checked by the registry; its messages are passed through as they are. - Every publish replaces the whole solution: without
README.mdor a cover the description or the cover is cleared. Installs and the publication date are kept. publishprints the solution and its public pagehttps://modules.orbito.pl/solutions/<slug>;--jsonprints the registry response withurl.list --jsonprints the list,unpublish --jsonthe solution withisPublished: false.
Installing the agent skill (omm skill install)
The orbito-modules skill (SKILL.md) teaches AI coding agents — Claude Code, Codex and
OpenCode — how to build, test and publish Orbito modules. omm skill install downloads the
current skill and copies it into the agents' skill directories; run it again to update it.
It works the same on Windows, macOS and Linux.
omm skill install # agents whose directory exists in your home directory
omm skill install --project # .claude/.codex/.opencode of the current directory
omm skill install --agent codex --agent opencode
omm skill install --all --no-npm
omm skill install [--project] [--all] [--agent <name>...] [--no-npm]
- By default the skill goes to every agent whose directory exists (
~/.claude,~/.codex,~/.config/opencode; with--project:.claude,.codex,.opencodein the current directory); if none exists, to Claude Code. The file lands in<agent dir>/skills/orbito-modules/SKILL.md. --allinstalls for all three agents;--agent claude|codex|opencode(repeatable) only for the given ones.- The skill is downloaded from
https://orbito.pl/docs/skill/SKILL.md(OMM_SKILL_URLoverrides it, also with afile://URL) and must declarename: orbito-modules, otherwise nothing is written. - Unless
--no-npmis given, the command maps the@orbitoscope in~/.npmrc(npm config set @orbito:registry …). When npm is missing or fails, it prints the line to add by hand; the skill is installed anyway (exit code 0). --jsonprints{ installed: [{ agent, file }], npm: "configured"|"skipped"|"failed", skillUrl }.- No update notices are printed after this command (the fresh copies would be reported as outdated by the check started before it).
https://orbito.pl/docs/skill/install.sh (curl … | sh) installs omm and runs
omm skill install with the same options.
Output for scripts and AI agents (--json)
--json (anywhere on the command line) prints only the result as JSON on stdout; progress
messages are suppressed. Errors go to stderr as {"error": "...", "status": 404} (status
is the HTTP status or null, plus code/details/validation when the server sends them and
hint when omm knows the next step) and the exit
code is 1. Commands never read stdin except the interactive ones: login without --token,
company use without an argument, init without --namespace for an account with several
namespaces (in a terminal only) and secrets set without OMM_SECRET_VALUE — and
automation create/update -f -, which read the graph from stdin.
omm instances --json
omm call ping --json
Update notices and omm doctor
Once a day omm checks the latest @orbito/omm and @orbito/api-lib in the Orbito npm
registry and the current agent skill (https://orbito.pl/docs/skill/version.json). The check
starts together with the command and its result is printed after it (also after an error),
always on stderr — stdout stays the clean command result:
! omm 1.1.0 is available (you have 1.0.1) — npm i -g @orbito/omm (https://orbito.pl/docs/agents/changelog.html)
With --json it is one line on stderr:
{"notices":[{"kind":"omm|sdk|skill","message":"...","fix":"...","url":"..."}]}. Notices:
omm— a neweromm; fixnpm i -g @orbito/omm, link to the changelog;sdk— only in a module directory (module.json): the lowest version of the@orbito/api-librange inpackage.json(^x.y.z,~x.y.z,x.y.z,>=x.y.z) is older than the latest; fixnpm i @orbito/api-lib@latest;skill— a localorbito-modules/SKILL.mdof Claude Code, Codex or OpenCode (user:~/.claude/skills,~/.codex/skills,~/.config/opencode/skills; project:.claude/skills,.codex/skills,.opencode/skillsin the current directory) differs from the published one; fix:omm skill install(omm skill install --projectfor project copies).
The result is cached for 24 h in the config (updateCheck); each request has a 3 s timeout and
network errors are silent (the previous result stays). OMM_NO_UPDATE_CHECK=1 turns the
automatic check off (CI).
omm doctor checks the whole setup at once and always fetches fresh versions
(also with OMM_NO_UPDATE_CHECK). Checks (ok / warn / fail, with a fix command):
node (engines), omm (vs latest), npm-scope (npm config get @orbito:registry),
registry-login (token + GET /developer/auth/me; warn without any namespace), core-login, company,
module (manifest, package.json with @orbito/api-lib, SDK vs latest) and skill:<agent>
per agent with the skill installed. The exit code is 1 only when a check fails.
omm doctor # table + fix lines
omm doctor --json # { "checks": [{ "name", "status", "message", "fix"? }], "notices": [...] }
Configuration
~/.config/omm/config.json— publish token per registry (registries[url] = { token, email },registry= last used registry), session per core (cores[url] = { token, expiresAt, email, companyId },core= last used core), last update check (updateCheck, cached 24 h).omm loginfills bothregistriesandcores.OMM_TOKEN— publish token from env (overrides the config; for CI).OMM_REGISTRY/--registry— registry API URL (defaulthttps://modules.orbito.pl/api).OMM_CORE/--core <url>— core API URL (default: last used, thenhttps://v2.orbito.pl/api).OMM_CORE_TOKEN— core JWT from env (overrides the config, not refreshed).OMM_COMPANY/--company <id>— working company (overridesomm company use).OMM_SECRET_VALUE— value foromm secrets setwithout a prompt (CI).OMM_NO_UPDATE_CHECK=1— no automatic update check (CI);omm doctorstill checks.OMM_PACKAGES_REGISTRY— npm registry of the@orbitopackages (defaulthttps://git.kozminski.net.pl/api/packages/orbito/npm/): source of the latest versions, the valueomm doctorexpects in@orbito:registryand the oneomm skill installsets there.OMM_SKILL_URL— source ofSKILL.mdforomm skill install(defaulthttps://orbito.pl/docs/skill/SKILL.md;file://URLs work too).
CI
CI needs no password and no omm login:
- Publishing (
omm publish,omm secrets,omm repo,omm solution):OMM_TOKEN=omm_...— a publish token created in the developer panel of the registry (recommended: one token per pipeline, revocable on its own), or the oneomm loginsaved in~/.config/omm/config.json(registries["<registry>"].token;omm logouton that machine revokes it).omm login --token omm_...saves such a token in the config instead. - Core commands (
install,logs,call,automation…):OMM_CORE_TOKEN=<core JWT>(valid 48 h, not refreshed) andOMM_COMPANY=<company id>. OMM_NO_UPDATE_CHECK=1turns the update notices off.
What goes into the package
If module.json has a files field (array of paths) — only the listed files and
directories (module.json is always included). Without files — the whole module
directory except: node_modules/, .git/, .env*, .npmrc, *.zip,
make-zip.sh, editor files.
.npmrc is excluded by default (secrets in the package). If the module's Docker
build needs private npm packages, add --include-npmrc deliberately.
Module secrets (omm secrets)
App keys (e.g. a marketplace client ID/secret) should not live in the module code. The registry stores the values — encrypted, globally per module code (not per version or company). The core fetches them when a module container starts and passes them as environment variables.
The module declares its secrets in module.json (without values):
{
"name": "core/allegro",
"version": "1.2.0",
"secrets": [
{ "name": "ALLEGRO_CLIENT_ID", "description": "Allegro app client ID (production)" },
{ "name": "ALLEGRO_CLIENT_SECRET" }
]
}
Name: ^[A-Z][A-Z0-9_]*$, max 64 characters, no ORBITO_ prefix (reserved for the core),
no duplicates; description is optional, max 200 characters.
omm secrets list # module code from ./module.json
omm secrets list --module core/allegro # or the given one
omm secrets set ALLEGRO_CLIENT_SECRET # value from a hidden prompt
OMM_SECRET_VALUE=... omm secrets set ALLEGRO_CLIENT_SECRET # CI, no prompt
omm secrets unset ALLEGRO_CLIENT_SECRET
listshows secrets declared in the latest version plus stored ones, with statusset/missing value/undeclared— never the values.setalso works for a name that is not declared yet (values can be set before the first publish). An empty value is an error.- A new value reaches containers on their next start — no new module version needed.
- Publishing is not blocked by missing values —
omm publish --releaseprints a⚠warning for every declared secret without a value.
Repository link (omm repo)
The module card can keep a link to the git repository with the module code, so everyone working
on the module knows where the current code lives. Only members of the module namespace see it
(developer panel and omm) — it is not in module.json, the package or the store.
omm repo # show (module code from ./module.json)
omm repo --module core/allegro # or the given one
omm repo set # URL of git remote "origin" of the current directory
omm repo set https://github.com/acme/hello # or the given URL
omm repo unset # remove the link
Accepted formats: https://… / http://…, ssh://… and git@host:org/repo.git;
the registry validates the URL and rejects URLs with a password or token
(https://user:token@…). omm repo set without a URL drops credentials from an http(s) origin
before saving. --json prints { "moduleCode", "repositoryUrl" }
(null when there is no link).
How publishing works
POST /developer/publish— ZIP upload; the server readsmodule.json, checks that the token's user is a member of the module namespace and the semver, and queues the Docker image build. A draft of the same version is overwritten (retry without bumping the version); published versions are immutable.GET /developer/publish/:imageId— the CLI polls the build status.POST /developer/publish/:imageId/finalize— only with--release: publishing (draft → published); the previously published version becomes deprecated. Server warnings (warnings, e.g. a secret without a value) are printed as⚠.
Authorization: Authorization: Bearer omm_... header (publish token, managed in the
developer panel or by omm login/omm logout).
Registry endpoints used (account, namespaces and solutions)
| Command | Endpoint |
|---|---|
login |
POST /developer/auth/tokens (with the core JWT); --token omm_...: GET /developer/publish/whoami |
logout |
DELETE /developer/publish/token |
whoami |
GET /developer/auth/me |
init |
GET /developer/auth/me (without --namespace), POST /developer/modules ({ namespace, name, shortDescription }) |
namespace list / create |
GET /developer/namespaces, POST /developer/namespaces |
namespace members |
GET /developer/namespaces/:name |
namespace invite |
POST /developer/namespaces/:name/members ({ email }) |
namespace remove |
DELETE /developer/namespaces/:name/members/:coreUserId or DELETE /developer/namespaces/:name/invitations/:email |
solution publish |
POST /developer/publish/solution (multipart: manifest = JSON with the automation graphs in place of the paths, files readme, cover) |
solution list / unpublish |
GET /developer/solutions, DELETE /developer/solutions/:slug |
Orbito Core endpoints used
| Command | Endpoint |
|---|---|
login |
POST /auth/signin, GET /users/me |
| (automatic refresh) | POST /auth/refresh |
company list / company use |
GET /users/me |
install |
POST /m/:moduleCode/enable (org_name, withDependencies: true) |
update |
POST /m/i/:id/update; same version: POST /m/i/:id/reload |
instances |
GET /m/instances |
logs |
GET /m/i/:id/logs (forDay, since), --container: GET /m/i/:id/container-logs |
problems |
GET /problems?moduleCode= |
call |
POST /m/i/:id/api/:method |
automation list / get |
GET /automations (isEnabled, query, limit), GET /automations/:id |
automation create / update |
POST /automations?strict=true, PUT /automations/:id?strict=true |
automation enable / disable |
PUT /automations/:id ({ isEnabled }) |
automation delete / duplicate |
DELETE /automations/:id, POST /automations/:id/duplicate |
automation elements / element |
GET /automations/editor/elements |
automation runs / run |
GET /automations/runs (automationId, status, eventValue, limit), GET /automations/runs/:runId |
automation var list / get / set |
GET /automations/vars, GET / PUT /automations/vars/:key |
Requests carry Authorization: Bearer <jwt> and the working company in x-company-id.
Dependencies
Dependencies
| ID | Version |
|---|---|
| commander | ^12.1.0 |
| yaml | ^2.9.1 |
| yazl | ^2.5.1 |