@kud/incidents-cli 0.0.0-stage → 0.1.0

package/dist/src/core/parse.js

@@ -0,0 +1,118 @@
+import { age } from "./age.js";
+import { SEVERITY } from "./severity.js";
+const tag = (block, name) => block
+    .match(new RegExp(`<${name}>(?:<!\\[CDATA\\[)?([\\s\\S]*?)(?:\\]\\]>)?<\\/${name}>`))?.[1]
+    ?.trim() ?? "";
+export const parseRss = (xml) => [...xml.matchAll(/<item>([\s\S]*?)<\/item>/g)].map(([, block]) => ({
+    title: tag(block, "title"),
+    link: tag(block, "link"),
+    date: tag(block, "pubDate"),
+}));
+const timeOf = (raw) => new Date(raw).getTime();
+export const newestFirst = (items) => [...items].sort((a, b) => {
+    const ta = timeOf(a.date);
+    const tb = timeOf(b.date);
+    if (Number.isNaN(ta) && Number.isNaN(tb))
+        return 0;
+    if (Number.isNaN(ta))
+        return 1;
+    if (Number.isNaN(tb))
+        return -1;
+    return tb - ta;
+});
+export const fromStatuspageSummary = (summary) => ({
+    indicator: (summary?.status?.indicator ?? "unknown"),
+    description: summary?.status?.description ?? "No description",
+    components: (summary?.components ?? [])
+        .filter((c) => !c.group && !/^Visit /i.test(c.name))
+        .map((c) => ({ name: c.name, status: c.status })),
+    active: (summary?.incidents ?? []).map((i) => ({
+        title: i.name,
+        link: i.shortlink ?? "",
+        date: i.started_at ?? i.created_at ?? "",
+        impact: i.impact,
+    })),
+});
+export const fromFeed = (items, { now = Date.now(), windowHours = 6 } = {}) => {
+    const latest = newestFirst(items)[0];
+    if (!latest)
+        return { indicator: "none", description: "No incidents posted" };
+    const since = now - timeOf(latest.date);
+    if (Number.isNaN(since))
+        return { indicator: "unknown", description: "Feed has no dates" };
+    return since < windowHours * 3_600_000
+        ? {
+            indicator: "minor",
+            description: `Posted ${age(since)} ago: ${latest.title}`,
+        }
+        : { indicator: "none", description: `Last post ${age(since)} ago` };
+};
+const SLACK_IMPACT = {
+    outage: "major",
+    incident: "minor",
+    notice: "minor",
+};
+export const fromSlack = (current) => {
+    const incidents = current?.active_incidents ?? [];
+    if (current?.status === "ok" || incidents.length === 0)
+        return {
+            indicator: "none",
+            description: "All systems operational",
+            active: [],
+        };
+    const indicator = incidents
+        .map((i) => SLACK_IMPACT[i.type ?? ""] ?? "minor")
+        .sort((a, b) => SEVERITY[b] - SEVERITY[a])[0];
+    return {
+        indicator,
+        description: incidents[0].title,
+        components: [...new Set(incidents.flatMap((i) => i.services ?? []))].map((name) => ({
+            name,
+            status: indicator === "major" ? "major_outage" : "degraded_performance",
+        })),
+        active: incidents.map((i) => ({
+            title: i.title,
+            link: i.url ?? "",
+            date: i.date_created ?? "",
+        })),
+    };
+};
+const AWS_STATUS = {
+    "1": "minor",
+    "2": "minor",
+    "3": "major",
+};
+export const fromAws = (events, { regions } = {}) => {
+    const regionOf = (e) => String(e.arn ?? "").split(":")[3] || "global";
+    const wanted = regions?.length ? new Set(regions.map(String)) : null;
+    const open = (events ?? []).filter((e) => !wanted || wanted.has(regionOf(e)) || regionOf(e) === "global");
+    if (open.length === 0)
+        return {
+            indicator: "none",
+            description: wanted
+                ? `No open events in ${[...wanted].join(", ")}`
+                : "No open events",
+        };
+    const level = (e) => AWS_STATUS[String(e.event_log?.at(-1)?.status ?? e.status)] ?? "minor";
+    const indicator = open.map(level).sort((a, b) => SEVERITY[b] - SEVERITY[a])[0];
+    const first = open[0];
+    return {
+        indicator,
+        description: `${first.service_name}, ${first.region_name}: ${first.summary}` +
+            (open.length > 1 ? ` (+${open.length - 1} more)` : ""),
+        components: open.map((e) => ({
+            name: `${e.service_name} (${regionOf(e)})`,
+            status: level(e) === "major" ? "major_outage" : "degraded_performance",
+        })),
+        active: open.map((e) => ({
+            title: `${e.service_name}, ${e.region_name}: ${e.summary}`,
+            link: "https://health.aws.amazon.com/health/status",
+            date: e.date ? new Date(Number(e.date) * 1000).toISOString() : "",
+        })),
+    };
+};
+export const decodeUtf16 = (buf) => {
+    const bytes = new Uint8Array(buf);
+    const le = bytes[0] === 0xff && bytes[1] === 0xfe;
+    return new TextDecoder(le ? "utf-16le" : "utf-16be").decode(bytes);
+};

package/dist/src/core/read.js

@@ -0,0 +1,52 @@
+import { ADAPTERS } from "./adapters.js";
+const failureReason = (error) => {
+    const e = error;
+    return e?.name === "TimeoutError" ? "timed out" : (e?.message ?? "failed");
+};
+export const readService = async (service, opts = {}) => {
+    const base = {
+        id: service.id,
+        name: service.name,
+        url: service.url ?? "",
+        kind: service.kind,
+        fetched: "ok",
+        indicator: "unknown",
+        description: "",
+        components: [],
+        active: [],
+        recent: [],
+        historyLoaded: false,
+        historyFailed: false,
+        note: service.note ?? "",
+    };
+    const adapter = ADAPTERS[service.kind];
+    if (!adapter)
+        return {
+            ...base,
+            fetched: "failed",
+            description: `Unknown kind '${service.kind}'`,
+        };
+    try {
+        const adapted = await adapter(service, opts);
+        return {
+            ...base,
+            ...adapted,
+            historyLoaded: Boolean(opts.detail) && service.kind !== "link",
+        };
+    }
+    catch (error) {
+        if (opts.signal?.aborted)
+            throw opts.signal.reason;
+        return {
+            ...base,
+            fetched: "failed",
+            description: `Could not read the page (${failureReason(error)})`,
+        };
+    }
+};
+export const readAll = async (services, { onRecord, ...opts } = {}) => Promise.all(services.map(async (service) => {
+    const record = await readService(service, opts);
+    if (!opts.signal?.aborted)
+        onRecord?.(record);
+    return record;
+}));

package/dist/src/core/registry.js

@@ -0,0 +1,54 @@
+import { CATALOGUE } from "./catalogue.js";
+export const RESERVED_WORDS = ["list", "services", "help"];
+const KINDS = ["statuspage", "rss", "slack", "aws", "link"];
+export class ConfigError extends Error {
+}
+export const mergeServices = (base = {}, over = {}) => {
+    const merged = { ...base };
+    for (const [id, fields] of Object.entries(over ?? {})) {
+        merged[id] = { ...(merged[id] ?? {}), ...(fields ?? {}) };
+    }
+    return merged;
+};
+const finalise = (raw) => Object.fromEntries(Object.entries(raw)
+    .filter(([, svc]) => svc && svc.enabled !== false)
+    .map(([id, svc]) => [
+    id,
+    { id, name: id, aliases: [], ...svc },
+]));
+export const mergeRegistry = (base = {}, profile = {}) => finalise(mergeServices(base, profile));
+const problemsOf = (svc) => {
+    const words = [svc.id, ...svc.aliases.map(String)].map((w) => w.toLowerCase());
+    const reserved = words.filter((w) => RESERVED_WORDS.includes(w));
+    if (svc.kind === undefined)
+        return [
+            ...reserved.map((w) => `'${w}' is a reserved word`),
+            "is not in the catalogue and has no kind",
+        ];
+    return [
+        ...reserved.map((w) => `'${w}' is a reserved word`),
+        ...(KINDS.includes(svc.kind)
+            ? []
+            : [`kind '${svc.kind}' is not one of ${KINDS.join(", ")}`]),
+        ...(["statuspage", "rss", "link"].includes(svc.kind) &&
+            !/^https:\/\//.test(svc.url ?? "")
+            ? ["needs an https url"]
+            : []),
+        ...(svc.kind === "rss" && !svc.feed ? ["needs a feed"] : []),
+    ];
+};
+export const selectServices = (selected, catalogue = CATALOGUE, source = "") => {
+    const registry = finalise(mergeServices(Object.fromEntries(Object.keys(selected).map((id) => [
+        id,
+        catalogue[id] ?? {},
+    ])), selected));
+    const problems = Object.values(registry).flatMap((svc) => problemsOf(svc).map((p) => `service '${svc.id}': ${p}`));
+    if (problems.length)
+        throw new ConfigError((source ? `${source}: ` : "") + problems.join("\n"));
+    return registry;
+};
+export const resolveService = (registry, word) => {
+    const w = word.toLowerCase();
+    return (registry[w] ??
+        Object.values(registry).find((svc) => svc.aliases.map((a) => String(a).toLowerCase()).includes(w)));
+};

package/dist/src/core/severity.js

@@ -0,0 +1,14 @@
+export const SEVERITY = {
+    critical: 6,
+    major: 5,
+    unknown: 4,
+    minor: 3,
+    maintenance: 2,
+    none: 1,
+    link: 0,
+};
+export const isClear = (indicator) => indicator === "none" || indicator === "link" || indicator === "maintenance";
+export const severityOf = (indicator) => SEVERITY[indicator] ?? SEVERITY.unknown;
+export const worstFirst = (records) => [...records].sort((a, b) => severityOf(b.indicator) - severityOf(a.indicator) ||
+    a.name.localeCompare(b.name));
+export const exitCode = (records) => records.every((r) => isClear(r.indicator)) ? 0 : 1;

package/dist/src/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/labels.js

@@ -0,0 +1,29 @@
+const STATUS = {
+    critical: { text: "● critical", tone: "error" },
+    major: { text: "● major", tone: "error" },
+    minor: { text: "● minor", tone: "warning" },
+    maintenance: { text: "◌ maintenance", tone: "info" },
+    unknown: { text: "? unreadable", tone: "warning" },
+    none: { text: "● ok", tone: "success" },
+    link: { text: "→ manual", tone: "muted" },
+};
+export const statusLabel = (indicator) => STATUS[indicator] ?? STATUS.link;
+const WORDS = {
+    major_outage: { text: "outage", tone: "error" },
+    partial_outage: { text: "partial", tone: "error" },
+    under_maintenance: { text: "maintenance", tone: "info" },
+    critical: { text: "critical", tone: "error" },
+    major: { text: "major", tone: "error" },
+    minor: { text: "minor", tone: "warning" },
+    degraded_performance: { text: "degraded", tone: "warning" },
+};
+export const wordLabel = (status) => WORDS[status ?? ""] ?? { text: "active", tone: "warning" };
+export const declaredText = (record) => {
+    if (record.indicator === "link")
+        return "no feed, open the page";
+    if (record.indicator !== "none")
+        return record.description;
+    if (record.kind === "rss")
+        return `quiet · ${record.description.charAt(0).toLowerCase()}${record.description.slice(1)}`;
+    return "operational";
+};

package/dist/src/mock.js

@@ -0,0 +1,117 @@
+const ago = (minutes) => new Date(Date.now() - minutes * 60_000).toISOString();
+const base = (id, name) => ({
+    id,
+    name,
+    kind: "statuspage",
+    url: `https://status.${id}.example.com`,
+    aliases: [],
+});
+export const MOCK_SERVICES = [
+    base("acme-cloud", "Acme Cloud"),
+    base("example-cdn", "Example CDN"),
+    base("sample-registry", "Sample Registry"),
+    base("demo-maintenance", "Demo Maintenance"),
+    { ...base("demo-feed", "Demo Feed"), kind: "rss", aliases: ["feed"] },
+    base("placeholder-mail", "Placeholder Mail"),
+    { ...base("test-docs", "Test Docs"), kind: "link" },
+];
+const record = (service, fields) => ({
+    id: service.id,
+    name: service.name,
+    url: service.url ?? "",
+    kind: service.kind,
+    fetched: "ok",
+    indicator: "none",
+    description: "All Systems Operational",
+    components: [],
+    active: [],
+    recent: [],
+    historyLoaded: false,
+    historyFailed: false,
+    note: "",
+    ...fields,
+});
+const history = (id) => [
+    {
+        title: "Delayed webhook delivery",
+        link: `https://status.${id}.example.com/incidents/h1`,
+        date: ago(3 * 24 * 60),
+    },
+    {
+        title: "Elevated latency in the EU region",
+        link: `https://status.${id}.example.com/incidents/h2`,
+        date: ago(11 * 24 * 60),
+    },
+];
+export const mockRecord = (service, detail = false) => {
+    const recent = detail ? history(service.id) : [];
+    const flags = { historyLoaded: detail };
+    switch (service.id) {
+        case "acme-cloud":
+            return record(service, {
+                ...flags,
+                indicator: "major",
+                description: "Partial System Outage",
+                components: [
+                    { name: "API", status: "major_outage" },
+                    { name: "Dashboard", status: "degraded_performance" },
+                    { name: "Webhooks", status: "operational" },
+                    { name: "Storage", status: "operational" },
+                ],
+                active: [
+                    {
+                        title: "Elevated API error rates",
+                        link: "https://status.acme-cloud.example.com/incidents/a1",
+                        date: ago(72),
+                        impact: "major",
+                    },
+                ],
+                recent,
+            });
+        case "example-cdn":
+            return record(service, {
+                ...flags,
+                indicator: "minor",
+                description: "Minor Service Outage",
+                components: [{ name: "Edge cache", status: "degraded_performance" }],
+                recent,
+            });
+        case "demo-maintenance":
+            return record(service, {
+                ...flags,
+                indicator: "maintenance",
+                description: "Scheduled maintenance in progress",
+                components: [{ name: "Database", status: "under_maintenance" }],
+                recent,
+            });
+        case "demo-feed":
+            return record(service, {
+                ...flags,
+                description: "Last post 3h ago",
+                recent,
+            });
+        case "placeholder-mail":
+            return record(service, {
+                ...flags,
+                fetched: "failed",
+                indicator: "unknown",
+                description: "Could not read the page (timed out)",
+            });
+        case "test-docs":
+            return record(service, {
+                ...flags,
+                indicator: "link",
+                description: "No machine-readable status",
+                historyLoaded: false,
+            });
+        default:
+            return record(service, {
+                ...flags,
+                components: [
+                    { name: "Install", status: "operational" },
+                    { name: "Search", status: "operational" },
+                ],
+                recent,
+            });
+    }
+};

package/dist/src/mode.js

@@ -0,0 +1,2 @@
+const isSet = (value) => value !== undefined && value !== "" && value !== "0" && value !== "false";
+export const canBeInteractive = ({ stdinTTY, stdoutTTY, env, json, }) => stdinTTY && stdoutTTY && !isSet(env.CI) && !json;

package/dist/src/render.js

@@ -0,0 +1,111 @@
+import { Chalk } from "chalk";
+import { colors } from "@kud/ink-ui";
+import { ageOf, whenLabel, worstFirst, } from "./core/index.js";
+import { declaredText, statusLabel, wordLabel } from "./labels.js";
+const ESC = String.fromCharCode(27);
+const BEL = String.fromCharCode(7);
+const ANSI = new RegExp(`${ESC}\\[[0-9;]*[a-zA-Z]`, "g");
+const OSC8 = new RegExp(`${ESC}\\]8;;[^${BEL}${ESC}]*(?:${BEL}|${ESC}\\\\)`, "g");
+export const stripEscapes = (s) => s.replace(OSC8, "").replace(ANSI, "");
+export const visibleLength = (s) => [...stripEscapes(s)].length;
+const pad = (s, width) => s + " ".repeat(Math.max(0, width - visibleLength(s)));
+const toneColour = {
+    error: colors.error,
+    warning: colors.warning,
+    info: colors.info,
+    success: colors.success,
+    muted: colors.muted,
+};
+const styler = ({ color, links }) => {
+    const chalk = new Chalk({ level: color ? 3 : 0 });
+    return {
+        tone: (text, tone) => chalk.hex(toneColour[tone])(text),
+        muted: (text) => chalk.hex(colors.muted)(text),
+        bold: (text) => chalk.bold(text),
+        link: (text, url) => links && url ? `\u001B]8;;${url}\u001B\\${text}\u001B]8;;\u001B\\` : text,
+    };
+};
+const table = (rows, muted) => {
+    const widths = rows[0].map((_, i) => Math.max(...rows.map((r) => visibleLength(r[i] ?? ""))));
+    return rows.map((row, index) => {
+        const line = row.map((cell, i) => pad(cell, widths[i])).join("  ");
+        return `  ${index === 0 ? muted(line.trimEnd()) : line.trimEnd()}`;
+    });
+};
+export const renderOverview = (records, options) => {
+    const s = styler(options);
+    const rows = [["Status", "Service", "Declared"]].concat(worstFirst(records).map((r) => {
+        const status = s.tone(statusLabel(r.indicator).text, statusLabel(r.indicator).tone);
+        const name = s.link(r.name, r.url);
+        const declared = declaredText(r);
+        const loud = r.indicator !== "none" && r.indicator !== "link";
+        return [
+            status,
+            loud ? s.bold(name) : name,
+            loud ? s.bold(declared) : s.muted(declared),
+        ];
+    }));
+    return [
+        "",
+        ...table(rows, s.muted),
+        "",
+        s.muted("  Declared status only: green is not proof your calls work. incidents list <service> for detail."),
+        ...(options.note ? [s.muted(`  ${options.note}`)] : []),
+        "",
+    ].join("\n");
+};
+const OPERATIONAL = "operational";
+export const renderDetail = (record, options) => {
+    const s = styler(options);
+    const now = options.now ?? Date.now();
+    const status = statusLabel(record.indicator);
+    const broken = record.components.filter((c) => c.status !== OPERATIONAL);
+    const healthy = record.components.length - broken.length;
+    const happening = [
+        ...broken.map((c) => {
+            const w = wordLabel(c.status);
+            return [s.tone(w.text, w.tone), c.name, "now"];
+        }),
+        ...record.active.map((i) => {
+            const w = wordLabel(i.impact);
+            const since = ageOf(i.date, now);
+            return [
+                s.tone(w.text, w.tone),
+                s.link(i.title, i.link),
+                since ? `since ${since}` : "",
+            ];
+        }),
+    ];
+    const current = new Set(record.active.flatMap((i) => [i.link, i.title]).filter(Boolean));
+    const earlier = record.recent
+        .filter((i) => !current.has(i.link) && !current.has(i.title))
+        .slice(0, 7);
+    return [
+        "",
+        `  ${s.tone(status.text, status.tone)}  ${record.description}  ${s.muted(record.url.replace(/^https:\/\//, ""))}`,
+        "",
+        ...(happening.length
+            ? [...table([["Status", "What", "When"], ...happening], s.muted), ""]
+            : []),
+        ...(broken.length === 0 && healthy > 0
+            ? [s.muted(`  ${healthy} components operational`), ""]
+            : []),
+        ...(earlier.length
+            ? [
+                ...table([
+                    ["Earlier", "When"],
+                    ...earlier.map((i) => [
+                        s.muted(s.link(i.title, i.link)),
+                        s.muted(whenLabel(i.date, now)),
+                    ]),
+                ], s.muted),
+                "",
+            ]
+            : []),
+        ...(record.historyFailed
+            ? [s.muted("  History unavailable: its feed could not be read."), ""]
+            : []),
+        ...(record.note ? [s.muted(`  ${record.note}`), ""] : []),
+        ...(options.note ? [s.muted(`  ${options.note}`), ""] : []),
+    ].join("\n");
+};

package/dist/src/source.js

@@ -0,0 +1,35 @@
+import { readAll, readService, } from "./core/index.js";
+import { MOCK_SERVICES, mockRecord } from "./mock.js";
+export const liveSource = (config, version, note) => {
+    const shared = {
+        timeout: config.timeout,
+        userAgent: `incidents-cli/${version}`,
+    };
+    return {
+        services: Object.values(config.services),
+        note,
+        readAll: ({ signal, onRecord }) => readAll(Object.values(config.services), { ...shared, signal, onRecord }),
+        readDetail: (service, { signal }) => readService(service, { ...shared, signal, detail: true }),
+    };
+};
+const settle = (ms, signal) => new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+    }, { once: true });
+});
+export const mockSource = (delayMs = 120) => ({
+    services: MOCK_SERVICES,
+    note: null,
+    readAll: async ({ signal, onRecord }) => Promise.all(MOCK_SERVICES.map(async (service, index) => {
+        await settle(delayMs * (index + 1), signal);
+        const record = mockRecord(service);
+        onRecord?.(record);
+        return record;
+    })),
+    readDetail: async (service, { signal }) => {
+        await settle(delayMs, signal);
+        return mockRecord(service, true);
+    },
+});