Orbito Orders managment

@orbito/omm (2.2.0)

Published 2026-10-27 13:33:49 +01:00 by wiktor

Installation

@orbito:registry=https://git.kozminski.net.pl/api/packages/orbito/npm/
npm install @orbito/omm@2.2.0
"@orbito/omm": "2.2.0"

About this package

OrbitoModulesManager — CLI to pack, publish and test Orbito modules (modules.orbi.do, Orbito Core)

OMM — OrbitoModulesManager

CLI for Orbito modules:

  • registry (modules.orbi.do) — pack and publish modules, the npm publish of Orbito modules, and business solutions (module sets with automation templates);
  • Orbito Core (my.orbi.do) — 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 my.orbi.do) 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://my.orbi.do.

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 login signs 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, named omm-<hostname>) and saves it. Both are written only when both steps succeed.
  • --core and --registry only choose the servers (defaults: last used, OMM_CORE / OMM_REGISTRY, then https://my.orbi.do/api and https://modules.orbi.do/api). A bare --core (the omm 1.x syntax) means the default core.
  • Moved on 2026-10-25: Orbito Core is now https://my.orbi.do/api; the old https://v2.orbito.pl/api only redirects, and the redirect drops your session (core commands fail with Access forbidden). If your config or OMM_CORE still points there, omm prints a core notice with every core command — log in again with omm login --core https://my.orbi.do/api (and update OMM_CORE in scripts/CI).
  • Moved on 2026-10-27: the registry is now https://modules.orbi.do/api; the old https://modules.orbito.pl/api still works for now but will be retired. If --registry, OMM_REGISTRY or the config (registry, last used) still points there, omm prints a registry notice with every registry command — log in again with omm login --registry https://modules.orbi.do/api (and update OMM_REGISTRY in scripts/CI).
  • 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 with GET /developer/publish/whoami); core commands then need omm login or OMM_CORE_TOKEN.
  • omm logout revokes 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: login prints { email, core, expiresAt, companyId, companies, registry, tokenName } ({ registry, email } with --token omm_...), whoami prints { registry, id, email, name, namespaces: [{ id, name, role }] }, logout prints { 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
  • invite adds 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.
  • remove looks 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>. --json prints the list for list and 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 --code the command creates the module card in a namespace in the registry (POST /developer/modules, needs omm login); the registry assigns the module code <namespace>/<slug of the name>. The namespace is --namespace, otherwise your only namespace (from GET /developer/auth/me); with several namespaces omm init asks 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 --code the card must already exist and the registry is not called.
  • --dir defaults 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 the hello-module example in the docs): module.json, package.json, index.js, pages/hello.yaml and .gitignore, with the module code put into every file and --description into package.json. npm install is not run.
  • --json prints { code, dir, files, cardCreated }.

Next: cd <dir> && npm install, then follow the build loop: https://orbi.do/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 from module.json in the current directory (-C <dir> for another one). instances, logs, problems and call also accept --module <namespace/name>.
  • update, logs and call act 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>.
  • install always installs missing dependencies too (withDependencies).
  • update compares the instance version with module.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. --json prints the core response plus "action": "update" or "action": "reload".
  • call runs the method with the permissions of the logged-in user; the core wraps the result in a one-element array — omm prints 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 (except company 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"
}
  • type is the element type from omm automation elements; module elements are <moduleCode>:<code> and need params.__instanceId (the instance that runs them). branches maps the action outputs (next, or e.g. true/false of a condition) to the next action id or null.
  • Draft → enable. create always saves a disabled automation and update never changes isEnabled; a graph file with isEnabled is rejected. Enable it explicitly with omm 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> --json can be edited and fed back to omm automation update <id> -f once isEnabled is removed — read-only fields (_id, validation, generatedName, …) are dropped before sending.
  • create and update send ?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 as path: message (CODE); for a rejected enable the blocking elements (triggers.0: <type> (<status>)) and invalid action params. With --json they are in the validation field of the error on stderr:
{"error":"Automation graph is invalid","status":422,"validation":{"errors":[{"path":"actions.a1.params.__instanceId","code":"REQUIRED","message":"..."}]}}
  • --json prints { automationId, name, isEnabled } for create, update, enable, disable and duplicate, the core response for the other commands, and a list of elements with kind (trigger / action) for elements. element prints JSON also without --json.
  • list shows up to 50 automations, runs up 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, isEnabled rejected, read-only fields dropped), so a working automation from your test company moves into a solution with omm automation get <id> --json (remove isEnabled). Do not keep params.__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-empty modules, 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.md or a cover the description or the cover is cleared. Installs and the publication date are kept.
  • publish prints the solution and its public page https://modules.orbi.do/solutions/<slug>; --json prints the registry response with url. list --json prints the list, unpublish --json the solution with isPublished: 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, .opencode in the current directory); if none exists, to Claude Code. The file lands in <agent dir>/skills/orbito-modules/SKILL.md.
  • --all installs for all three agents; --agent claude|codex|opencode (repeatable) only for the given ones.
  • The skill is downloaded from https://orbi.do/docs/skill/SKILL.md (OMM_SKILL_URL overrides it, also with a file:// URL) and must declare name: orbito-modules, otherwise nothing is written.
  • Unless --no-npm is given, the command maps the @orbito scope 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).
  • --json prints { 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://orbi.do/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://orbi.do/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://orbi.do/docs/agents/changelog.html)

With --json it is one line on stderr: {"notices":[{"kind":"omm|sdk|skill|core|registry","message":"...","fix":"...","url":"..."}]}. Notices:

  • core — commands with --core only, without network (also with OMM_NO_UPDATE_CHECK): the core URL is an old host (v2.orbito.pl); fix omm login --core https://my.orbi.do/api. omm doctor reports it as core-login warn;

  • registry — commands with --registry only, without network (also with OMM_NO_UPDATE_CHECK): the registry URL is an old host (modules.orbito.pl); fix omm login --registry https://modules.orbi.do/api. omm doctor reports it as registry-login warn;

  • omm — a newer omm; fix npm i -g @orbito/omm, link to the changelog;

  • sdk — only in a module directory (module.json): the lowest version of the @orbito/api-lib range in package.json (^x.y.z, ~x.y.z, x.y.z, >=x.y.z) is older than the latest; fix npm i @orbito/api-lib@latest;

  • skill — a local orbito-modules/SKILL.md of Claude Code, Codex or OpenCode (user: ~/.claude/skills, ~/.codex/skills, ~/.config/opencode/skills; project: .claude/skills, .codex/skills, .opencode/skills in the current directory) differs from the published one; fix: omm skill install (omm skill install --project for 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 login fills both registries and cores.
  • OMM_TOKEN — publish token from env (overrides the config; for CI).
  • OMM_REGISTRY / --registry — registry API URL (default https://modules.orbi.do/api).
  • OMM_CORE / --core <url> — core API URL (default: last used, then https://my.orbi.do/api).
  • OMM_CORE_TOKEN — core JWT from env (overrides the config, not refreshed).
  • OMM_COMPANY / --company <id> — working company (overrides omm company use).
  • OMM_SECRET_VALUE — value for omm secrets set without a prompt (CI).
  • OMM_NO_UPDATE_CHECK=1 — no automatic update check (CI); omm doctor still checks.
  • OMM_PACKAGES_REGISTRY — npm registry of the @orbito packages (default https://git.kozminski.net.pl/api/packages/orbito/npm/): source of the latest versions, the value omm doctor expects in @orbito:registry and the one omm skill install sets there.
  • OMM_SKILL_URL — source of SKILL.md for omm skill install (default https://orbi.do/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 one omm login saved in ~/.config/omm/config.json (registries["<registry>"].token; omm logout on 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) and OMM_COMPANY=<company id>.
  • OMM_NO_UPDATE_CHECK=1 turns 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
  • list shows secrets declared in the latest version plus stored ones, with status set / missing value / undeclared — never the values.
  • set also 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 --release prints 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

  1. POST /developer/publish — ZIP upload; the server reads module.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.
  2. GET /developer/publish/:imageId — the CLI polls the build status.
  3. 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
Details
npm
2026-10-27 13:33:49 +01:00
15
UNLICENSED
latest
61 KiB
Assets (1)
omm-2.2.0.tgz 61 KiB
Versions (15) View all
2.2.0 2026-10-27
2.1.3 2026-10-27
2.1.2 2026-10-25
2.1.1 2026-10-25
2.1.0 2026-10-16