108 lines
3.5 KiB
TypeScript
108 lines
3.5 KiB
TypeScript
// The Portainer API client — portainer's own code, living in the module (novox/hq ADR 0039).
|
|
// portainer is tools-only: its "events" would really be the underlying containers' lifecycle,
|
|
// which the host owns and emits — so this module reads Portainer's own resources (endpoints,
|
|
// stacks, containers) and exposes them, and stops there.
|
|
|
|
import { readFileSync } from "node:fs";
|
|
|
|
export interface PortainerEndpoint {
|
|
id: number;
|
|
name: string;
|
|
type: number;
|
|
url: string;
|
|
status: number;
|
|
}
|
|
|
|
export interface PortainerStack {
|
|
id: number;
|
|
name: string;
|
|
type: number;
|
|
endpointId: number;
|
|
status: number;
|
|
}
|
|
|
|
export interface PortainerContainer {
|
|
id: string;
|
|
names: string[];
|
|
image: string;
|
|
state: string;
|
|
status: string;
|
|
}
|
|
|
|
/** The settings-merged config the mesh delivers (novox/hq ADR 0046): { url, apiKey, token, password, user, ... }. */
|
|
function meshConfig(file?: string): Record<string, string> {
|
|
if (!file) return {};
|
|
try { return JSON.parse(readFileSync(file, "utf8")) as Record<string, string>; }
|
|
catch { return {}; }
|
|
}
|
|
|
|
export class PortainerClient {
|
|
readonly baseUrl: string;
|
|
|
|
constructor(
|
|
url: string,
|
|
private readonly token: string,
|
|
) {
|
|
this.baseUrl = url.replace(/\/+$/, "");
|
|
}
|
|
|
|
/**
|
|
* Build from the module's resolved environment. The URL is MESH_PORTAINER_URL (or the local
|
|
* dashboard port) and the API token is MESH_PORTAINER_TOKEN — an access token minted in
|
|
* Portainer, sent as X-API-Key. Throws when no token is configured, so a misconfigured module
|
|
* exposes nothing rather than calling Portainer unauthenticated.
|
|
*/
|
|
static fromEnv(env: NodeJS.ProcessEnv = process.env): PortainerClient {
|
|
const cfg = meshConfig(env.MESH_PORTAINER_CONFIG_FILE);
|
|
const url = cfg.url ?? env.MESH_PORTAINER_URL ?? `https://127.0.0.1:${env.PORTAINER_PORT ?? "9443"}`;
|
|
const token = cfg.token ?? env.MESH_PORTAINER_TOKEN;
|
|
if (!token) throw new Error("no Portainer token — set MESH_PORTAINER_TOKEN");
|
|
return new PortainerClient(url, token);
|
|
}
|
|
|
|
private async get<T>(path: string): Promise<T> {
|
|
const res = await fetch(`${this.baseUrl}${path}`, { headers: { "X-API-Key": this.token } });
|
|
if (!res.ok) throw new Error(`Portainer ${path}: ${res.status} ${await res.text()}`);
|
|
return res.json() as Promise<T>;
|
|
}
|
|
|
|
/** The environments (endpoints) Portainer manages — each a Docker host or cluster it talks to. */
|
|
async listEndpoints(): Promise<PortainerEndpoint[]> {
|
|
const raw = await this.get<any[]>("/api/endpoints");
|
|
return (raw ?? []).map((e) => ({
|
|
id: e.Id,
|
|
name: e.Name,
|
|
type: e.Type,
|
|
url: e.URL,
|
|
status: e.Status,
|
|
}));
|
|
}
|
|
|
|
/** The stacks (compose/swarm deployments) Portainer knows about. */
|
|
async listStacks(): Promise<PortainerStack[]> {
|
|
const raw = await this.get<any[]>("/api/stacks");
|
|
return (raw ?? []).map((s) => ({
|
|
id: s.Id,
|
|
name: s.Name,
|
|
type: s.Type,
|
|
endpointId: s.EndpointId,
|
|
status: s.Status,
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* The containers on one endpoint, read through Portainer's Docker API proxy. Includes stopped
|
|
* containers, so the caller sees the whole picture rather than only what is running.
|
|
*/
|
|
async listContainers(endpointId: number): Promise<PortainerContainer[]> {
|
|
const raw = await this.get<any[]>(`/api/endpoints/${endpointId}/docker/containers/json?all=1`);
|
|
return (raw ?? []).map((c) => ({
|
|
id: c.Id,
|
|
names: c.Names ?? [],
|
|
image: c.Image,
|
|
state: c.State,
|
|
status: c.Status,
|
|
}));
|
|
}
|
|
}
|