kelta CLI — Command Reference

CLI version 0.1.0 · manifest v1 · output formats: table, json, yaml, csv, ndjson

Global flags on every command: --profile, --output, --raw, --quiet, --yes. Full machine-readable catalog: kelta manifest.

auth#

kelta auth login writes the profile named by --profile (or KELTA_PROFILE), otherwise the default profile. Without an explicit profile, a --tenant that differs from the default profile’s saved tenant is refused (exit 2, PROFILE_TENANT_MISMATCH) and nothing is changed — log in to the other tenant as its own profile with --profile <name>. Re-login to the same tenant, a profile with no saved tenant, and any explicit --profile are written as asked. The output names the profile that was written.

kelta auth login#

Log in via the browser and store a PAT for a profile (—token for headless)

• --url <url> — Kelta API URL (default: from the profile)
• --tenant <slug> — Tenant slug (default: from the profile; a different tenant needs an explicit —profile)
• --auth-url <url> — Auth server URL (default: profile value, or api.→auth. host derivation)
• --token <token> — Skip the browser: store this PAT (klt_…) or JWT
• --expires-in <days> — PAT lifetime in days (browser login) (default: “90”)
• --no-browser — Print the login URL instead of opening a browser

# Log in through the browser and save a 90-day PAT
kelta auth login --url https://api.kelta.io --tenant acme
# Headless login with an existing PAT
kelta auth login --url https://api.kelta.io --tenant acme --profile staging --token "$KELTA_TOKEN"

kelta auth logout#

Remove the stored credential for the active profile (—revoke also revokes it)

• --revoke — Revoke the PAT server-side before removing it locally

kelta auth logout
# Revoke the PAT server-side, then forget it locally
kelta auth logout --revoke --profile staging

kelta auth status#

Show the resolved connection settings for the active profile

kelta auth status --profile staging --output json

token#

kelta token list#

List your active personal access tokens

kelta token list

kelta token create#

Create a personal access token (the full token is shown exactly once)

• --name <name> — Token name
• --expires-in <days> — Lifetime in days (1-365) (default: “90”)

# Create a 30-day token for CI
kelta token create --name ci-deploy --expires-in 30

kelta token revoke <tokenId>#

Revoke a personal access token by id (destructive — needs —yes off-TTY)

kelta token revoke 3f6c1a52-8d2e-4b7a-9c1e-5a0d2f7b9e14 --yes

profile#

kelta profile list#

List configured profiles

kelta profile list

kelta profile use <name>#

Set the default profile

kelta profile use staging

kelta profile show [name]#

Show the resolved settings of a profile (default: active profile)

kelta profile show staging --output json

kelta profile remove <name>#

Remove a profile and its stored credential

kelta profile remove staging

kelta profile rename <oldName> <newName>#

Rename a profile (credential moves with it)

kelta profile rename default production

collections#

kelta collections list#

List all collections

kelta collections list

kelta collections describe <name>#

Show collection details and fields

kelta collections describe customers

kelta collections create#

Create a collection

• --name <name> — API name (required)
• --display-name <label> — Display name
• --description <text> — Description
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta collections create --name invoices --display-name Invoices --description 'Customer invoices'
# Create from a JSON attributes file
kelta collections create --name orders --data @orders-collection.json

kelta collections update <collection>#

Update a collection (name or id)

• --display-name <label> — Display name
• --description <text> — Description
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta collections update invoices --display-name 'Sales Invoices'

kelta collections delete <collection>#

Delete a collection and its data (destructive — needs —yes off-TTY)

• --force — Confirm deletion of a collection that still has dependent data (attachments, layouts, reports, validation rules, field history, record versions, …); the server blocks the delete without this.

kelta collections delete invoices --yes
# Delete even though layouts and other dependent data exist
kelta collections delete invoices --force --yes

fields#

kelta fields list <collection>#

List the fields of a collection

kelta fields list customers

kelta fields add <collection>#

Add a field to a collection (friendly type aliases: text, number, picklist, reference, …)

• --name <name> — Field API name (required)
• --type <type> — Field type alias or native enum (required)
• --display-name <label> — Display name
• --required — Field is required
• --unique — Unique constraint
• --indexed — Create an index
• --searchable — Full-text searchable
• --system-maintained — Only flows and server-side code may set the value; an API write that sets or changes it gets a 400 (see kelta docs jsonapi)
• --description <text> — Description
• --default <value> — Default value (true|false for BOOLEAN, a number for numeric types)
• --picklist <name|id> — Global picklist source (picklist types)
• --values <a,b,c> — Comma-separated field-scoped picklist values (picklist types, instead of —picklist)
• --reference <collection> — Target collection (reference types)
• --relationship-name <name> — Relationship name (reference types)
• --dimension <n> — Vector dimension (vector type)
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

# Add a required currency field
kelta fields add invoices --name amount --type currency --required
# Picklist field with field-scoped values
kelta fields add orders --name status --type picklist --values draft,submitted,shipped --default draft

kelta fields update <fieldId>#

Update a field by id

• --display-name <label> — Display name
• --required <bool> — true|false
• --system-maintained <bool> — true|false — set or clear the system-maintained flag (see kelta docs jsonapi)
• --description <text> — Description
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta fields update fld_123 --display-name 'Due Date' --required true

kelta fields remove <fieldId>#

Remove a field and its data (destructive — needs —yes off-TTY)

kelta fields remove fld_123 --yes

picklists#

kelta picklists list#

List global picklists

• --name <name> — Filter by exact name

kelta picklists list
# Look up one picklist by exact name
kelta picklists list --name order_status

kelta picklists get <picklist>#

Show a global picklist with its values

kelta picklists get order_status

kelta picklists create#

Create a global picklist (optionally with initial values)

• --name <name> — Picklist name (required)
• --description <text> — Description
• --values <list> — Initial values, comma-separated (value used as label)

# Create a picklist with four initial values
kelta picklists create --name order_status --description 'Order lifecycle' --values draft,submitted,shipped,cancelled

kelta picklists delete <picklist>#

Delete a global picklist (destructive — needs —yes off-TTY)

kelta picklists delete order_status --yes

kelta picklists value-add <picklist>#

Add a value to a global picklist

• --value <value> — Stored value (required)
• --label <label> — Display label (default: the value)
• --sort <n> — Sort order (default: “0”)
• --default — Mark as the default value

kelta picklists value-add order_status --value returned --label Returned --sort 4

kelta picklists value-update <valueId>#

Update a picklist value by id

• --value <value> — Stored value
• --label <label> — Display label
• --sort <n> — Sort order
• --active <bool> — true|false
• --default <bool> — true|false

kelta picklists value-update val_123 --label 'On hold' --sort 2

kelta picklists value-deactivate <valueId>#

Deactivate a picklist value (records keep it; new picks cannot use it)

kelta picklists value-deactivate val_123

validation-rules#

kelta validation-rules list <collection>#

List validation rules of a collection

kelta validation-rules list invoices

kelta validation-rules create <collection>#

Create a validation rule (record is REJECTED when —formula evaluates TRUE)

• --name <name> — Rule name (required)
• --formula <formula> — ERROR condition — TRUE rejects the record (required)
• --message <text> — Error message shown to the user (required)
• --evaluate-on <when> — CREATE|UPDATE|CREATE_AND_UPDATE (default: “CREATE_AND_UPDATE”)
• --severity <level> — ERROR|WARNING (default: “ERROR”)
• --error-field <field> — Field to attach the error to
• --inactive — Create the rule inactive

# Reject invoices whose amount is zero or negative
kelta validation-rules create invoices --name positive_amount --formula 'amount <= 0' --message 'Amount must be positive' --error-field amount
# Warn on update when the due date is blank
kelta validation-rules create orders --name due_date_set --formula 'ISBLANK(due_date)' --message 'Set a due date' --evaluate-on UPDATE --severity WARNING

kelta validation-rules update <ruleId>#

Update a validation rule by id

• --active <bool> — true|false
• --data <json> — Attributes as JSON, @file, or - (merged last)

# Deactivate a rule
kelta validation-rules update rule_123 --active false
kelta validation-rules update rule_123 --data '{"errorMessage": "Amount must be greater than zero"}'

kelta validation-rules delete <ruleId>#

Delete a validation rule (destructive — needs —yes off-TTY)

kelta validation-rules delete rule_123 --yes

constraints#

kelta constraints list <collection>#

List composite unique constraints of a collection

kelta constraints list orders

kelta constraints create <collection>#

Create a composite unique constraint (Postgres unique index; duplicates → 409)

• --fields <list> — Field names, comma-separated (required)

# Make each order number unique per customer
kelta constraints create orders --fields customer,order_number

kelta constraints delete <collection> <indexName>#

Drop a composite unique constraint by index name (destructive — needs —yes off-TTY)

kelta constraints delete orders uq_orders_customer_order_number --yes

layouts#

kelta layouts list <collection>#

List page layouts of a collection

kelta layouts list customers

kelta layouts create <collection>#

Create a page layout (sections/fields via the UI or kelta api)

• --name <name> — Layout name (required)
• --default — Mark as the default layout
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta layouts create customers --name 'Customer detail' --default

kelta layouts get <layoutId>#

Get a page layout by id

• --tree — Fetch the whole layout as a tree (sections, field placements, related lists) — the document layouts apply --file accepts.

kelta layouts get lay_123
# Fetch the full tree, the shape layouts apply accepts
kelta layouts get lay_123 --tree --output json

kelta layouts apply <collection>#

Apply a layout tree file (sections, fields, related lists) to a collection

• --file <path> — Layout tree JSON file — see layouts get <id> --tree for the shape. Also accepts an apply_layout (MCP) argument file as-is: collectionName/layoutId are stripped before forwarding, and a layoutId addresses the layout by id.
• --name <name> — Layout name (overrides the file’s own “name”; addresses the layout within the collection, creating it if it does not exist yet)

kelta layouts apply customers --file customer-layout.json
# Override the layout name from the file
kelta layouts apply customers --file customer-layout.json --name 'Customer detail'

kelta layouts update <layoutId>#

Update a page layout by id

• --name <name> — Layout name
• --default <bool> — true|false
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta layouts update lay_123 --name 'Customer summary' --default true

kelta layouts delete <layoutId>#

Delete a page layout (destructive — needs —yes off-TTY)

kelta layouts delete lay_123 --yes

list-views#

kelta list-views list <collection>#

List saved list views of a collection

kelta list-views list orders

kelta list-views create <collection>#

Create a saved list view

• --name <name> — List view name (required)
• --columns <list> — Displayed field names, comma-separated (required)
• --filter <spec> — Filter as field[.op]=value (repeatable) (repeatable)
• --sort <field> — Sort field, -prefix for descending
• --default — Mark as the default list view
• --visibility <vis> — PRIVATE (default), PUBLIC or GROUP
• --view-type <type> — Renderer: TABLE (default), KANBAN, CALENDAR or GALLERY
• --lane-field <field> — Kanban lane field (a picklist field)
• --card-fields <list> — Kanban card fields, comma-separated
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

# Table view of open orders, newest first
kelta list-views create orders --name 'Open orders' --columns order_number,customer,amount,status --filter status=open --sort -createdAt
# Kanban board laned by status
kelta list-views create orders --name 'Order board' --columns order_number,amount --view-type KANBAN --lane-field status --card-fields customer,amount

kelta list-views apply <collection>#

Create-or-update a saved list view, keyed on (collection, name)

• --name <name> — List view name (required)
• --columns <list> — Displayed field names, comma-separated (required)
• --filter <spec> — Filter as field[.op]=value (repeatable); always written as given (repeatable)
• --sort <field> — Sort field, -prefix for descending
• --row-limit <n> — Maximum rows rendered
• --default <bool> — true|false — omit to leave the current value alone
• --visibility <vis> — PRIVATE, PUBLIC or GROUP
• --view-type <type> — Renderer: TABLE, KANBAN, CALENDAR or GALLERY
• --lane-field <field> — Kanban lane field (a picklist field)
• --card-fields <list> — Kanban card fields, comma-separated
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

# Create or update the shared Overdue view
kelta list-views apply invoices --name Overdue --columns invoice_number,customer,amount,due_date --filter status=unpaid --filter due_date.lt=2026-11-01 --sort due_date --visibility PUBLIC

kelta list-views update <listViewId>#

Update a saved list view by id

• --name <name> — List view name
• --columns <list> — Displayed field names, comma-separated
• --filter <spec> — Filter as field[.op]=value (repeatable); replaces all filters (repeatable)
• --sort <field> — Sort field, -prefix for descending
• --default <bool> — true|false
• --visibility <vis> — PRIVATE, PUBLIC or GROUP
• --view-type <type> — Renderer: TABLE, KANBAN, CALENDAR or GALLERY
• --lane-field <field> — Kanban lane field (a picklist field)
• --card-fields <list> — Kanban card fields, comma-separated
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta list-views update lv_123 --columns order_number,customer,status --sort -amount

kelta list-views get <listViewId>#

Get a saved list view by id

kelta list-views get lv_123

kelta list-views delete <listViewId>#

Delete a saved list view (destructive — needs —yes off-TTY)

kelta list-views delete lv_123 --yes

pages#

kelta pages list#

List UI pages (screen builder)

kelta pages list

kelta pages get <pageId>#

Get a UI page by id

kelta pages get page_123 --output json

kelta pages create#

Create a UI page (draft — unpublished until pages publish)

• --name <name> — Page name (required)
• --path <path> — Route the page is served at (required)
• --title <title> — Browser and header title
• --config <json> — Page config as JSON, @file, or - (layout, components, bindings)
• --active <bool> — true|false (default true)
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

# Create a draft page at /home
kelta pages create --name Home --path /home --title 'Welcome' --config @home-config.json

kelta pages apply <file>#

Validate then create-or-update a UI page from a JSON file, keyed on path. Returns {action, id, path, changed, published} like apply_page — pass —raw for the full ui-pages record instead. (destructive — needs —yes off-TTY)

• --dry-run — Validate config only; write nothing

# Validate the page config without writing
kelta pages apply home-page.json --dry-run
# Create or update the page keyed on its path
kelta pages apply home-page.json --yes

kelta pages update <pageId>#

Update a UI page by id

• --name <name> — Page name
• --path <path> — Route the page is served at
• --title <title> — Browser and header title
• --config <json> — Page config as JSON, @file, or -
• --active <bool> — true|false
• --published <bool> — true|false
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta pages update page_123 --title 'Customer home' --published true

kelta pages delete <pageId>#

Delete a UI page (destructive — needs —yes off-TTY)

kelta pages delete page_123 --yes

kelta pages publish <path>#

Publish the UI page served at a route path (sets published=true). Returns {action: “published”|“unchanged”, id, path}.

kelta pages publish /home

menus#

kelta menus list#

List UI menus (apps/nav v2)

kelta menus list

kelta menus get <menu>#

Get a UI menu by name or id (—tree nests items by parentId)

• --tree — Include menu items nested by parentId under attribute “items”

# Show the Sales menu with nested items
kelta menus get Sales --tree

kelta menus create#

Create a UI menu

• --name <name> — Menu name (required)
• --description <text> — Description
• --icon <name> — Icon rendered beside the app label
• --display-order <n> — Ordinal position among sibling menus
• --default — Mark as the default menu
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta menus create --name Sales --icon briefcase --display-order 2

kelta menus apply#

Apply a menu tree file (items/groups) in one call, creating the menu if needed

• --file <path> — Menu tree JSON file — see menus get <name> --tree for the shape
• --name <name> — Menu name (overrides the file’s own “name”; creates the menu if it does not exist yet)

# Apply the tree using the file's own name
kelta menus apply --file sales-menu.json
# Apply the tree to the Sales menu, creating it if needed
kelta menus apply --file sales-menu.json --name Sales

kelta menus update <menuId>#

Update a UI menu by id

• --name <name> — Menu name
• --description <text> — Description
• --icon <name> — Icon rendered beside the app label
• --display-order <n> — Ordinal position among sibling menus
• --default <bool> — true|false
• --active <bool> — true|false
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta menus update menu_123 --default true --display-order 1

kelta menus delete <menuId>#

Delete a UI menu (destructive — needs —yes off-TTY)

kelta menus delete menu_123 --yes

dashboards#

kelta dashboards list#

List dashboards

kelta dashboards list

kelta dashboards get <dashboardId>#

Get a dashboard by id (—components includes widgets sorted by row/column)

• --components — Include dashboard components, sorted by rowPosition then columnPosition

# Include widgets in grid order
kelta dashboards get dash_123 --components

kelta dashboards create#

Create a dashboard (add widgets via kelta api — dashboard-components)

• --name <name> — Dashboard name (required)
• --description <text> — Description
• --access-level <level> — PRIVATE (default), PUBLIC or HIDDEN
• --column-count <n> — Width of the dashboard grid in columns
• --dynamic — Widgets execute as —running-user-id rather than the viewer
• --running-user-id <id> — User a dynamic dashboard executes widgets as
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta dashboards create --name 'Sales overview' --access-level PUBLIC --column-count 12

kelta dashboards apply#

Apply a dashboard tree file (widgets) in one call, creating the dashboard if needed

• --file <path> — Dashboard tree JSON file — see dashboards get <id> --components for the shape
• --name <name> — Dashboard name (overrides the file’s own “name”; creates the dashboard if it does not exist yet)

# Apply widgets, creating the dashboard if needed
kelta dashboards apply --file sales-dashboard.json --name 'Sales overview'

kelta dashboards update <dashboardId>#

Update a dashboard by id

• --name <name> — Dashboard name
• --description <text> — Description
• --access-level <level> — PRIVATE, PUBLIC or HIDDEN
• --column-count <n> — Width of the dashboard grid in columns
• --dynamic <bool> — true|false
• --running-user-id <id> — User a dynamic dashboard executes widgets as
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

kelta dashboards update dash_123 --access-level PRIVATE --description 'Weekly sales KPIs'

kelta dashboards delete <dashboardId>#

Delete a dashboard (destructive — needs —yes off-TTY)

kelta dashboards delete dash_123 --yes

kelta dashboards validate <dashboard>#

Validate a dashboard’s widget configs (read-only; prints the API response as-is)

• --data <json> — Body as JSON, @file, or - — e.g. {“components”:[…]} to validate unsaved widgets

kelta dashboards validate 'Sales overview'

kelta dashboards data <dashboard>#

Execute a dashboard’s widgets and print their data (read-only; API response as-is)

• --data <json> — Runtime parameters as JSON, @file, or - (e.g. {“timeRange”:“LAST_30_DAYS”})

# Widget data for the last 30 days
kelta dashboards data 'Sales overview' --data '{"timeRange": "LAST_30_DAYS"}'

reports#

kelta reports list#

List saved reports

kelta reports list

kelta reports get <reportId>#

Get a report definition by id

kelta reports get rep_123 --output json

flows#

kelta flows list#

List flow definitions

kelta flows list --output json

kelta flows describe <flowId>#

Show a flow definition

kelta flows describe flow_123

kelta flows create#

Create a flow (definition JSON is the state machine)

• --name <name> — Flow name (required)
• --type <type> — RECORD_TRIGGERED|SCHEDULED|AUTOLAUNCHED|SCREEN|NATS_TRIGGERED
• --definition <json> — Definition as JSON, @file, or - (required)
• --description <text> — Description
• --trigger-config <json> — Trigger config as JSON, @file, or -
• --active — Create the flow active (default: inactive)
• --step-logging <level> — FULL (every step with snapshots) | ERRORS_ONLY (snapshots only for a failed step) | NONE (only a failed step) (default: FULL)
• --retention-days <days> — Days a finished run and its step logs are kept, 1-3650 (default: the platform-wide window)

# Active flow that runs whenever an order is created
kelta flows create --name 'Notify on new order' --type RECORD_TRIGGERED --definition @order-flow.json --trigger-config '{"collection": "orders", "events": ["CREATE"]}' --active
# Scheduled flow that keeps runs for 30 days
kelta flows create --name 'Nightly cleanup' --type SCHEDULED --definition @cleanup.json --step-logging ERRORS_ONLY --retention-days 30

kelta flows update <flowId>#

Update a flow by id

• --active <bool> — true|false
• --definition <json> — Definition as JSON, @file, or -
• --step-logging <level> — FULL (every step with snapshots) | ERRORS_ONLY (snapshots only for a failed step) | NONE (only a failed step)
• --retention-days <days> — Days a finished run and its step logs are kept, 1-3650 (default: the platform-wide window); “default” clears the override
• --data <json> — Extra attributes as JSON, @file, or - (merged last)

# Deactivate a flow
kelta flows update flow_123 --active false
# Replace the definition and reset retention to the platform default
kelta flows update flow_123 --definition @order-flow.json --retention-days default

kelta flows delete <flowId>#

Delete a flow with its execution history and step logs (refused while a run is RUNNING or WAITING) (destructive — needs —yes off-TTY)

kelta flows delete flow_123 --yes

kelta flows execute <flowId>#

Start a flow run (flows read input as $.input.)

• --input <json> — Flow input as JSON, @file, or -
• --test — Mark the run as a test execution
• --wait — Poll until COMPLETED/FAILED/CANCELLED (~5 min budget)

# Run with input read as $.input.orderId and wait for the result
kelta flows execute flow_123 --input '{"orderId": "rec_123"}' --wait
# Start a test run from a file
kelta flows execute flow_123 --input @input.json --test

kelta flows runs <flowId>#

List recent executions of a flow

• --limit <n> — Max runs (default: “50”)

kelta flows runs flow_123 --limit 10

kelta flows run <executionId>#

Show one execution (—steps for per-step detail)

• --steps — Include per-step detail

# Show an execution with per-step detail
kelta flows run exec_123 --steps

kelta flows cancel <executionId>#

Cancel a running execution (destructive — needs —yes off-TTY)

kelta flows cancel exec_123 --yes

kelta flows retry <executionId>#

Retry an execution (new run)

• --mode <mode> — full|from-failure (default: “full”)

# Resume from the failed step
kelta flows retry exec_123 --mode from-failure

kelta flows publish <flowId>#

Publish the current flow definition as a new version

• --summary <text> — Change summary

kelta flows publish flow_123 --summary 'Add approval step'

kelta flows versions <flowId>#

List published versions of a flow

kelta flows versions flow_123

kelta flows webhook-url <flowId>#

Show the inbound webhook URL of an AUTOLAUNCHED flow

kelta flows webhook-url flow_123

users#

kelta users list#

List platform users

• --search <text> — Search filter (name/email contains)
• --status <status> — ACTIVE|INACTIVE
• --page <n> — Page number (default: “1”)
• --size <n> — Page size (default: “20”)

kelta users list --search jane --status ACTIVE --size 50

kelta users get <userId>#

Show one user

kelta users get usr_123

kelta users invite <userId>#

Send (or resend) the invite email to an existing user

kelta users invite usr_123

kelta users portal-invite#

Invite a portal (external) user

• --email <email> — Email address
• --data <json> — Full request body as JSON, @file, or - (wins on collision)

kelta users portal-invite --email jane@acme.example
# Send the full request body from a file
kelta users portal-invite --data @portal-user.json

kelta users reset-password <userId>#

Trigger a password reset for a user (destructive — needs —yes off-TTY)

kelta users reset-password usr_123 --yes

kelta users token-create <userId>#

Mint a personal access token on a user’s behalf (requires MANAGE_USERS) (destructive — needs —yes off-TTY)

• --name <name> — Token name
• --expires-in <days> — Lifetime in days (1-365) (default: “90”)

# 30-day token for a user
kelta users token-create usr_123 --name 'CI deploy' --expires-in 30 --yes

kelta users logins <userId>#

Show a user’s login history

• --size <n> — Page size (default: “20”)

kelta users logins usr_123 --size 10

tenants#

kelta tenants bootstrap-token <slug>#

Mint a short-lived PAT as a tenant’s admin (requires MANAGE_TENANTS; prints the token once)

• --expires-in <duration> — Lifetime: 30m, 2h or ISO-8601 (PT2H); max 24h (default: “1h”)
• --user-id <id> — A user of that tenant (default: the tenant’s seeded System Administrator)

# Short-lived admin token for the acme tenant
kelta tenants bootstrap-token acme --expires-in 30m

limits#

kelta limits get#

Show tenant governor-limit status

kelta limits get

kelta limits set-tier <tier>#

Set the tenant governor tier (destructive — needs —yes off-TTY)

kelta limits set-tier PROFESSIONAL --yes

kelta limits set#

Override individual governor limits (raw limits map, persisted per tenant) (destructive — needs —yes off-TTY)

• --data <json> — Limits map as JSON, @file, or - (required)

# Override the daily API call limit
kelta limits set --data '{"apiCallsPerDay": 50000}' --yes

audit#

kelta audit setup#

Recent setup (metadata) audit entries

• --since <iso> — Only entries at/after this ISO timestamp
• --size <n> — Page size (max 200) (default: “50”)

kelta audit setup --size 20
# Entries since 1 October 2026 as JSON
kelta audit setup --since 2026-10-01T00:00:00Z --output json

kelta audit security#

Recent security audit log entries

• --since <iso> — Only entries at/after this ISO timestamp
• --size <n> — Page size (max 200) (default: “50”)

kelta audit security --size 20
# Entries since 1 October 2026 as JSON
kelta audit security --since 2026-10-01T00:00:00Z --output json

kelta audit logins#

Recent login history

• --since <iso> — Only entries at/after this ISO timestamp
• --size <n> — Page size (max 200) (default: “50”)

kelta audit logins --size 20
# Entries since 1 October 2026 as JSON
kelta audit logins --since 2026-10-01T00:00:00Z --output json

records#

kelta records list <collection>#

List records in a collection

• --filter <spec> — Filter as field[.op]=value (repeatable) (repeatable)
• --sort <fields> — Sort fields, comma-separated, -prefix for desc
• --fields <fields> — Sparse fieldset, comma-separated
• --include <rels> — Related resources to include, comma-separated
• --page <number> — Page number (default: “1”)
• --size <number> — Page size (max 200) (default: “25”)
• --all — Auto-paginate through every page (client cap 10k records)

# Newest 50 active customers
kelta records list customers --filter status=active --sort -createdAt --size 50
# Every order of 100 or more, three fields each
kelta records list orders --filter amount.gte=100 --fields id,amount,status --all

kelta records get <collection> <id>#

Get a single record

• --include <rels> — Related resources to include
• --fields <fields> — Sparse fieldset, comma-separated

kelta records get orders rec_123 --include customer

kelta records create <collection>#

Create a record

• --data <json> — Attributes as JSON, @file, or - for stdin

kelta records create customers --data '{"name": "Acme Ltd", "status": "active"}'
# Attributes from a file
kelta records create orders --data @order.json

kelta records update <collection> <id>#

Update a record (partial)

• --data <json> — Attributes as JSON, @file, or - for stdin

kelta records update orders rec_123 --data '{"status": "shipped"}'

kelta records delete <collection> <id>#

Delete a record (destructive — needs —yes off-TTY)

kelta records delete customers rec_123 --yes

kelta records bulk#

Apply a batch of atomic operations (all-or-nothing, max 100 ops) (destructive — needs —yes off-TTY)

• --data <json> — Body as JSON, @file, or - : {“atomic:operations”:[{op,data|ref},…]} (required)

# Apply a JSON:API atomic:operations document, all-or-nothing
kelta records bulk --data @ops.json --yes

kelta records search <query>#

Full-text search across collections (query min 3 chars)

• --limit <n> — Max results (max 100) (default: “20”)

kelta records search acme --limit 5

kelta records semantic-search <collection> <query>#

Vector similarity search within one collection (needs a VECTOR field)

• --limit <n> — Max results (default: “10”)

kelta records semantic-search orders 'late delivery complaints' --limit 3

notifications#

kelta notifications list#

List your own in-app notifications, newest first

• --unread — Only unread notifications
• --page <n> — Page number (default: “1”)
• --size <n> — Page size (max 200) (default: “20”)

kelta notifications list
# Only what is still unread
kelta notifications list --unread --size 50

metadata#

kelta metadata export#

Export this tenant’s metadata as a package file

• -n, --name <name> — Package name (default: the tenant slug)
• -v, --version <version> — Package version (default: 1.0.0)
• --collections <list> — Collection names, comma-separated: export only these, with their validation rules, page layouts, list views, record-triggered flows, global picklists and the dashboards with a widget on them (default: the whole tenant)
• --exclude <types> — Item types to leave out, comma-separated: list-view, dashboard, flow, page-layout, validation-rule, ui-page, ui-menu (list views and dashboards are exported by default; seed records never are)
• -o, --out <file> — Output file (default: the name the server returns)

# Export the whole tenant
kelta metadata export --out metadata.json
# Export two collections without their list views and dashboards
kelta metadata export --collections customers,orders --exclude list-view,dashboard --name sales -v 1.2.0

kelta metadata diff <file>#

Preview a package file against this tenant (dry run, no writes): creates, updates with their changed attributes, unchanged counts, conflicts

kelta metadata diff metadata.json

kelta metadata apply <file>#

Apply a package file to this tenant (metadata items, then its seed records section) (destructive — needs —yes off-TTY)

• --dry-run — Validate without writing
• --conflict <mode> — On an item that already exists: skip (default) or overwrite (seed records are always skipped) (default: “skip”)

# Validate without writing
kelta metadata apply metadata.json --dry-run
# Apply, overwriting items that already exist
kelta metadata apply metadata.json --conflict overwrite --yes

sandbox#

A sandbox is its own tenant with its own users, not a view into the parent tenant — the parent’s PAT or session has no membership there and is refused on sandbox-tenant paths. sandbox create prints a one-time admin credential for the new tenant plus its sign-in URL (signInUrl, <ui-base-url>/<slug>/login) and API base URL (apiBaseUrl, <external-base-url>/<slug>); the worker builds both from kelta.ui-base-url (KELTA_UI_BASE_URL) and kelta.external-base-url (EXTERNAL_BASE_URL). Sign in at the printed URL, or authenticate via POST /auth/direct-login on the auth server (not the API host) with username, password and tenantSlug from the printed output, or run kelta auth login against the sandbox slug (browser login) and then kelta token create to mint a PAT scoped to it. By default the sandbox is a clone of the parent’s metadata (collections, fields, picklists, layouts, list views, flows, dashboards, menus, pages). sandbox create --empty sends cloneMetadata: false and creates it with the system defaults only — system collections, default profiles and the admin — while keeping the parent’s edition, settings, limits and IP allowlist; use it for a clean tenant to build a template, package or reproduction in. sandbox status and sandbox list show clone_mode (CLONED or EMPTY). An empty sandbox cannot be refreshed: sandbox refresh would clone the parent’s metadata into it, so it answers 409 EMPTY_SANDBOX_REFRESH; delete it and create one without --empty to get a clone.

kelta sandbox create#

Create a sandbox environment (prints one-time admin credentials)

• -n, --name <name> — Environment name
• -d, --description <description> — Environment description
• --empty — Create the sandbox without cloning the parent’s metadata: system collections, default profiles and the admin only (it cannot be refreshed)

kelta sandbox create --name staging --description 'Pre-release testing'
# Create a sandbox without cloning the parent's metadata
kelta sandbox create --name uat --empty

kelta sandbox list#

List environments

kelta sandbox list --output json

kelta sandbox status <envId>#

Show environment status (with —wait, poll until ACTIVE or FAILED)

• --wait — Poll until the environment reaches ACTIVE or FAILED

# Wait until the sandbox is ready
kelta sandbox status env_123 --wait

kelta sandbox refresh <envId>#

Refresh a sandbox environment from its source (an —empty sandbox is refused with 409) (destructive — needs —yes off-TTY)

kelta sandbox refresh env_123 --yes

kelta sandbox delete <envId>#

Delete a sandbox environment (archives it; decommissions the backing tenant) (destructive — needs —yes off-TTY)

kelta sandbox delete env_123 --yes

promote#

kelta promote create#

Create a promotion from a source to a target environment

• -s, --source <envId> — Source environment id
• -t, --target <envId> — Target environment id
• --type <type> — Promotion type: FULL or SELECTIVE (default: “FULL”)
• --conflict <mode> — Conflict mode: skip or overwrite (default: “skip”)
• --item <spec> — Item to promote as TYPE:name (repeatable, for SELECTIVE promotions) (repeatable)

# Full promotion
kelta promote create --source env_123 --target env_456
# Promote two collections, overwriting existing ones
kelta promote create --source env_123 --target env_456 --type SELECTIVE --item collection:orders --item collection:invoices --conflict overwrite

kelta promote preview#

Preview the changes a promotion from a source environment would make

• -s, --source <envId> — Source environment id

kelta promote preview --source env_123

kelta promote approve <id>#

Approve a promotion (a promotion cannot be approved by its creator)

kelta promote approve prm_123

kelta promote execute <id>#

Execute a promotion (with —wait, poll until COMPLETED or FAILED) (destructive — needs —yes off-TTY)

• --wait — Poll until the promotion reaches COMPLETED or FAILED

# Execute and wait for COMPLETED or FAILED
kelta promote execute prm_123 --wait --yes

kelta promote status <id>#

Show a promotion and its item counts

kelta promote status prm_123

kelta promote rollback <id>#

Roll back an executed promotion (destructive — needs —yes off-TTY)

kelta promote rollback prm_123 --yes

sdk#

kelta sdk types#

Generate TypeScript types from this tenant’s live OpenAPI document

• -o, --out <file> — Output file (default: kelta-types.ts)

kelta sdk types --out src/kelta-types.ts

(top level)#

kelta manifest#

Print the machine-readable command catalog (JSON Schema per command)

• --group <group> — Only commands of one group

# Every command with its JSON Schema
kelta manifest
# Only the records commands
kelta manifest --group records

kelta version#

Show detailed build information

kelta version --output json

kelta update#

Self-update from the cluster downloads service (—check only reports)

• --check — Report whether an update exists without installing

# Report whether a newer version exists
kelta update --check
kelta update

kelta api <method> <path>#

Raw API escape hatch: profile auth + tenant prefix applied, response verbatim (destructive — needs —yes off-TTY)

• --data <json> — Request body as JSON, @file, or - (any JSON value)
• --header <h> — Extra header as Name:value (repeatable) (repeatable)

kelta api GET '/api/customers?page[size]=5'
# Update a record with a raw JSON:API body
kelta api PATCH /api/customers/rec_123 --data '{"data":{"type":"customers","id":"rec_123","attributes":{"status":"active"}}}' --yes

kelta docs [topic]#

Print a reference doc (the agent guide or an authoring topic), or list every topic

# List every doc topic
kelta docs list
# Same as `kelta docs list`
kelta docs
# Print the agent guide
kelta docs agent

mcp#

kelta mcp serve#

Run a stdio MCP server: hosted kelta-mcp tools bridged + cli_ local tools

• --toolset <set> — user|admin|all (default: “all”)
• --source <source> — auto|remote|local (default: “auto”)
• --mcp-url <url> — Hosted MCP base URL (default: the profile’s API origin)
• --tenant <slug> — Serve this tenant (e.g. a sandbox) instead of the profile’s; needs its token
• --token-env <var> — Env var holding the —tenant token (keeps it out of argv and client config)
• --enable-api-tool — Expose the raw cli_api escape hatch (off by default)

# Serve all toolsets for the current profile
kelta mcp serve
# Serve the user toolset for a sandbox tenant
kelta mcp serve --toolset user --tenant acme-staging --token-env KELTA_STAGING_TOKEN

kelta mcp install <client>#

Print MCP client configuration for this profile (stdio bridge by default)

• --toolset <set> — user|admin|all (default: “all”)
• --direct — Hosted HTTP config instead of the stdio bridge
• --tenant <slug> — Bridge this tenant (e.g. a sandbox) instead of the profile’s
• --token-env <var> — Env var the launched server reads the —tenant token from (required with —tenant)

kelta mcp install claude-code
# Bridge a sandbox tenant with the admin toolset
kelta mcp install cursor --toolset admin --tenant acme-staging --token-env KELTA_STAGING_TOKEN