From 3ff4df5c6ef7ac0b0d7254757d3626d5bdc5f022 Mon Sep 17 00:00:00 2001 From: jochen Date: Sun, 22 Nov 2026 20:44:24 +0100 Subject: [PATCH] mesh-cli: nox licence is the licences' overview; the controller's leftovers go The operator typed `nox licence` and got the retired controller's refusal instead of the licences. `nox licence` and `nox licence list` now call the licence manager's licences and bindings and print one table of each, every time local (1126/AC1); `nox licence usage []` prints the usage readings as a table (1126/AC2). `--json` prints the raw answer on every rendered line, `nox nodes` included: one behaviour for one flag; for the two calls one object {licences, bindings} (1126/AC3). In the same change, the operator (2026-11-22 20:41): "why are there still references to the controller?". Every retired controller line nox answered with "this was the controller's" (its `instead` lines and the `unowned` map) is deleted with its text: none has a seat verb of the same job; a retired line now answers "is not a command" with exit 2, and nothing nox prints names the controller (1126/AC4). The comments, help and README no longer name the controller or issue 1126. Builds: issue 1126 note 151, answers 1-5, and the note after it (acceptance 1126/AC1..AC4, the operator's 20:41 line); one-question-one-tool; principle 4, a module is steered by its tools. --- modules/mesh-cli/README.md | 28 +-- modules/mesh-cli/cmd/mesh-cli/commands.go | 58 +++--- modules/mesh-cli/cmd/mesh-cli/console.go | 5 +- modules/mesh-cli/cmd/mesh-cli/enrol.go | 2 +- modules/mesh-cli/cmd/mesh-cli/licence.go | 176 ++++++++++++++++++ modules/mesh-cli/cmd/mesh-cli/main.go | 84 ++++++--- modules/mesh-cli/cmd/mesh-cli/main_test.go | 147 +++++++++++---- .../mesh-cli/cmd/mesh-cli/manifest_test.go | 6 +- 8 files changed, 390 insertions(+), 116 deletions(-) create mode 100644 modules/mesh-cli/cmd/mesh-cli/licence.go diff --git a/modules/mesh-cli/README.md b/modules/mesh-cli/README.md index 1835cf7e2..ef4e1eac0 100644 --- a/modules/mesh-cli/README.md +++ b/modules/mesh-cli/README.md @@ -35,21 +35,24 @@ puts the call on the bus, as every agent session on the machine does. The consol - **Who judges.** The seat that owns the job: a change of assignments is a proposal the operator approves (`mesh-module-assigner.propose`), a config value is set with its why (`mesh-config.config`), a silence or a hand act is - recorded as one. Until novox/hq issue 1126 the controller ran these lines and judged the account (ADR 0272); with - the controller unassigned, that judgement went with it. -- **The map.** Every line the controller ran, and the seat verb or tool that does its job now, or none, is - `commands.go`'s table (and hq's `.work/1126/nox-map.md` while issue 1126 runs). A line no seat or module owns says - that it was the controller's, that the controller is unassigned, and what to use instead, and exits 1 having called - nothing. A line nox cannot read says how it is written and exits 2. + recorded as one. +- **The map.** Every line nox takes, and the seat verb or tool that does its job, is `commands.go`'s table. A line + nox does not know, or cannot read, says so and how lines are found or written, and exits 2 having called nothing. - **Any address.** `nox call
[json]` calls any seat verb or tool; `nox search ` and `nox describe
` find one and its arguments. -- **What is printed.** The owner's answer as the console gave it (JSON), on standard output with exit 0; an answer the +- **What is printed.** The owner's answer as the console gave it (JSON), or the line's table (`nox nodes`, + `nox licence`, `nox licence usage`; `--json` prints the answer raw), on standard output with exit 0; an answer the console marks an error (a refusal, nothing serving, no answer within its bound) on standard error with exit 1. A console that does not answer is said as nothing having been called; no answer in time is said as a call that may have run. - **`nox status`** is the delivery view's (`mesh-delivery-view.view_status`). When the view does not answer, nox says so first, shows the open conditions and the deliveries under their own addresses, and exits 1: they are never passed off as the status. +- **`nox licence`** (and `nox licence list`) is the operator's overview of the licences in one line + (one-question-one-tool): the licence manager's `licences` as one table (licence, kind, bound nodes, weekly, session + and sonnet usage with their resets, the token's expiry, failures, conditions, whether it is the target), then its + `bindings` (node, licence, since, why), every time local; with `--json` the two answers as one object + `{licences, bindings}`. `nox licence usage []` is the manager's `usage` readings as a table. - **`nox enrol open --key `** runs here and asks nothing of the mesh (ADR 0587 §8). A process that runs for a verb (it carries `MESH_VERB`) is refused before anything is called: a verb is never the @@ -57,15 +60,16 @@ operator. ## What it does not do yet -- **No formatting beyond `nox nodes`.** Answers are the owners' JSON. -- **Lines with no owner.** Accepting a secret from a person, making or setting the operator key, opening a sealed - secret locally, registering a module from another repository and forgetting a module have no seat verb yet; nox - names what to use meanwhile. +- **No formatting beyond `nox nodes` and the licence lines.** Answers are the owners' JSON. +- **No line without a seat verb.** Accepting a secret from a person, making or setting the operator key, opening a + sealed secret locally, registering a module from another repository and forgetting a module have no seat verb yet, + so nox has no line for them. ## Tests `go test ./...`: every owned line calls its owner's address with the arguments it reads, against a stand-in console -answering MCP `tools/call` as node-tools does; a line with no owner or not read calls nothing and says why; an error +answering MCP `tools/call` as node-tools does; a line not known or not read calls nothing and says why; the licence +lines print their tables from the manager's answers; an error answer, a silent console and a verb's process are said; the status's fallback is labelled and exits 1; the console's address is found; `enrol open` opens a sealed token locally; the module places the program and the console's address and nothing else. diff --git a/modules/mesh-cli/cmd/mesh-cli/commands.go b/modules/mesh-cli/cmd/mesh-cli/commands.go index d28149b3a..84e42eb8d 100644 --- a/modules/mesh-cli/cmd/mesh-cli/commands.go +++ b/modules/mesh-cli/cmd/mesh-cli/commands.go @@ -1,8 +1,7 @@ package main -// Every command line nox takes, and the seat verb or module tool that owns its job now that the controller is -// unassigned (novox/hq issue 1126; the map is hq's .work/1126/nox-map.md). A line no seat or module owns says so and -// names what to use instead: it never fails silently, and it never pretends to have run. +// Every command line nox takes, and the seat verb or module tool that owns its job. A line nox does not know says so +// and calls nothing: it never fails silently, and it never pretends to have run. import ( "encoding/json" @@ -93,18 +92,25 @@ type command struct { words []string usage string does string - // build reads the line and answers the call; nil for a line no seat owns. + // build reads the line and answers the call. build func(l line) (call, error) // allowed are the flags the line reads; any other is refused before anything is called. allowed []string - // instead says, for a line with no owner, what to use; empty for one that is owned. - instead string - // render shapes a successful answer for reading; nil prints it as the console gave it. + // render shapes a successful answer for reading; nil prints it as the console gave it. With --json the answer is + // printed raw. render func(text string) string + // also is a second call the line makes after the first, its answer read beside the first's; nil for a line of one + // call. + also *second } -// gone is the reason every unowned line gives. -const gone = "this was the controller's, and the controller is unassigned (novox/hq issue 1126). Nothing was called" +// second is a line's second call: its address, asked with no arguments, the keys the two raw answers are printed +// under with --json, and the render that reads both answers. +type second struct { + address string + keys [2]string + render func(first, second string) string +} // commands is every line, longest words first within a word. var commands = []command{ @@ -120,8 +126,6 @@ var commands = []command{ {words: []string{"node", "public-domain"}, usage: " [ | --clear] [--why ]", does: "the domain a node composes its routed names under; with a domain or --clear, proposed to assignments", allowed: []string{"clear", "why"}, build: publicDomain}, - {words: []string{"node", "add"}, instead: "a new machine joins through the seat mesh-node-enroller: nox enrol issue --why "}, - {words: []string{"node", "networks"}, instead: "no seat keeps a node's routed networks yet; mesh-module-assigner.assignments shows what a node decides"}, {words: []string{"plan"}, usage: "", does: "what the assigner wants the node to run", build: optNode("mesh-delivery-view.assigner_wants")}, {words: []string{"haves"}, usage: "[]", does: "what each node runs, as its node-engine said", build: optNode("mesh-delivery-view.node_haves")}, {words: []string{"switch"}, does: "what each node runs, as its node-engine said", build: fixed("mesh-delivery-view.node_haves")}, @@ -135,7 +139,6 @@ var commands = []command{ {words: []string{"seats"}, does: "who holds each seat, and where", build: func(line) (call, error) { return call{"mesh-module-assigner.assignments", map[string]any{"seats": "true"}}, nil }}, - {words: []string{"seat"}, instead: "a seat is held by placing its module: nox assign --why (mesh-module-assigner.propose)"}, {words: []string{"assign"}, usage: " ... --why ", does: "propose placing modules on a node", allowed: []string{"why"}, build: placeModules("place")}, {words: []string{"unassign"}, usage: " ... --why ", does: "propose taking modules off a node", @@ -157,7 +160,6 @@ var commands = []command{ }}, {words: []string{"proposals"}, usage: "[]", does: "the open proposals of assignments", build: optArg("mesh-module-assigner.proposals", "id")}, {words: []string{"overlay", "show"}, does: "every node's assignments, with its tunnel", build: fixed("mesh-module-assigner.assignments")}, - {words: []string{"overlay"}, instead: "a node's tunnel is a decided field of its assignments: mesh-module-assigner.propose with op decide"}, // Deliveries and builds. {words: []string{"deliveries"}, usage: "[--state s] [--repository owner/repo] [--group g] [--all]", @@ -291,11 +293,7 @@ var commands = []command{ c, err := fixed("mesh-vault.secret_vault_export")(l) return warranted(c, "the vault's sealed copies"), err }}, - {words: []string{"secret", "accept"}, instead: "mesh-vault.accept takes a value from the controller alone, and no seat takes one from a person yet; a module's own secret is asked at a desk (mesh-vault.secret-ask)"}, - {words: []string{"secret", "recover"}, instead: "opening a sealed copy locally is not built yet (beside nox enrol open); nox secret export gives the sealed copies"}, - {words: []string{"secret"}, instead: "nox secret export; mesh-vault.rotate makes one anew"}, {words: []string{"operator", "key", "show"}, does: "what needs a person's eye in the vault, the operator key among it", build: fixed("mesh-vault.vault_status")}, - {words: []string{"operator"}, instead: "no seat sets or makes the operator key yet; nox operator key show reads it (mesh-vault.vault_status)"}, {words: []string{"rotate"}, usage: "[--node n --module m --name s | --provider n --provision p] --why ", does: "make a secret anew", allowed: []string{"node", "module", "name", "provider", "provision", "consumer", "consumer_module", "why"}, build: func(l line) (call, error) { @@ -353,7 +351,13 @@ var commands = []command{ }}, {words: []string{"images"}, usage: "", does: "every container image a machine's wants and haves name", build: needArg("mesh-artifact-sweep.images", "node")}, {words: []string{"mirrors"}, does: "the bases the mesh copied into its store", build: fixed("mesh-artifact-sweep.mirrors")}, - {words: []string{"licence", "list"}, does: "every licence the manager holds", build: fixed("anthropic-licence-manager.licences")}, + // The operator's overview of the licences, in one line (one-question-one-tool). + {words: []string{"licence"}, does: "every licence: kind, bound nodes, usage and its resets, token expiry, failures, conditions, target; then the bindings", + build: fixed("anthropic-licence-manager.licences"), also: licenceBindings}, + {words: []string{"licence", "list"}, does: "every licence: kind, bound nodes, usage and its resets, token expiry, failures, conditions, target; then the bindings", + build: fixed("anthropic-licence-manager.licences"), also: licenceBindings}, + {words: []string{"licence", "usage"}, usage: "[]", does: "the usage readings, the latest first, of every licence or one", + build: optArg("anthropic-licence-manager.usage", "licence"), render: renderUsage}, {words: []string{"licence", "use"}, usage: " ", does: "move a node's agent to another licence", build: func(l line) (call, error) { if len(l.pos) != 2 { @@ -363,7 +367,6 @@ var commands = []command{ }}, {words: []string{"licence", "refresh"}, usage: "[]", does: "refresh a licence now, or every due one", build: optArg("anthropic-licence-manager.refresh", "licence")}, {words: []string{"licence", "key"}, does: "the manager's public key", build: fixed("anthropic-licence-manager.public-key")}, - {words: []string{"licence"}, instead: "anthropic-licence-manager.adopt takes an API key from a file on the manager's node; nox licence list|use|refresh|key"}, {words: []string{"module", "list"}, does: "every module the indexer holds", build: fixed("mesh-delivery-view.indexer_modules")}, {words: []string{"module", "show"}, usage: "", does: "what the indexer holds of one module", build: needArg("mesh-delivery-view.indexer_module", "module")}, {words: []string{"head", "take"}, usage: " --why ", does: "take a held head in by hand (design 47 H §742, H-A-105)", allowed: []string{"why"}, @@ -374,8 +377,6 @@ var commands = []command{ return call{"mesh-delivery-gate.gate_head_take", map[string]any{"repository": l.pos[0], "branch": l.pos[1], "why": l.flags["why"]}}, nil }}, {words: []string{"head", "list"}, does: "every untaken head the gate holds", build: fixed("mesh-delivery-gate.gate_heads")}, - {words: []string{"module"}, instead: "the indexer takes modules in from their repositories; nox module list|show, nox head take for a held head, and nothing forgets one by hand yet"}, - {words: []string{"register"}, instead: "no seat registers a module from another repository yet (novox/hq ADR 0501 §4); nox head take takes a held head in"}, {words: []string{"account", "issue"}, usage: "", does: "mint one bus account the grants part wants, now", build: needArg("mesh-vault.issue-account", "user")}, // Issues and records. @@ -479,21 +480,6 @@ var commands = []command{ }}, } -// unowned are the controller's own lines that no seat or module took over, and what to use where there is anything. -var unowned = map[string]string{ - "migrate": "", "prepare": "", "serve": "", "declare": "", "broker": "", "board": "", "api": "", "facts": "", - "rehearse": "", "take": "", "converge": "", "adopt": "", "move-placement": "", "move-config": "", "durations": "", - "data": "each machine's backups: nox call /node-backup.backed-up", - "forget-checks": "nox checks ", "queue": "nox builds; nox stuck", "cancel": "nox deliveries", - "clear": "nox deliveries", "kill": "nox deliveries", "replay": "nox dead-letters", - "pause": "nox call /node-build-go.pause (or node-build-node, node-build-image)", - "resume": "nox call /node-build-go.resume (or node-build-node, node-build-image)", - "push": "a merge is delivered by mesh-delivery: nox deliveries; one version on one machine is mesh-delivery-assigner.assigner_put", - "deliver": "nox deliveries", "plans": "nox deliveries", "delivery-stop": "nox stalled", - "delivery-backups-again": "nox deliveries", "delivery-walks": "nox deliveries", "delivery-order": "nox deliveries", - "rollout": "nox upgrade ; delivery is mesh-delivery's: nox deliveries", -} - // find answers the command whose words begin the line, the longest first, and what follows them. func find(args []string) (*command, []string) { var best *command diff --git a/modules/mesh-cli/cmd/mesh-cli/console.go b/modules/mesh-cli/cmd/mesh-cli/console.go index a952784b8..f24819337 100644 --- a/modules/mesh-cli/cmd/mesh-cli/console.go +++ b/modules/mesh-cli/cmd/mesh-cli/console.go @@ -1,8 +1,7 @@ package main -// How mesh-cli reaches the mesh now that the controller is unassigned (novox/hq issue 1126): through this machine's -// console, the mesh MCP server the module node-tools serves on loopback (provision mcp-endpoint, ADR 0152: the -// machine's login is the authority). mesh-cli calls `mesh_call` with a seat verb's or a module tool's address, and the +// How mesh-cli reaches the mesh: through this machine's console, the mesh MCP server the module node-tools serves on +// loopback (provision mcp-endpoint, ADR 0152: the machine's login is the authority). mesh-cli calls `mesh_call` with a seat verb's or a module tool's address, and the // console puts the call on the bus, the way every agent session on the machine does. mesh-cli holds no credential and // keeps no bus account of its own. diff --git a/modules/mesh-cli/cmd/mesh-cli/enrol.go b/modules/mesh-cli/cmd/mesh-cli/enrol.go index b04e59a25..13d52cf4f 100644 --- a/modules/mesh-cli/cmd/mesh-cli/enrol.go +++ b/modules/mesh-cli/cmd/mesh-cli/enrol.go @@ -4,7 +4,7 @@ package main // // The seat mesh-node-enroller's `tokens` answers the token sealed to the operator key, which only the operator's private key // opens; the mesh never holds it. This subcommand is local: it asks nothing of the node-engine's socket and nothing of -// the controller or the bus. It reads the sealed token (the base64 of the sealed box) on standard input and the private +// the bus. It reads the sealed token (the base64 of the sealed box) on standard input and the private // key from a file (`--key`, the raw X25519 key in base64 that `operator key make` wrote), opens the box, and prints the // token text a joining machine's `enrol` takes. The key is read from the file named and nowhere else, and never printed. diff --git a/modules/mesh-cli/cmd/mesh-cli/licence.go b/modules/mesh-cli/cmd/mesh-cli/licence.go new file mode 100644 index 000000000..2ca125bd6 --- /dev/null +++ b/modules/mesh-cli/cmd/mesh-cli/licence.go @@ -0,0 +1,176 @@ +package main + +// The operator's overview of the licences in one line (one-question-one-tool): the licence manager's licences and +// bindings as two tables, and its usage readings as one; every time is local. + +import ( + "encoding/json" + "fmt" + "strings" + "text/tabwriter" + "time" +) + +// licenceBindings is the second call of `nox licence`: which licence each node is bound to, since when and why. +var licenceBindings = &second{address: "anthropic-licence-manager.bindings", keys: [2]string{"licences", "bindings"}, + render: renderLicences} + +// splitAnswer is the console's answer as its first JSON value and what the console said after it ("answered by ace"). +func splitAnswer(text string) (json.RawMessage, string) { + dec := json.NewDecoder(strings.NewReader(text)) + var v json.RawMessage + if err := dec.Decode(&v); err != nil { + return nil, text + } + return v, strings.TrimSpace(text[dec.InputOffset():]) +} + +// localTime is an RFC 3339 time in this machine's zone, to the minute; "-" for none, and the text itself when it is +// not one. +func localTime(s string) string { + if s == "" { + return "-" + } + t, err := time.Parse(time.RFC3339Nano, s) + if err != nil { + return s + } + return t.Local().Format("2006-01-02 15:04") +} + +// percent is a reading with its reset when it has one; "-" for a reading the vendor did not give. +func percent(pct *float64, resets string) string { + if pct == nil { + return "-" + } + if resets == "" { + return fmt.Sprintf("%g %%", *pct) + } + return fmt.Sprintf("%g %% (resets %s)", *pct, localTime(resets)) +} + +func dashed(s string) string { + if s == "" { + return "-" + } + return s +} + +// conditionNames are a licence's open conditions as their keys; a condition that is not a key is said as given. +func conditionNames(cs []json.RawMessage) string { + names := make([]string, 0, len(cs)) + for _, c := range cs { + var s string + if json.Unmarshal(c, &s) == nil { + names = append(names, s) + continue + } + var o struct { + Key string `json:"key"` + } + if json.Unmarshal(c, &o) == nil && o.Key != "" { + names = append(names, o.Key) + continue + } + names = append(names, string(c)) + } + return dashed(strings.Join(names, " ")) +} + +// renderLicences is the licences as one table, then the bindings as another; an answer it cannot read is printed as +// given. +func renderLicences(licences, bindings string) string { + var ls []struct { + Name string `json:"name"` + Kind string `json:"kind"` + Bound []string `json:"bound"` + Usage struct { + WeeklyPct *float64 `json:"weeklyPct"` + WeeklyResetsAt string `json:"weeklyResetsAt"` + SessionPct *float64 `json:"sessionPct"` + SessionResetsAt string `json:"sessionResetsAt"` + SonnetPct *float64 `json:"sonnetPct"` + } `json:"usage"` + AccessExpiresAt string `json:"accessExpiresAt"` + Failures int `json:"failures"` + Conditions []json.RawMessage `json:"conditions"` + Target bool `json:"target"` + } + var bs []struct { + Consumer string `json:"consumer"` + Licence string `json:"licence"` + Since string `json:"since"` + Why string `json:"why"` + } + lv, lafter := splitAnswer(licences) + bv, bafter := splitAnswer(bindings) + if lv == nil || json.Unmarshal(lv, &ls) != nil || bv == nil || json.Unmarshal(bv, &bs) != nil { + return licences + "\n" + bindings + } + var b strings.Builder + w := tabwriter.NewWriter(&b, 0, 0, 2, ' ', 0) + fmt.Fprintln(w, "LICENCE\tKIND\tBOUND\tWEEKLY\tSESSION\tSONNET\tTOKEN EXPIRES\tFAILURES\tCONDITIONS\tTARGET") + for _, l := range ls { + target := "no" + if l.Target { + target = "yes" + } + fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%d\t%s\t%s\n", l.Name, dashed(l.Kind), dashed(strings.Join(l.Bound, " ")), + percent(l.Usage.WeeklyPct, l.Usage.WeeklyResetsAt), percent(l.Usage.SessionPct, l.Usage.SessionResetsAt), + percent(l.Usage.SonnetPct, ""), localTime(l.AccessExpiresAt), l.Failures, conditionNames(l.Conditions), target) + } + w.Flush() + b.WriteString("\n") + w = tabwriter.NewWriter(&b, 0, 0, 2, ' ', 0) + fmt.Fprintln(w, "NODE\tLICENCE\tSINCE\tWHY") + for _, x := range bs { + fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", x.Consumer, x.Licence, localTime(x.Since), dashed(x.Why)) + } + w.Flush() + // Which machine answered each call, said once when both say the same. + for i, a := range []string{lafter, bafter} { + if a != "" && (i == 0 || a != lafter) { + b.WriteString(a + "\n") + } + } + return b.String() +} + +// renderUsage is the usage readings as one table, the latest first as the manager answers them; an answer it cannot +// read is printed as given. +func renderUsage(text string) string { + var rs []struct { + At int64 `json:"at"` + Licence string `json:"licence"` + Reading struct { + WeeklyPct *float64 `json:"weeklyPct"` + WeeklyResetsAt string `json:"weeklyResetsAt"` + SessionPct *float64 `json:"sessionPct"` + SessionResetsAt string `json:"sessionResetsAt"` + SonnetResetsAt string `json:"sonnetResetsAt"` + } `json:"reading"` + } + v, after := splitAnswer(text) + if v == nil || json.Unmarshal(v, &rs) != nil { + return text + } + var b strings.Builder + w := tabwriter.NewWriter(&b, 0, 0, 2, ' ', 0) + fmt.Fprintln(w, "LICENCE\tREAD AT\tWEEKLY\tSESSION\tRESETS") + for _, r := range rs { + var resets []string + for _, x := range [][2]string{{"weekly", r.Reading.WeeklyResetsAt}, {"session", r.Reading.SessionResetsAt}, + {"sonnet", r.Reading.SonnetResetsAt}} { + if x[1] != "" { + resets = append(resets, x[0]+" "+localTime(x[1])) + } + } + fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", r.Licence, time.UnixMilli(r.At).Local().Format("2006-01-02 15:04"), + percent(r.Reading.WeeklyPct, ""), percent(r.Reading.SessionPct, ""), dashed(strings.Join(resets, ", "))) + } + w.Flush() + if after != "" { + b.WriteString(after + "\n") + } + return b.String() +} diff --git a/modules/mesh-cli/cmd/mesh-cli/main.go b/modules/mesh-cli/cmd/mesh-cli/main.go index e48c3db5f..34e78cc31 100644 --- a/modules/mesh-cli/cmd/mesh-cli/main.go +++ b/modules/mesh-cli/cmd/mesh-cli/main.go @@ -1,8 +1,8 @@ // Command mesh-cli is the operator's command on every node: `mesh-cli `, in interactive zsh also `nox`. // -// Each line calls the seat verb or the module tool that owns its job (novox/hq issue 1126: the controller that ran -// these lines before is unassigned), through this machine's console, the mesh MCP server on loopback (console.go). -// A line no seat or module owns says so and names what to use instead. `enrol open` runs here and asks nothing. +// Each line calls the seat verb or the module tool that owns its job, through this machine's console, the mesh MCP +// server on loopback (console.go). A line nox does not know says so and calls nothing. `enrol open` runs here and asks +// nothing. package main import ( @@ -75,16 +75,10 @@ func run(ctx context.Context, args []string, stdout, stderr io.Writer) int { } c, rest := find(args) if c == nil { - if instead, ok := unowned[args[0]]; ok { - return noOwner(args[0], instead, stderr) - } fmt.Fprintf(stderr, "mesh-cli: %q is not a command. nox help lists them; nox search finds a seat verb "+ "or a tool, and nox call
calls it\n", args[0]) return 2 } - if c.build == nil { - return noOwner(strings.Join(c.words, " "), c.instead, stderr) - } k, err := c.read(rest) if err != nil { fmt.Fprintf(stderr, "mesh-cli: %v. Nothing was called\n nox %s %s\n", err, strings.Join(c.words, " "), c.usage) @@ -100,7 +94,59 @@ func run(ctx context.Context, args []string, stdout, stderr io.Writer) int { if k.Address == "mesh-delivery-view.view_status" { return status(ctx, stdout, stderr) } - return show(ctx, "mesh_call", map[string]any{"address": k.Address, "arguments": k.Args}, c.render, stdout, stderr) + render := c.render + l, _ := parseLine(rest) + if l.has("json") { + render = nil + } + if c.also != nil { + return showTwo(ctx, k, c.also, !l.has("json"), stdout, stderr) + } + return show(ctx, "mesh_call", map[string]any{"address": k.Address, "arguments": k.Args}, render, stdout, stderr) +} + +// showTwo calls a line's two addresses in turn and prints both answers: through the line's render, or raw as one +// object under the line's two keys. The second is not called when the first fails, and either failing is said with +// exit 1. +func showTwo(ctx context.Context, first call, also *second, rendered bool, stdout, stderr io.Writer) int { + var texts [2]string + for i, k := range []call{first, {also.address, map[string]any{}}} { + a, err := consoleTool(ctx, "mesh_call", map[string]any{"address": k.Address, "arguments": k.Args}) + if err != nil { + return failed(err, stderr) + } + if a.IsError { + fmt.Fprintln(stderr, "mesh-cli: "+k.Address+": "+strings.TrimRight(a.Text, "\n")) + return 1 + } + texts[i] = a.Text + } + if rendered { + fmt.Fprintln(stdout, strings.TrimRight(also.render(texts[0], texts[1]), "\n")) + return 0 + } + whole := map[string]json.RawMessage{} + var after []string + for i, text := range texts { + v, rest := splitAnswer(text) + if v == nil { + fmt.Fprintf(stderr, "mesh-cli: %s answered no JSON: %q\n", []string{first.Address, also.address}[i], text) + return 1 + } + whole[also.keys[i]] = v + if rest != "" && (len(after) == 0 || after[0] != rest) { + after = append(after, rest) + } + } + b, err := json.MarshalIndent(whole, "", " ") + if err != nil { + return failed(err, stderr) + } + fmt.Fprintln(stdout, string(b)) + for _, a := range after { + fmt.Fprintln(stdout, a) + } + return 0 } // recordAct records the hand act a sensitive vault verb is warranted by, through mesh-hand-acts, and answers its id; @@ -127,17 +173,6 @@ func recordAct(ctx context.Context, h handAct, stderr io.Writer) (string, int) { return rec.Act.ID, 0 } -// noOwner says a line has no owner since the controller went, and what to use. -func noOwner(what, instead string, stderr io.Writer) int { - fmt.Fprintf(stderr, "mesh-cli: nox %s: %s.\n", what, gone) - if instead != "" { - fmt.Fprintf(stderr, " instead: %s\n", instead) - } else { - fmt.Fprintln(stderr, " no seat or module does this now; nox search finds what does nearby") - } - return 1 -} - // show calls one of the console's tools and prints what it answered: an answer marked an error on standard error, with // exit 1. func show(ctx context.Context, tool string, args map[string]any, render func(string) string, stdout, stderr io.Writer) int { @@ -218,14 +253,11 @@ func usage() string { b.WriteString(`mesh-cli: the operator's command (nox in interactive zsh) Each line calls the seat verb or module tool that owns the job, through this machine's console (the mesh MCP -server on loopback). The controller that ran these lines before is unassigned (novox/hq issue 1126). +server on loopback). `) lines := make([]string, 0, len(commands)) for _, c := range commands { - if c.build == nil { - continue - } lines = append(lines, fmt.Sprintf(" nox %s %s\n %s", strings.Join(c.words, " "), c.usage, c.does)) } sort.Strings(lines) @@ -239,7 +271,7 @@ server on loopback). The controller that ran these lines before is unassigned (n open an enrolment token sealed to the operator key, here; asks nothing of the mesh nox version -Every answer is the owner's own, as JSON. A line the controller ran that no seat owns says so and what to use. +Every answer is the owner's own, as JSON, or a table where the line says so; --json prints it raw. `) return b.String() } diff --git a/modules/mesh-cli/cmd/mesh-cli/main_test.go b/modules/mesh-cli/cmd/mesh-cli/main_test.go index df8821545..7984172ea 100644 --- a/modules/mesh-cli/cmd/mesh-cli/main_test.go +++ b/modules/mesh-cli/cmd/mesh-cli/main_test.go @@ -77,8 +77,8 @@ func runLine(args ...string) (int, string, string) { return code, out.String(), errOut.String() } -// Every owned line calls the seat verb or module tool that owns its job, with the arguments the owner reads -// (novox/hq issue 1126; hq .work/1126/nox-map.md), and prints its answer. +// Every line calls the seat verb or module tool that owns its job, with the arguments the owner reads, and prints its +// answer. func TestEachLineCallsItsOwner(t *testing.T) { now = func() time.Time { return time.Date(2026, 11, 2, 10, 0, 0, 0, time.UTC) } t.Cleanup(func() { now = time.Now }) @@ -121,14 +121,14 @@ func TestEachLineCallsItsOwner(t *testing.T) { {"settings clear zsh execute --node g14 --why test", "mesh-config.config", `{"action":"clear","key":"execute","module":"zsh","node":"g14","why":"test"}`}, {"config history --key k --limit 5", "mesh-config.config", `{"action":"history","key":"k","limit":5}`}, {"operator key show", "mesh-vault.vault_status", `{}`}, - // A cleanup without --confirm deletes nothing, so no hand act is recorded for it (issue 1126 review 2). + // A cleanup without --confirm deletes nothing, so no hand act is recorded for it. {"cleanup delete ace.plex --why dry", "mesh-vault.provisioner_delete", `{"consumer":"ace.plex","why":"dry"}`}, {"collect --confirm --why space", "mesh-artifact-sweep.collect", `{"confirm":"true","why":"space"}`}, {"images ace", "mesh-artifact-sweep.images", `{"node":"ace"}`}, {"licence use g14 work", "anthropic-licence-manager.switch", `{"consumer":"g14","licence":"work"}`}, {"module show plex", "mesh-delivery-view.indexer_module", `{"module":"plex"}`}, {"issues apostrophe bug --status open --limit 5", "issue-tracker.list", `{"limit":5,"search":"apostrophe bug","status":"open"}`}, - {"issue 1126 --brief", "issue-tracker.get", `{"brief":true,"number":1126}`}, + {"issue 294 --brief", "issue-tracker.get", `{"brief":true,"number":294}`}, {"kb ask what holds about the merge window", "knowledge-base.ask", `{"question":"what holds about the merge window"}`}, {"kb get 587 --reasoning", "knowledge-base.get", `{"number":587,"reasoning":true}`}, {"progress 47", "knowledge-base.progress", `{"of":"design 47"}`}, @@ -154,42 +154,43 @@ func TestEachLineCallsItsOwner(t *testing.T) { } } -// A line the controller ran that no seat owns says so and what to use, exits 1 and calls nothing; a line nox cannot -// read says how it is written, exits 2 and calls nothing. -func TestALineWithNoOwnerOrNotReadCallsNothingAndSaysWhy(t *testing.T) { +// 1126/AC4: a line nox cannot read says how it is written, exits 2 and calls nothing; the controller's retired lines are gone with +// it, not mapped to a refusal (the operator, 2026-11-22: "why are there still references to the controller?"), and +// nothing nox says names the controller. +func TestALineNotReadCallsNothingAndSaysWhy(t *testing.T) { for _, c := range []struct { line string - code int err string }{ - {"push ace", 1, "mesh-delivery-assigner.assigner_put"}, - {"migrate", 1, "no seat or module does this now"}, - {"secret accept ace plex token", 1, "mesh-vault.secret-ask"}, - {"node add new1", 1, "nox enrol issue"}, - {"pause", 1, "node-build-go.pause"}, - {"operator key make", 1, "operator key show"}, - {"assign ace plex", 2, "needs --why"}, - {"issue twelve", 2, "not an issue's number"}, - {"conditions --bogus x", 2, "--bogus is not a flag"}, - {"settings set zsh {\"execute\":\"withhold\"} --node g14 --why x", 2, "set each key"}, - {"healers --days soon", 2, "takes a number"}, - {"config propose --pull novox/x#1", 2, "--pull is not a flag"}, - {"frobnicate", 2, "is not a command"}, + {"push ace", "is not a command"}, + {"migrate", "is not a command"}, + {"secret accept ace plex token", "is not a command"}, + {"node add new1", "is not a command"}, + {"pause", "is not a command"}, + {"operator key make", "is not a command"}, + {"module forget plex", "is not a command"}, + {"assign ace plex", "needs --why"}, + {"issue twelve", "not an issue's number"}, + {"conditions --bogus x", "--bogus is not a flag"}, + {"settings set zsh {\"execute\":\"withhold\"} --node g14 --why x", "set each key"}, + {"healers --days soon", "takes a number"}, + {"config propose --pull novox/x#1", "--pull is not a flag"}, + {"frobnicate", "is not a command"}, // The checker and the groups go whole (design 47 H §764): nox calls neither. - {"try novox/mesh-catalog abc123 --level unit", 2, "is not a command"}, - {"groups", 2, "is not a command"}, - {"checks novox/mesh-catalog --number 591", 2, "is not a command"}, + {"try novox/mesh-catalog abc123 --level unit", "is not a command"}, + {"groups", "is not a command"}, + {"checks novox/mesh-catalog --number 591", "is not a command"}, } { got := console(t, nil) args := strings.Fields(c.line) code, _, errOut := runLine(args...) - if code != c.code || len(*got) != 0 || !strings.Contains(errOut, c.err) { - t.Errorf("nox %s: exit %d, asked %+v, stderr %q; want exit %d saying %q", c.line, code, *got, errOut, c.code, c.err) - } - if c.code == 1 && !strings.Contains(errOut, "issue 1126") { - t.Errorf("nox %s does not say the controller is unassigned: %q", c.line, errOut) + if code != 2 || len(*got) != 0 || !strings.Contains(errOut, c.err) || strings.Contains(errOut, "controller") { + t.Errorf("nox %s: exit %d, asked %+v, stderr %q; want exit 2 saying %q", c.line, code, *got, errOut, c.err) } } + if strings.Contains(usage(), "controller") { + t.Errorf("the help still names the controller:\n%s", usage()) + } } // What the console says is printed as said: an answer it marks an error on standard error with exit 1, a console that @@ -279,16 +280,13 @@ func TestEveryLineIsInTheHelpOnce(t *testing.T) { if c.build != nil && !strings.Contains(help, "nox "+w+" ") { t.Errorf("nox %s is not in the help", w) } - if c.build == nil && c.instead == "" { - t.Errorf("nox %s has neither an owner nor an instead", w) - } - if _, dup := unowned[c.words[0]]; dup && len(c.words) == 1 { - t.Errorf("nox %s is both owned and unowned", w) + if c.build == nil { + t.Errorf("nox %s has no owner", w) } } } -// ADR 0590 §8 (issue 1126 review 1): each sensitive vault verb judges its own caller, and nox reaches the vault as its +// ADR 0590 §8: each sensitive vault verb judges its own caller, and nox reaches the vault as its // machine's runtime, so nox first records the hand act that warrants the line through mesh-hand-acts (the vault verb as // its verb, what it acts on as its what) and names it as `act`; a recording refused calls the vault not at all. func TestASensitiveLineRecordsItsHandActAndNamesIt(t *testing.T) { @@ -322,3 +320,82 @@ func TestASensitiveLineRecordsItsHandActAndNamesIt(t *testing.T) { t.Errorf("a refused recording: exit %d, asked %+v, %q", code, *got, errOut) } } + +// 1126/AC1, 1126/AC2, 1126/AC3: the operator's overview of the licences is one line (one-question-one-tool): `nox licence` and +// `nox licence list` call the licence manager's licences and bindings and print one table of each, every time local; +// `nox licence usage` prints the readings; --json prints the raw answers, the two as one object. +func TestTheLicencesAreOneTable(t *testing.T) { + local := time.Local + time.Local = time.FixedZone("CET", 3600) + t.Cleanup(func() { time.Local = local }) + licences := `[{"name":"work","account":"a@example.org","kind":"subscription","bound":["ace","novox"], + "usage":{"readAt":"2026-11-22T19:32:27Z","weeklyPct":2,"weeklyResetsAt":"2026-11-25T01:59:59.5+00:00", + "sessionPct":7,"sessionResetsAt":"2026-11-23T00:29:59+00:00","sonnetPct":null}, + "accessExpiresAt":"2026-11-23T01:56:57Z","refreshExpiresAt":"2026-12-14T01:48:16Z","room":98, + "failures":0,"conditions":[],"target":true}, + {"name":"home","account":"b@example.org","kind":"subscription","bound":[], + "usage":{"weeklyPct":99,"weeklyResetsAt":"2026-11-25T10:59:59+00:00","sessionPct":null,"sonnetPct":40}, + "accessExpiresAt":"2026-11-23T02:02:57Z","failures":2,"conditions":["licence.home.full"],"target":false}]` + bindings := `[{"consumer":"g14","licence":"home","kind":"subscription","generation":3,"since":"2026-11-22T19:32:28Z", + "why":"work reached 99 % of its weekly window","by":"usage"}]` + usage := `[{"at":1795376250078,"licence":"work","reading":{"weeklyPct":4,"weeklyResetsAt":"2026-11-29T17:59:59+00:00", + "sessionPct":null,"sonnetPct":null}}]` + answers := map[string]string{"anthropic-licence-manager.licences": licences, + "anthropic-licence-manager.bindings": bindings, "anthropic-licence-manager.usage": usage} + for _, words := range []string{"licence", "licence list"} { + got := console(t, answers) + code, out, errOut := runLine(strings.Fields(words)...) + if code != 0 || errOut != "" || len(*got) != 2 || (*got)[0].Address != "anthropic-licence-manager.licences" || + (*got)[1].Address != "anthropic-licence-manager.bindings" || (*got)[1].Args != `{}` { + t.Fatalf("nox %s: exit %d, stderr %q, asked %+v", words, code, errOut, *got) + } + for _, want := range []string{ + "LICENCE", "KIND", "BOUND", "WEEKLY", "SESSION", "SONNET", "TOKEN EXPIRES", "FAILURES", "CONDITIONS", "TARGET", + "work", "ace novox", "2 % (resets 2026-11-25 02:59)", "7 % (resets 2026-11-23 01:29)", "2026-11-23 02:56", "yes", + "home", "99 % (resets 2026-11-25 11:59)", "40 %", "licence.home.full", + "NODE", "SINCE", "WHY", "g14", "2026-11-22 20:32", "work reached 99 % of its weekly window", + } { + if !strings.Contains(out, want) { + t.Errorf("nox %s does not print %q:\n%s", words, want, out) + } + } + if strings.Contains(out, "2026-12-14") || strings.Contains(out, "98") { + t.Errorf("nox %s prints the refresh-token expiry or the room:\n%s", words, out) + } + } + + // 1126/AC3: --json prints the raw answers, the two calls' as one object. + console(t, answers) + code, out, _ := runLine("licence", "--json") + var raw struct { + Licences []map[string]any `json:"licences"` + Bindings []map[string]any `json:"bindings"` + } + if err := json.Unmarshal([]byte(strings.SplitN(out, "\nanswered by", 2)[0]), &raw); code != 0 || err != nil || + len(raw.Licences) != 2 || len(raw.Bindings) != 1 { + t.Errorf("nox licence --json: exit %d, %v:\n%s", code, err, out) + } + + // 1126/AC3: on every rendered line, as on the nodes. + nodes := `{"keys":{"ace":{"assignments":{"decided":{"address":"10.0.0.1"},"modules":[]}}}}` + console(t, map[string]string{"mesh-module-assigner.assignments": nodes}) + if code, out, _ := runLine("nodes", "--json"); code != 0 || !strings.HasPrefix(out, nodes) { + t.Errorf("nox nodes --json: exit %d, does not print the raw answer:\n%s", code, out) + } + + // 1126/AC2: the usage readings as one table. + got := console(t, answers) + code, out, errOut := runLine("licence", "usage", "work") + if code != 0 || len(*got) != 1 || (*got)[0].Address != "anthropic-licence-manager.usage" || (*got)[0].Args != `{"licence":"work"}` { + t.Fatalf("nox licence usage work: exit %d, stderr %q, asked %+v", code, errOut, *got) + } + for _, want := range []string{"LICENCE", "READ AT", "WEEKLY", "SESSION", "RESETS", "work", + time.UnixMilli(1795376250078).Local().Format("2006-01-02 15:04"), "4 %", "weekly 2026-11-29 18:59"} { + if !strings.Contains(out, want) { + t.Errorf("nox licence usage does not print %q:\n%s", want, out) + } + } + if code, _, _ := runLine("licence", "usage", "--limit", "5"); code != 2 { + t.Errorf("nox licence usage --limit is read (exit %d); it takes no limit", code) + } +} diff --git a/modules/mesh-cli/cmd/mesh-cli/manifest_test.go b/modules/mesh-cli/cmd/mesh-cli/manifest_test.go index c411eab7d..9e42e6d51 100644 --- a/modules/mesh-cli/cmd/mesh-cli/manifest_test.go +++ b/modules/mesh-cli/cmd/mesh-cli/manifest_test.go @@ -24,8 +24,8 @@ func TestTheArchivePlacesExactlyOneFileAndTheConsolesAddressOne(t *testing.T) { if err := json.Unmarshal(raw, &m); err != nil { t.Fatal(err) } - // Beside the program, one directory and one file: the console's address, from the mcp-endpoint it requires - // (novox/hq issue 1126). Nothing else. + // Beside the program, one directory and one file: the console's address, from the mcp-endpoint it requires. + // Nothing else. var r map[string]any for _, res := range m.Resources { switch { @@ -43,7 +43,7 @@ func TestTheArchivePlacesExactlyOneFileAndTheConsolesAddressOne(t *testing.T) { if len(m.Resources) != 3 || r == nil || r["path"] != "/usr/local/bin" { t.Fatalf("its resources are %v", m.Resources) } - // The build has a second artifact, the files archive the controller reads the templates back from; it + // The build has a second artifact, the files archive the templates are read back from; it // places no file. The artifact the resource unpacks is the one that does. var a map[string]any for _, candidate := range m.Build.Artifacts { -- 2.54.0