@the-seeker/server-agent 0.1.0

package/dist/collectors/command.js

@@ -0,0 +1,53 @@
+import { execFile } from "node:child_process";
+export function run(file, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        execFile(file, [...args], { timeout: 8000, maxBuffer: 8 * 1024 * 1024, ...options, shell: false, encoding: "utf8" }, (error, stdout, stderr) => {
+            if (error)
+                reject(Object.assign(error, { stderr }));
+            else
+                resolve({ stdout, stderr });
+        });
+    });
+}
+export async function locate(binary) {
+    try {
+        const { stdout } = await run("which", [binary]);
+        return stdout.trim() || null;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && (error.code === 1 || error.code === "ENOENT"))
+            return null;
+        throw error;
+    }
+}
+export class CollectionError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "CollectionError";
+    }
+}
+export function responseError(error) {
+    if (error instanceof CollectionError)
+        return error;
+    if (!(error instanceof Error))
+        throw error;
+    const code = "code" in error ? error.code : undefined;
+    const stderr = "stderr" in error && typeof error.stderr === "string" ? error.stderr : "";
+    if (code === "EACCES" || code === "EPERM" || code === "ELOOP" || /No journal files|permission|access denied/i.test(stderr))
+        return new CollectionError("permission_denied");
+    if (code === "ENOENT")
+        return new CollectionError("not_found");
+    if (code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER")
+        return new CollectionError("too_large");
+    if (error.name === "AbortError" || ("killed" in error && error.killed === true))
+        return new CollectionError("timeout");
+    return new CollectionError("internal");
+}
+export function capabilityError(error) {
+    const mapped = responseError(error);
+    if (mapped.code === "not_found")
+        return "not_installed";
+    return mapped.code === "permission_denied" ? "permission_denied" : "error";
+}

package/dist/collectors/host.d.ts

@@ -0,0 +1,16 @@
+import si from "systeminformation";
+import type { Host } from "../protocol.js";
+type NetworkCounter = Readonly<Pick<si.Systeminformation.NetworkStatsData, "iface" | "rx_bytes" | "tx_bytes">>;
+export type NetworkSample = {
+    readonly measuredAt: number;
+    readonly interfaces: readonly NetworkCounter[];
+};
+export type HostCollection = {
+    readonly host: Host;
+    readonly collected_at: string;
+    readonly sample: NetworkSample;
+};
+export declare function networkRates(current: NetworkSample, previous?: NetworkSample): Host["net"];
+export declare function filterDisks(disks: readonly Pick<si.Systeminformation.FsSizeData, "fs" | "type" | "mount" | "used" | "size">[]): Host["disks"];
+export declare function collectHost(previous?: NetworkSample): Promise<HostCollection>;
+export {};

package/dist/collectors/host.js

@@ -0,0 +1,43 @@
+import * as os from "node:os";
+import { performance } from "node:perf_hooks";
+import si from "systeminformation";
+export function networkRates(current, previous) {
+    const missing = { rx_bps: null, tx_bps: null };
+    if (!previous || current.measuredAt <= previous.measuredAt || !current.interfaces.length)
+        return missing;
+    if (current.interfaces.length !== previous.interfaces.length)
+        return missing;
+    const elapsed = (current.measuredAt - previous.measuredAt) / 1000;
+    let rx = 0;
+    let tx = 0;
+    for (const counter of current.interfaces) {
+        const prior = previous.interfaces.find((entry) => entry.iface === counter.iface);
+        if (!prior)
+            return missing;
+        rx += counter.rx_bytes < prior.rx_bytes || prior.rx_bytes < 0 ? NaN : counter.rx_bytes - prior.rx_bytes;
+        tx += counter.tx_bytes < prior.tx_bytes || prior.tx_bytes < 0 ? NaN : counter.tx_bytes - prior.tx_bytes;
+    }
+    return { rx_bps: Number.isFinite(rx) ? rx / elapsed : null, tx_bps: Number.isFinite(tx) ? tx / elapsed : null };
+}
+export function filterDisks(disks) {
+    return disks.filter((disk) => !["devfs", "tmpfs", "squashfs", "overlay"].includes(disk.type.toLowerCase())
+        && disk.mount !== "/System/Volumes" && !disk.mount.startsWith("/System/Volumes/"))
+        .slice(0, 32).map((disk) => ({ mount: disk.mount, fs: disk.fs, used: disk.used, total: disk.size }));
+}
+export async function collectHost(previous) {
+    const [cpu, memory, disks, sample] = await Promise.all([
+        si.currentLoad(), si.mem(), si.fsSize(),
+        si.networkStats().then((interfaces) => ({ measuredAt: performance.now(), interfaces: interfaces.map(({ iface, rx_bytes, tx_bytes }) => ({ iface, rx_bytes, tx_bytes })) })),
+    ]);
+    const [load1 = 0, load5 = 0, load15 = 0] = os.loadavg();
+    return {
+        collected_at: new Date().toISOString(), sample,
+        host: {
+            cpu_pct: Number.isFinite(cpu.currentLoad) ? Math.max(0, Math.min(100, cpu.currentLoad)) : null,
+            cpu_count: os.cpus().length, load: [load1, load5, load15],
+            mem: { used: memory.total - memory.available, total: memory.total },
+            swap: { used: memory.swapused, total: memory.swaptotal }, disks: filterDisks(disks),
+            net: networkRates(sample, previous), uptime_sec: os.uptime(),
+        },
+    };
+}

package/dist/collectors/nginx-config.d.ts

@@ -0,0 +1,8 @@
+export declare const NGINX_CONFIG_ROOTS: readonly ["/etc/nginx", "/opt/homebrew/etc/nginx"];
+export type Directive = {
+    readonly words: readonly string[];
+    readonly children: readonly Directive[];
+};
+export declare function parseConfig(text: string): Directive[];
+export declare function readNginxConfig(file: string, roots?: readonly string[]): Promise<string>;
+export declare function expandNginxDump(text: string): string;

package/dist/collectors/nginx-config.js

@@ -0,0 +1,132 @@
+import { readFile, readdir, realpath } from "node:fs/promises";
+import { dirname, resolve, sep } from "node:path";
+import { CollectionError } from "./command.js";
+import { inside } from "./sources.js";
+export const NGINX_CONFIG_ROOTS = ["/etc/nginx", "/opt/homebrew/etc/nginx"];
+export function parseConfig(text) {
+    const tokens = text.match(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|#[^\n]*|[{};]|[^\s{};"'#]+/g) ?? [];
+    let index = 0;
+    function block(nested) {
+        const directives = [];
+        let words = [];
+        while (index < tokens.length) {
+            const token = tokens[index++];
+            if (!token || token.startsWith("#"))
+                continue;
+            if (token === "}") {
+                if (!nested || words.length)
+                    throw new CollectionError("internal");
+                return directives;
+            }
+            if (token === "{" || token === ";") {
+                directives.push({ words, children: token === "{" ? block(true) : [] });
+                words = [];
+            }
+            else
+                words.push(token.replace(/^(["'])([\s\S]*)\1$/, "$2"));
+        }
+        if (nested || words.length)
+            throw new CollectionError("internal");
+        return directives;
+    }
+    return block(false);
+}
+function globRegex(pattern) {
+    return new RegExp(`^${pattern.replace(/[.+^${}()|\\]/g, "\\$&").replace(/\[!/g, "[^").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")}$`);
+}
+export async function readNginxConfig(file, roots = NGINX_CONFIG_ROOTS) {
+    const canonicalRoots = await Promise.all(roots.map(async (root) => {
+        try {
+            return await realpath(root);
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                return resolve(root);
+            throw error;
+        }
+    }));
+    async function checked(path) {
+        if (!roots.some((root) => inside(resolve(path), resolve(root))))
+            throw new CollectionError("permission_denied");
+        const canonical = await realpath(path);
+        if (!canonicalRoots.some((root) => inside(canonical, root)))
+            throw new CollectionError("permission_denied");
+        return canonical;
+    }
+    async function expand(pattern) {
+        const segments = resolve(pattern).split(sep).filter(Boolean);
+        let paths = [sep];
+        for (const segment of segments) {
+            if (!/[?*\[]/.test(segment)) {
+                paths = paths.map((path) => resolve(path, segment));
+                continue;
+            }
+            const expanded = [];
+            for (const path of paths) {
+                const parent = await checked(path);
+                for (const name of (await readdir(parent)).sort())
+                    if (globRegex(segment).test(name))
+                        expanded.push(resolve(path, name));
+            }
+            paths = expanded;
+        }
+        return paths;
+    }
+    const prefix = dirname(file);
+    async function load(path, depth) {
+        if (depth > 3)
+            throw new CollectionError("unsupported");
+        const text = await readFile(await checked(path), "utf8");
+        const directives = parseConfig(text);
+        async function render(entries) {
+            const output = [];
+            for (const entry of entries) {
+                if (entry.words[0] === "include" && entry.words[1]) {
+                    for (const child of await expand(resolve(prefix, entry.words[1])))
+                        output.push(await load(child, depth + 1));
+                }
+                else {
+                    const words = entry.words.map((word) => JSON.stringify(word)).join(" ");
+                    output.push(entry.children.length ? `${words} { ${await render(entry.children)} }` : `${words};`);
+                }
+            }
+            return output.join("\n");
+        }
+        return render(directives);
+    }
+    return load(file, 0);
+}
+export function expandNginxDump(text) {
+    const sections = [...text.matchAll(/^# configuration file (.+):\r?\n/gm)];
+    if (!sections.length)
+        return text;
+    const files = new Map();
+    for (const [index, section] of sections.entries()) {
+        const path = section[1];
+        if (path) {
+            if (!NGINX_CONFIG_ROOTS.some((root) => inside(resolve(path), root)))
+                throw new CollectionError("permission_denied");
+            files.set(path, text.slice((section.index ?? 0) + section[0].length, sections[index + 1]?.index ?? text.length));
+        }
+    }
+    const first = sections[0]?.[1];
+    if (!first)
+        throw new CollectionError("internal");
+    const prefix = dirname(first);
+    function render(entries, depth) {
+        if (depth > 3)
+            throw new CollectionError("unsupported");
+        return entries.map((entry) => {
+            if (entry.words[0] === "include" && entry.words[1]) {
+                const include = resolve(prefix, entry.words[1]);
+                if (!NGINX_CONFIG_ROOTS.some((root) => inside(include, root)))
+                    throw new CollectionError("permission_denied");
+                const pattern = globRegex(include);
+                return [...files].filter(([path]) => pattern.test(path)).map(([, content]) => render(parseConfig(content), depth + 1)).join("\n");
+            }
+            const words = entry.words.map((word) => JSON.stringify(word)).join(" ");
+            return entry.children.length ? `${words} { ${render(entry.children, depth)} }` : `${words};`;
+        }).join("\n");
+    }
+    return render(parseConfig(files.get(first) ?? ""), 0);
+}

package/dist/collectors/nginx.d.ts

@@ -0,0 +1,8 @@
+import type { CapabilityState, Source } from "../protocol.js";
+import type { SourceRegistry } from "./sources.js";
+export type NginxCollection = {
+    readonly capability: CapabilityState;
+    readonly sources: Source[];
+};
+export declare function mapNginx(text: string, registry: SourceRegistry, prefix?: string): NginxCollection;
+export declare function collectNginx(nginxEnabled: boolean, registry: SourceRegistry, signal?: AbortSignal): Promise<NginxCollection>;

package/dist/collectors/nginx.js

@@ -0,0 +1,78 @@
+import { isAbsolute, resolve } from "node:path";
+import { capabilityError, CollectionError, locate, run } from "./command.js";
+import { expandNginxDump, parseConfig, readNginxConfig } from "./nginx-config.js";
+export function mapNginx(text, registry, prefix = "/usr/local/nginx") {
+    const sources = [];
+    for (const http of parseConfig(text).filter((entry) => entry.words[0] === "http")) {
+        for (const server of http.children.filter((entry) => entry.words[0] === "server")) {
+            const name = server.children.find((entry) => entry.words[0] === "server_name")?.words[1] ?? "_";
+            for (const [directive, kind] of [["access_log", "nginx_access"], ["error_log", "nginx_error"]]) {
+                const find = (entries) => entries.find((entry) => entry.words[0] === directive);
+                const path = (find(server.children) ?? find(http.children))?.words[1];
+                if (path && path !== "off" && !path.startsWith("syslog:") && !path.includes("$")) {
+                    sources.push(registry.registerFile(kind, name, resolve(prefix, path), name, "Nginx"));
+                }
+            }
+        }
+    }
+    return { capability: "available", sources: [...new Map(sources.map((source) => [source.id, source])).values()] };
+}
+export async function collectNginx(nginxEnabled, registry, signal) {
+    registry.clearKinds(["nginx_access", "nginx_error"]);
+    if (!nginxEnabled)
+        return { capability: "unsupported", sources: [] };
+    try {
+        const binary = await locate("nginx");
+        if (!binary)
+            return { capability: "not_installed", sources: [] };
+        let text;
+        try {
+            const { stdout } = await run(binary, ["-T"], { timeout: 5000, ...(signal ? { signal } : {}) });
+            text = expandNginxDump(stdout);
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            signal?.throwIfAborted();
+            try {
+                text = await readNginxConfig("/etc/nginx/nginx.conf");
+            }
+            catch (fallbackError) {
+                if (!(fallbackError instanceof Error))
+                    throw fallbackError;
+                try {
+                    text = await readNginxConfig("/opt/homebrew/etc/nginx/nginx.conf");
+                }
+                catch (homebrewError) {
+                    if (!(homebrewError instanceof Error))
+                        throw homebrewError;
+                    throw new CollectionError("permission_denied");
+                }
+            }
+        }
+        const pending = [...parseConfig(text)];
+        let relativeLogs = false;
+        while (pending.length) {
+            const entry = pending.pop();
+            if (!entry)
+                break;
+            pending.push(...entry.children);
+            const path = entry.words[1];
+            if ((entry.words[0] === "access_log" || entry.words[0] === "error_log") && path
+                && path !== "off" && !path.startsWith("syslog:") && !path.includes("$") && !isAbsolute(path))
+                relativeLogs = true;
+        }
+        let prefix = "/usr/local/nginx";
+        if (relativeLogs) {
+            const version = await run(binary, ["-V"], { timeout: 5000, ...(signal ? { signal } : {}) });
+            const configured = `${version.stdout}\n${version.stderr}`.match(/--prefix=(?:"([^"]+)"|'([^']+)'|(\S+))/);
+            prefix = configured?.[1] ?? configured?.[2] ?? configured?.[3] ?? prefix;
+            if (!isAbsolute(prefix))
+                throw new CollectionError("permission_denied");
+        }
+        return mapNginx(text, registry, prefix);
+    }
+    catch (error) {
+        return { capability: capabilityError(error), sources: [] };
+    }
+}

package/dist/collectors/pm2.d.ts

@@ -0,0 +1,12 @@
+import type { CapabilityState, Process, Source } from "../protocol.js";
+import type { SourceRegistry } from "./sources.js";
+export type Pm2Collection = {
+    readonly capability: CapabilityState;
+    readonly processes: Process[];
+    readonly sources: Source[];
+};
+export declare function mapPm2(text: string, registry: SourceRegistry, now?: number): Pm2Collection;
+export declare function collectPm2(registry: SourceRegistry, options?: {
+    readonly pm2Home?: string;
+    readonly signal?: AbortSignal;
+}): Promise<Pm2Collection>;

package/dist/collectors/pm2.js

@@ -0,0 +1,50 @@
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { z } from "zod";
+import { capabilityError, locate, run } from "./command.js";
+const jlist = z.array(z.object({
+    name: z.string(), pm_id: z.number(),
+    monit: z.object({ cpu: z.number().default(0), memory: z.number().default(0) }),
+    pm2_env: z.object({
+        status: z.string(), restart_time: z.number().default(0), unstable_restarts: z.number().default(0),
+        pm_uptime: z.number().nullish(), version: z.string().nullish(), exec_mode: z.string().nullish(),
+        pm_out_log_path: z.string().optional(), pm_err_log_path: z.string().optional(),
+    }),
+}));
+export function mapPm2(text, registry, now = Date.now()) {
+    const entries = jlist.parse(JSON.parse(text)).slice(0, 100);
+    const sources = [];
+    const processes = entries.map((entry) => {
+        const environment = entry.pm2_env;
+        if (environment.pm_out_log_path && isAbsolute(environment.pm_out_log_path)) {
+            sources.push(registry.registerFile("pm2_out", entry.name, environment.pm_out_log_path, `${entry.name} stdout`, "PM2"));
+        }
+        if (environment.pm_err_log_path && isAbsolute(environment.pm_err_log_path)) {
+            sources.push(registry.registerFile("pm2_err", entry.name, environment.pm_err_log_path, `${entry.name} stderr`, "PM2"));
+        }
+        return {
+            name: entry.name, pm_id: entry.pm_id, status: environment.status, cpu_pct: entry.monit.cpu,
+            memory_bytes: entry.monit.memory, restarts: environment.restart_time, unstable_restarts: environment.unstable_restarts,
+            uptime_ms: environment.pm_uptime ? Math.max(0, now - environment.pm_uptime) : null,
+            version: environment.version ?? null, exec_mode: environment.exec_mode ?? null,
+        };
+    });
+    return { capability: "available", processes, sources: [...new Map(sources.map((source) => [source.id, source])).values()] };
+}
+export async function collectPm2(registry, options = {}) {
+    registry.clearKinds(["pm2_out", "pm2_err"]);
+    try {
+        const binary = process.env["PM2_BIN"] || await locate("pm2");
+        if (!binary)
+            return { capability: "not_installed", processes: [], sources: [] };
+        const { stdout } = await run(binary, ["jlist"], {
+            timeout: 8000, maxBuffer: 8 * 1024 * 1024,
+            env: { ...process.env, PM2_HOME: options.pm2Home ?? process.env["PM2_HOME"] ?? join(homedir(), ".pm2") },
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        return mapPm2(stdout, registry);
+    }
+    catch (error) {
+        return { capability: capabilityError(error), processes: [], sources: [] };
+    }
+}

package/dist/collectors/sources.d.ts

@@ -0,0 +1,12 @@
+import type { LogsTailPayload, Source, SourceKind } from "../protocol.js";
+type FileKind = Exclude<SourceKind, "systemd_journal">;
+export declare function inside(path: string, root: string): boolean;
+export declare class SourceRegistry {
+    #private;
+    constructor(pm2Home?: string);
+    registerFile(kind: FileKind, name: string, path: string, label: string, group: string): Source;
+    registerJournal(unit: string): Source;
+    clearKinds(kinds: readonly SourceKind[]): void;
+    tail(sourceId: string, lines: number, signal?: AbortSignal): Promise<LogsTailPayload>;
+}
+export {};

package/dist/collectors/sources.js

@@ -0,0 +1,110 @@
+import { constants } from "node:fs";
+import { open, realpath, stat } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { LOG_MAX_BYTES, makeSourceId } from "../protocol.js";
+import { CollectionError, responseError, run } from "./command.js";
+export function inside(path, root) {
+    return path === root || path.startsWith(root + sep);
+}
+function payload(sourceId, input, lines, clipped) {
+    let start = Math.max(0, input.length - LOG_MAX_BYTES);
+    while (start < input.length && ((input[start] ?? 0) & 0xc0) === 0x80)
+        start++;
+    const text = input.subarray(start).toString("utf8").replace(/\n$/, "");
+    const selected = input.length ? text.split("\n").slice(-lines) : [];
+    const encoded = Buffer.from(selected.join("\n"));
+    let offset = Math.max(0, encoded.length - LOG_MAX_BYTES);
+    while (offset < encoded.length && ((encoded[offset] ?? 0) & 0xc0) === 0x80)
+        offset++;
+    const bounded = encoded.subarray(offset).toString("utf8");
+    return { source_id: sourceId, lines: selected.length ? bounded.split("\n") : [], bytes: Buffer.byteLength(bounded),
+        truncated: clipped || input.length > LOG_MAX_BYTES || offset > 0 };
+}
+export class SourceRegistry {
+    #targets = new Map();
+    #roots;
+    constructor(pm2Home = process.env["PM2_HOME"] ?? join(homedir(), ".pm2")) {
+        this.#roots = ["/var/log/nginx", "/opt/homebrew/var/log/nginx", join(pm2Home, "logs"), join(homedir(), ".pm2/logs")];
+    }
+    registerFile(kind, name, path, label, group) {
+        if (!isAbsolute(path))
+            throw new CollectionError("permission_denied");
+        const id = makeSourceId(kind, name);
+        this.#targets.set(id, { kind, path: resolve(path) });
+        return { id, kind, label, group };
+    }
+    registerJournal(unit) {
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9_.@:\\-]*$/.test(unit))
+            throw new CollectionError("permission_denied");
+        const kind = "systemd_journal";
+        const id = makeSourceId(kind, unit);
+        this.#targets.set(id, { kind, unit });
+        return { id, kind, label: unit, group: "서비스" };
+    }
+    clearKinds(kinds) {
+        for (const [id, target] of this.#targets)
+            if (kinds.includes(target.kind))
+                this.#targets.delete(id);
+    }
+    async tail(sourceId, lines, signal) {
+        const target = this.#targets.get(sourceId);
+        if (!target)
+            throw new CollectionError("not_found");
+        if (!Number.isInteger(lines) || lines < 1 || lines > 500)
+            throw new CollectionError("unsupported");
+        try {
+            if (target.kind === "systemd_journal") {
+                const result = await run("journalctl", ["-u", target.unit, "-n", String(lines), "--no-pager", "-o", "short-iso"], { ...(signal ? { signal } : {}), maxBuffer: 8 * 1024 * 1024 });
+                return payload(sourceId, Buffer.from(result.stdout), lines, false);
+            }
+            const canonical = await realpath(target.path);
+            let advertised = target.path;
+            if (platform() === "darwin") {
+                const alias = ["/var", "/tmp", "/etc"].find((root) => inside(target.path, root));
+                if (alias)
+                    advertised = resolve(await realpath(alias), relative(alias, target.path));
+            }
+            const roots = await Promise.all(this.#roots.map(async (root) => {
+                try {
+                    return await realpath(root);
+                }
+                catch (error) {
+                    if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "EACCES"))
+                        return resolve(root);
+                    throw error;
+                }
+            }));
+            if (canonical !== advertised && !roots.some((root) => inside(canonical, root)))
+                throw new CollectionError("permission_denied");
+            const handle = await open(canonical, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+            try {
+                const metadata = await handle.stat();
+                const current = await stat(canonical);
+                if (!metadata.isFile() || metadata.dev !== current.dev || metadata.ino !== current.ino || await realpath(target.path) !== canonical) {
+                    throw new CollectionError("permission_denied");
+                }
+                let position = metadata.size;
+                let content = Buffer.alloc(0);
+                while (position > 0 && content.length < LOG_MAX_BYTES + 1) {
+                    signal?.throwIfAborted();
+                    const size = Math.min(16384, position, LOG_MAX_BYTES + 1 - content.length);
+                    position -= size;
+                    const block = Buffer.alloc(size);
+                    const { bytesRead } = await handle.read(block, 0, size, position);
+                    content = Buffer.concat([block.subarray(0, bytesRead), content]);
+                    const lineCount = content.toString("utf8").split("\n").length - (content.at(-1) === 10 ? 1 : 0);
+                    if (lineCount > lines)
+                        break;
+                }
+                return payload(sourceId, content, lines, content.length > LOG_MAX_BYTES);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch (error) {
+            throw responseError(error);
+        }
+    }
+}

package/dist/collectors/systemd.d.ts

@@ -0,0 +1,11 @@
+import type { CapabilityState, Service, Source } from "../protocol.js";
+import type { SourceRegistry } from "./sources.js";
+export type SystemdCollection = {
+    readonly capability: CapabilityState;
+    readonly services: Service[];
+    readonly sources: Source[];
+};
+export declare function collectSystemd(watchedServices: readonly string[], registry: SourceRegistry, options?: {
+    readonly platform?: string;
+    readonly signal?: AbortSignal;
+}): Promise<SystemdCollection>;

package/dist/collectors/systemd.js

@@ -0,0 +1,28 @@
+import { platform } from "node:os";
+import { capabilityError, locate, run } from "./command.js";
+export async function collectSystemd(watchedServices, registry, options = {}) {
+    registry.clearKinds(["systemd_journal"]);
+    if ((options.platform ?? platform()) !== "linux")
+        return { capability: "unsupported", services: [], sources: [] };
+    try {
+        const binary = await locate("systemctl");
+        if (!binary)
+            return { capability: "not_installed", services: [], sources: [] };
+        const services = [];
+        const sources = [];
+        for (const unit of [...new Set(watchedServices)].slice(0, 50)) {
+            sources.push(registry.registerJournal(unit));
+            const { stdout } = await run(binary, ["show", unit, "--property=ActiveState,SubState,MainPID,NRestarts", "--no-pager"], options.signal ? { signal: options.signal } : {});
+            const properties = new Map(stdout.split("\n").map((line) => {
+                const split = line.indexOf("=");
+                return [line.slice(0, split), line.slice(split + 1)];
+            }));
+            services.push({ unit, active_state: properties.get("ActiveState") ?? "unknown", sub_state: properties.get("SubState") ?? "unknown" });
+        }
+        return { capability: "available", services, sources };
+    }
+    catch (error) {
+        registry.clearKinds(["systemd_journal"]);
+        return { capability: capabilityError(error), services: [], sources: [] };
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+export declare const SYSTEM_CONFIG_DIR = "/etc/theseeker-agent";
+export declare const CONFIG_FILE_NAME = "config.json";
+export declare const CONFIG_FILE_MODE = 384;
+export declare const CONFIG_DIR_MODE = 488;
+export declare const ENDPOINT_ENV = "THESEEKER_AGENT_ENDPOINT";
+export declare const TOKEN_ENV = "THESEEKER_AGENT_TOKEN";
+export declare const AGENT_VERSION: string;
+export declare const LogLevelSchema: z.ZodEnum<{
+    error: "error";
+    debug: "debug";
+    info: "info";
+    warn: "warn";
+}>;
+export type LogLevel = z.infer<typeof LogLevelSchema>;
+export declare const ConfigFileSchema: z.ZodObject<{
+    endpoint: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    pm2Home: z.ZodOptional<z.ZodString>;
+    logLevel: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>>;
+}, z.core.$strip>;
+export type ConfigFile = z.infer<typeof ConfigFileSchema>;
+export interface AgentConfig {
+    readonly endpoint: string;
+    readonly token: string;
+    readonly pm2Home?: string | undefined;
+    readonly logLevel: LogLevel;
+}
+export interface ConfigEnvironment {
+    readonly platform?: string | undefined;
+    readonly env?: NodeJS.ProcessEnv | undefined;
+    readonly home?: string | undefined;
+}
+export declare class AgentConfigError extends Error {
+    constructor(message: string);
+}
+export declare function systemConfigPath(): string;
+export declare function userConfigPath(home?: string): string;
+/** First existing readable config file, or `null` when the agent is env-only. */
+export declare function readableConfigPath(options?: ConfigEnvironment): Promise<string | null>;
+/** Where `install` should write: the system path on linux when its directory is writable, else the user path. */
+export declare function writableConfigPath(options?: ConfigEnvironment): Promise<string>;
+export declare function writeConfigFile(config: ConfigFile, path: string): Promise<void>;
+export declare function readConfigFile(path: string): Promise<ConfigFile>;
+/** Config file merged with the `THESEEKER_AGENT_*` overrides. Never echoes the token back to the caller's logs. */
+export declare function loadConfig(options?: ConfigEnvironment): Promise<AgentConfig>;
+export type LogFields = Readonly<Record<string, string | number | boolean | null | undefined>>;
+export type Logger = (level: LogLevel, event: string, fields?: LogFields) => void;
+/** Structured stdout-only logger. Callers pass event names and scalar fields; frame bodies and tokens are never accepted. */
+export declare function createLogger(level?: LogLevel, write?: (line: string) => void): Logger;