jochen
7e9ef899c1
ADR 0193 says the node's runtime launches every served bundle over MCP stdio and knows no language, and ADR 0188 says one module may carry several bundles in any language. Nothing in the catalogue shows both at once: every tools bundle is TypeScript, and the only Go bundle is the runtime itself. netcheck is the smallest real module that does — read-only checks from a machine, worth having on their own: - tools-go (Go SDK go/v0.1.6): netcheck_tcp (one connect, nothing sent) and netcheck_dns (A/AAAA/CNAME/TXT/MX through the machine's resolver). - tools-typescript (@novox/mesh-sdk): netcheck_http (HEAD or GET, body neither sent nor read, redirects reported not followed, anything but http(s) refused). Both say loads; the module lists its tools. No container, no image, no env: nothing to be given, so the runtime's own words suffice.
85 lines
3.4 KiB
TypeScript
85 lines
3.4 KiB
TypeScript
// netcheck's HTTP check — the module's own code, in TypeScript (novox/hq ADR 0039, ADR 0188). One
|
|
// request, HEAD or GET, never a body sent and never a body read: the status, how long it took and
|
|
// a few headers that say what answered. Redirects are reported, not followed, so a check reaches
|
|
// exactly the address it was given.
|
|
|
|
export const METHODS = ["HEAD", "GET"] as const;
|
|
export type Method = (typeof METHODS)[number];
|
|
|
|
/** The headers worth reporting: what answered and what it says it is, nothing it set for a client. */
|
|
export const REPORTED_HEADERS = [
|
|
"content-type", "content-length", "server", "location", "date",
|
|
"cache-control", "last-modified", "etag",
|
|
] as const;
|
|
|
|
export const DEFAULT_TIMEOUT_MS = 5000;
|
|
export const MOST_TIMEOUT_MS = 30000;
|
|
|
|
export interface HttpResult {
|
|
url: string;
|
|
method: Method;
|
|
status?: number;
|
|
statusText?: string;
|
|
elapsed_ms: number;
|
|
headers: Record<string, string>;
|
|
error?: string;
|
|
}
|
|
|
|
/** Only http and https are checked; anything else — file:, data:, ftp: — is refused by name. */
|
|
export function checkedUrl(raw: unknown): URL {
|
|
const text = typeof raw === "string" ? raw.trim() : "";
|
|
if (!text) throw new Error("url is required");
|
|
let url: URL;
|
|
try {
|
|
url = new URL(text);
|
|
} catch {
|
|
throw new Error(`${JSON.stringify(text)} is not a URL`);
|
|
}
|
|
if (url.protocol !== "http:" && url.protocol !== "https:") {
|
|
throw new Error(`netcheck_http checks http and https URLs only, not ${url.protocol}`);
|
|
}
|
|
return url;
|
|
}
|
|
|
|
export function checkedMethod(raw: unknown): Method {
|
|
const m = (typeof raw === "string" && raw.trim() ? raw.trim() : "HEAD").toUpperCase();
|
|
if (!(METHODS as readonly string[]).includes(m)) {
|
|
throw new Error(`method ${m} is not one netcheck_http uses (${METHODS.join(", ")}): a check never changes anything`);
|
|
}
|
|
return m as Method;
|
|
}
|
|
|
|
export function checkedTimeout(raw: unknown): number {
|
|
if (raw === undefined || raw === null || raw === "") return DEFAULT_TIMEOUT_MS;
|
|
const n = Number(raw);
|
|
if (!Number.isInteger(n) || n < 1) throw new Error(`timeout_ms must be a whole number of at least 1, not ${String(raw)}`);
|
|
return Math.min(n, MOST_TIMEOUT_MS);
|
|
}
|
|
|
|
/** Make one request and report how it went. A refused connection or a timeout is a result with its
|
|
* error; only a malformed question throws. */
|
|
export async function checkHttp(args: Readonly<Record<string, unknown>>, fetcher: typeof fetch = fetch): Promise<HttpResult> {
|
|
const url = checkedUrl(args.url);
|
|
const method = checkedMethod(args.method);
|
|
const timeout = checkedTimeout(args.timeout_ms);
|
|
const started = performance.now();
|
|
const out: HttpResult = { url: url.toString(), method, elapsed_ms: 0, headers: {} };
|
|
try {
|
|
const res = await fetcher(url, { method, redirect: "manual", signal: AbortSignal.timeout(timeout) });
|
|
out.elapsed_ms = Math.round(performance.now() - started);
|
|
out.status = res.status;
|
|
out.statusText = res.statusText;
|
|
for (const h of REPORTED_HEADERS) {
|
|
const v = res.headers.get(h);
|
|
if (v !== null) out.headers[h] = v;
|
|
}
|
|
// The body is not read: a check asks whether something answers, not what it says.
|
|
await res.body?.cancel().catch(() => {});
|
|
} catch (err) {
|
|
out.elapsed_ms = Math.round(performance.now() - started);
|
|
const e = err as Error & { cause?: { message?: string; code?: string } };
|
|
out.error = e.name === "TimeoutError" ? `no answer within ${timeout} ms` : (e.cause?.code ?? e.cause?.message ?? e.message);
|
|
}
|
|
return out;
|
|
}
|