Skip to main content
Glama
Cyan Eclipse License Server

Cyan Eclipse License Server

Official

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
PYTHONPATHYesSet to `src` so that `python3 -m license_server` resolves the package (e.g. `PYTHONPATH=src python3 -m license_server`).

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{}

Tools

Functions exposed to the LLM to take actions

NameDescription
policy_showA

Show this server's identity, policy defaults (heartbeat 4 h, offline window 72 h, seat-reclaim window 30 d, expiry grace 14 d, clock tolerances), the tier floor of every tool, the denylist, the tenant's signing key ids in force, and the tenant's journal head. Use it first, for orientation and discovery; it is the only tool that answers without a valid tenant (an absent or unknown tenant gets the genesis journal head and no key ids). It reports posture, never licence state -- use license_status or license_inspect for a licence. Read-only; changes nothing.

license_verifyA

Verify a signed .cetlic licence artefact string: parse the envelope, check the Ed25519 signature against the issuing tenant's registered public keys, check optional tenant/product expectations, then reconcile with the store (an authentic artefact for an unknown licence reports LICENSE_UNKNOWN; a stored state such as REVOKED overrides the artefact's own validity). Use it when an artefact is in hand; use license_status instead when only a licence id is known. The tenant is resolved from the artefact payload, so caller context is optional. Read-only.

license_statusA

Show the current computed state of one stored licence: LICENSE_VALID, LICENSE_GRACE (inside the 14-day post-expiry grace), LICENSE_EXPIRED, LICENSE_REVOKED, LICENSE_SUPERSEDED, or LICENSE_UNKNOWN when the id is not the tenant's. Returns state plus product, tier, expiry, perpetual flag, and seat count -- the summary view. Use license_inspect for the full record with its journal receipts, and license_verify when an artefact string is in hand. Requires a valid _tenant_id. Read-only.

license_listA

List every licence stored for the caller's tenant, optionally filtered by product_id or by computed state (for example LICENSE_REVOKED). Caller must be a principal of class tenant_owner, issuer, support_reader, or auditor. On the support surface (support_reader) licensee details are masked; other classes see the full record. Use license_inspect for one licence with its receipts; this tool returns the same per-licence view in bulk plus a count and the surface served. Read-only.

license_inspectA

Show one stored licence in full -- terms, licensee, artefact and artefact hash, status history fields -- together with every journal receipt that names it or its predecessor licence. Caller must be a principal of class tenant_owner, issuer, support_reader, or auditor; support_reader sees a masked licensee. An unknown id returns state LICENSE_UNKNOWN rather than an error. Use license_status for the cheap state-only check. Read-only.

revocation_list_getA

Return the tenant's current revocation list: the ids of all revoked licences, optionally filtered to one product, as a body signed with the tenant's current signing key (signature is null when no key store is configured). This is the published artefact offline verifiers and auditors check; under online activation (model B), connected apps instead learn of a revocation at their next check-in, so do not use this as a live status check -- use license_status. Requires a valid _tenant_id. Read-only.

journal_infoA

Show the head of the caller's tenant journal: receipt count, latest sequence number, head hash, and genesis hash. The journal is the tenant's append-only, hash-chained record of every lifecycle operation and refusal. Caller must be a principal of class tenant_owner, issuer, support_reader, or auditor. Use it to anchor or sanity-check the chain; use chain_verify to recompute the whole chain and journal_list / receipt_get to read entries. Read-only.

journal_listA

List the caller's tenant journal receipts in sequence order, paged by limit (default 100) and offset. Each receipt is one hash-chained lifecycle entry (issue, renew, revoke, activation events, refusals of note). Caller must be a principal of class tenant_owner, issuer, support_reader, or auditor. Use receipt_get for a single known sequence and chain_verify when integrity, not content, is the question. Read-only.

receipt_getA

Return a single journal receipt by its sequence number in the caller's tenant journal. Caller must be a principal of class tenant_owner, issuer, support_reader, or auditor. A sequence that does not exist returns receipt null with state LICENSE_UNKNOWN. Use journal_list to browse and chain_verify to validate the chain the receipt sits in. Read-only.

chain_verifyA

Recompute the caller's tenant journal hash chain end to end and report whether every receipt's sequence and previous-hash link check out. Returns ok, the receipt count, the head hash, and -- on failure -- the sequence it failed at and why (sequence_gap or prev_hash_mismatch). Caller must be a principal of class tenant_owner, issuer, support_reader, or auditor. Use chain_verify_anchored instead when an externally witnessed anchor must be honoured. Read-only.

chain_verify_anchoredA

Verify the caller's tenant journal chain (exactly as chain_verify) and additionally that the chain extends an externally held anchor: the receipt at the anchor sequence must carry the anchor hash, proving history was not rewritten below the anchor. Caller must be a principal of class tenant_owner, issuer, support_reader, or auditor. Use chain_verify when no external anchor exists. Read-only.

seat_usageA

Show the seat picture for one licence: its seat cap, how many activations are live, and every activation on record (install label, status, activated-at, last check-in, stale flag; install ids are truncated off the owner surface). Caller must be a principal of class tenant_owner, issuer, or support_reader. An unknown licence returns state LICENSE_UNKNOWN. Use activation_list to browse activations across licences and activation_inspect for one activation with its receipts. Read-only.

activation_listA

List every activation recorded for the caller's tenant, optionally filtered by license_id or by status (live, deactivated, reclaimed). Caller must be a principal of class tenant_owner, issuer, or support_reader; support_reader sees truncated install ids. Returns the activations, a count, and the surface served. Use seat_usage for the per-licence cap-versus-live summary. Read-only.

activation_inspectA

Show one activation in full -- install, status, timestamps, stale flag, artefact hash -- plus the journal receipts that name it. Caller must be a principal of class tenant_owner, issuer, or support_reader; support_reader sees a truncated install id. An unknown activation id returns state LICENSE_UNKNOWN rather than an error. Read-only.

license_issue_proposeA

Create a proposal to issue a new licence. A proposal changes nothing by itself: it validates the request (product and tier must exist, seats must be >= 1 and default to the tier's, licensee needs a name and an email, and a term licence needs expires_at or a tier term) and returns a proposal id, its hash, and the confirm-token shape. Caller must be tenant_owner or issuer. Nothing is issued until license_issue executes the proposal with the bound confirm token under a live mandate. Each call creates a fresh proposal.

license_renew_proposeA

Create a proposal to renew an existing licence. Validates that the licence exists (unknown ids fail with LICENSE_UNKNOWN) and that a term licence gets a new expires_at; fields left out (tier, licensee, seats) inherit the current licence's values when license_renew executes. Caller must be tenant_owner or issuer. The proposal alone changes nothing and extends nothing. Each call creates a fresh proposal.

license_revoke_proposeA

Create a proposal to revoke an existing licence, with a reason that will be journalled at execution. Validates that the licence exists (unknown ids fail with LICENSE_UNKNOWN). Caller must be tenant_owner or issuer. The proposal alone revokes nothing: revocation happens only when license_revoke executes it, and connected clients then see the revocation at their next check-in. Each call creates a fresh proposal.

activation_deactivate_proposeA

Create a proposal to deactivate one activation, freeing its seat when executed. The activation must exist -- an unknown id is an error here, unlike the read tools. Caller must be tenant_owner or issuer. The proposal alone frees nothing; activation_deactivate executes it under a mandate. Each call creates a fresh proposal.

license_issueA

Execute an issue proposal and mint the licence: the signed .cetlic artefact is created and the issuance is written to the tenant journal BEFORE the artefact is returned (journal-before-release). Requires the proposal_id and the confirm token bound to its hash, plus a live mandate held by the caller covering the product and the issue operation class. Returns the licence id, the artefact string, its hash, the payload, and the journal receipt. A proposal executes exactly once. This is the only path that creates licences -- there is no unjournalled bulk issue.

license_renewA

Execute a renew proposal: mint a successor licence carrying the renewed terms, linked to the previous licence, which is marked superseded. Requires the proposal_id, the confirm token bound to its hash (confirm-renew-...), and a live mandate covering the product and the renew operation class. Issuance is journalled before the new artefact is returned. Returns the new licence id, artefact, hash, payload, and receipt. A proposal executes exactly once.

license_revokeA

Execute a revoke proposal: journal the revocation (with the proposal's reason) and mark the licence revoked. Requires the proposal_id, the confirm token bound to its hash (confirm-revoke-...), and a live mandate covering the product and the revoke operation class. Revocation is final -- there is no un-revoke and licence deletion does not exist. Connected clients see LICENSE_REVOKED at their next check-in and the licence joins the signed revocation list. Returns the licence id, state LICENSE_REVOKED, and the journal receipt.

license_supersedeA

Execute a renew-kind proposal as a supersede -- or, with transfer true, as a transfer -- minting a successor licence and marking the previous licence superseded. Uses the supersede confirm verb (confirm-supersede-...) even though the proposal kind is renew, and requires a live mandate covering the supersede (or transfer) operation class for the product. Issuance is journalled before the artefact is returned. Returns the new licence id, artefact, hash, payload, and receipt. A proposal executes exactly once.

product_registerA

Register a product in the caller's tenant so tiers can be defined and licences issued for it. Tenant_owner only. The registration is journalled. product_id must be new to the tenant (re-registering an existing id fails). custody records the key-custody model for the product: 'witness' (the default -- the tenant holds its signing keys and the platform stores public keys only) or a custodial election where the deployment supports it. Do this before tier_define for the product.

tier_defineA

Define a tier for a registered product. Tiers are versioned and never edited in place: every call creates the next version (previous max + 1) with its own journal receipt, and returns that version. Tenant_owner only; the product must already be registered (see product_register). Defaults: features [], seats 1, perpetual false, term_days null (a term licence then needs an explicit expires_at at proposal time).

principal_manageA

Administer the tenant's principals and mandates -- the only path that creates either. Tenant_owner only; grants and revocations are journalled. action create_principal registers a principal (principal_id + principal_class: tenant_owner, issuer, support_reader, auditor). action grant_mandate gives a principal a mandate scoped to products and operation classes until expires_at, and returns the mandate_id. action revoke_mandate revokes a mandate by id, effective immediately. There is deliberately no self-service mandate escalation: mandate_self_grant is denylisted and does not exist as a tool.

activation_deactivateA

Execute a deactivate proposal: journal the deactivation and mark the activation deactivated, freeing its seat immediately. Requires the proposal_id, the confirm token bound to its hash (confirm-deactivate-...), and a live mandate covering the product and the deactivate operation class. The affected install sees LICENSE_DEACTIVATED at its next check-in. Returns the activation id, state LICENSE_DEACTIVATED, and the journal receipt. A proposal executes exactly once.

activation_reclaim_staleA

Reclaim seats held by stale activations: every live activation in the tenant whose last check-in is older than the reclaim window (30 days by policy default) is marked reclaimed, with a seat_reclaim journal receipt per slot. Optionally scoped to one product. Caller must be tenant_owner or issuer AND hold a live mandate covering the reclaim operation class. Fresh activations are untouched, and running it again reclaims nothing further. Returns the reclaimed activation ids and their count.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A4.1/5.0

Scored across 27 tools

Disambiguation4/5

The set is unusually well cross-referenced: every read tool explicitly names the sibling to use instead (license_status vs license_inspect vs license_verify vs license_list; seat_usage vs activation_list vs activation_inspect; chain_verify vs chain_verify_anchored), and the propose/execute split is clearly stated. The main residual ambiguity is license_renew vs license_supersede, which operate on the same renew-kind proposal but differ only by confirm verb and operation class — an agent could plausibly pick the wrong executor. revocation_list_get vs license_status is also a subtle boundary (published artifact vs live state), though the description warns about it.

Naming Consistency4/5

A consistent resource_action convention dominates (license_issue, license_revoke, journal_list, receipt_get, activation_inspect, product_register, tier_define), with a coherent _propose suffix marking the two-phase pattern against bare execute verbs. Deviations: revocation_list_get appends an extra noun-plus-'get' that breaks the pattern, and principal_manage is a multi-action tool hiding create/grant/revoke behind one name. Minor but noticeable irregularities.

Tool Count3/5

At 27 tools this is heavy, and the surface could be tightened (license_supersede overlaps license_renew; the journal has five read tools; propose/execute pairs double up four operation types). That said, the domain is genuinely broad — crypto-verified artefacts, two-phase issuance, append-only journal, activations, products/tiers, principals — so most tools do earn their place. It sits on the borderline of justified breadth rather than gratuitous sprawl.

Completeness4/5

Core lifecycle is fully covered: register product, define tier, propose/execute issue, renew, revoke, supersede, verify, list/inspect/status, revocation list, journal read and integrity checks, activation deactivation and stale-seat reclaim, plus principal/mandate admin. Notable gaps: there is no product or tier read tool (product_list/product_inspect, tier_list/tier_get) — after registering products and defining versioned tiers, an agent cannot enumerate or inspect them — and no activation-create path (plausibly client-driven). These are workable gaps but real ones.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues