jochen
9ab58e79fb
The holder of the seat the controller seeds under novox/hq ADR 0177. Eight verbs under the seat's name — units, status, start, stop, restart, enable, disable, journal — each taking an optional scope, "system" by default or "user" for the operator account's own manager, reached as `systemctl --user --machine=<account>@` when the runtime is not that account. One tool of its own, systemd_failed, for every failed unit in both scopes. A package, a claim and a bundle; no container, no process: served by the node tools runtime (ADR 0175) once it exists. `module check` passes against a controller that carries the seat; the tools type-check against the SDK.
72 lines
3.7 KiB
TypeScript
72 lines
3.7 KiB
TypeScript
// systemd's tools: the node-service-manager seat's eight verbs — the units on this machine in
|
|
// both scopes, read and acted on by name — and the module's own reading of what has failed
|
|
// (novox/hq ADR 0177). Served by the node tools runtime (ADR 0175); the host applies units, this
|
|
// answers about them.
|
|
import { registerModuleTools, type ToolDefinition } from "@novox/mesh-sdk/tools";
|
|
import { ServiceManager, type Scope } from "../client.js";
|
|
|
|
const scope = { type: "string", description: "\"system\" (the default) or \"user\": the operator account's own manager" };
|
|
const unit = { type: "string", description: "the unit's name, as the service manager knows it" };
|
|
|
|
function scopeOf(args: Readonly<Record<string, unknown>>): Scope {
|
|
const s = String(args.scope ?? "system");
|
|
if (s !== "system" && s !== "user") throw new Error(`scope ${JSON.stringify(s)}: "system" or "user"`);
|
|
return s;
|
|
}
|
|
function unitOf(args: Readonly<Record<string, unknown>>): string {
|
|
const u = String(args.unit ?? "").trim();
|
|
if (!u) throw new Error("a unit is required");
|
|
return u;
|
|
}
|
|
|
|
export function getSeatVerbs(manager: ServiceManager): ToolDefinition[] {
|
|
const act = (verb: "start" | "stop" | "restart" | "enable" | "disable", description: string): ToolDefinition => ({
|
|
name: verb,
|
|
description,
|
|
input: { type: "object", properties: { scope, unit }, required: ["unit"] },
|
|
run: async (args) => manager.act(scopeOf(args), verb, unitOf(args)),
|
|
});
|
|
return [
|
|
{
|
|
name: "units",
|
|
description: "The units the service manager knows in a scope, each with its load, active and sub state; narrowed to a pattern when asked.",
|
|
input: { type: "object", properties: { scope, pattern: { type: "string", description: "a glob the unit's name must match (optional)" } } },
|
|
run: async (args) => ({ scope: scopeOf(args), units: await manager.units(scopeOf(args), args.pattern ? String(args.pattern) : undefined) }),
|
|
},
|
|
{
|
|
name: "status",
|
|
description: "One unit as the service manager sees it now: its states, whether it starts at boot, its main process, and whether the mesh declares it.",
|
|
input: { type: "object", properties: { scope, unit }, required: ["unit"] },
|
|
run: async (args) => manager.status(scopeOf(args), unitOf(args)),
|
|
},
|
|
act("start", "Start one unit. For a unit the mesh declares, the answer says the host will restore what its declaration says at the next apply."),
|
|
act("stop", "Stop one unit; for a mesh-declared unit the answer says the host will restore its declared state."),
|
|
act("restart", "Restart one unit."),
|
|
act("enable", "Make one unit start at boot (or at the account's login, in user scope)."),
|
|
act("disable", "Stop one unit starting at boot (or at login, in user scope)."),
|
|
{
|
|
name: "journal",
|
|
description: "The last lines of one unit's journal.",
|
|
input: { type: "object", properties: { scope, unit, lines: { type: "number", description: "how many lines from the end (default 100)" } }, required: ["unit"] },
|
|
run: async (args) => {
|
|
const n = Number(args.lines ?? 100);
|
|
return manager.journal(scopeOf(args), unitOf(args), Number.isFinite(n) && n > 0 ? Math.min(n, 5000) : 100);
|
|
},
|
|
},
|
|
];
|
|
}
|
|
|
|
export function getOwnTools(manager: ServiceManager): ToolDefinition[] {
|
|
return [
|
|
{
|
|
name: "systemd_failed",
|
|
description: "Every failed unit on this machine, in the system manager and in the operator account's.",
|
|
input: { type: "object", properties: {} },
|
|
run: async () => manager.failed(),
|
|
},
|
|
];
|
|
}
|
|
|
|
registerModuleTools("node-service-manager", (env) => getSeatVerbs(ServiceManager.fromEnv(env)));
|
|
registerModuleTools("systemd", (env) => getOwnTools(ServiceManager.fromEnv(env)));
|