@the-seeker/server-agent 0.1.0

package/dist/protocol.js

@@ -0,0 +1,115 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+export const PROTOCOL_VERSION = 1;
+export const MAX_HEARTBEAT_BYTES = 131072;
+export const MAX_RESPONSE_BYTES = 393216;
+export const LOG_LINES_OPTIONS = [100, 200, 500];
+export const LOG_MAX_BYTES = 262144;
+export const REQUEST_TIMEOUT_MS = 20000;
+export const OFFLINE_AFTER_MS = 90000;
+export const PROCESS_HISTORY_INTERVAL_MS = 60000;
+export const SourceKindSchema = z.enum(["pm2_out", "pm2_err", "nginx_access", "nginx_error", "systemd_journal"]);
+export const SourceSchema = z.object({
+    id: z.string().max(120).regex(/^[a-z0-9._:-]+$/),
+    kind: SourceKindSchema, label: z.string(), group: z.string(),
+}).strict();
+export function makeSourceId(kind, rawName) {
+    const slug = rawName.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").slice(0, 60);
+    const hash6 = createHash("sha1").update(rawName).digest("hex").slice(0, 6);
+    return `${kind}:${slug}-${hash6}`;
+}
+export const CapabilityStateSchema = z.enum(["available", "unsupported", "not_installed", "permission_denied", "error"]);
+export const CapabilitiesSchema = z.object({
+    host: CapabilityStateSchema, pm2: CapabilityStateSchema,
+    systemd: CapabilityStateSchema, nginx: CapabilityStateSchema,
+}).strict();
+const isoTimestamp = z.iso.datetime({ offset: true });
+const memory = z.object({ used: z.number(), total: z.number() }).strict();
+export const HostSchema = z.object({
+    cpu_pct: z.number().min(0).max(100).nullable(), cpu_count: z.number(),
+    load: z.tuple([z.number(), z.number(), z.number()]).nullable(),
+    mem: memory.nullable(), swap: memory.nullable(),
+    disks: z.array(z.object({
+        mount: z.string(), fs: z.string(), used: z.number(), total: z.number(),
+    }).strict()).max(32),
+    net: z.object({ rx_bps: z.number().nullable(), tx_bps: z.number().nullable() }).strict(),
+    uptime_sec: z.number(),
+}).strict();
+export const ProcessSchema = z.object({
+    name: z.string(), pm_id: z.number(), status: z.string(), cpu_pct: z.number(),
+    memory_bytes: z.number(), restarts: z.number(), unstable_restarts: z.number(),
+    uptime_ms: z.number().nullable(), version: z.string().nullable(), exec_mode: z.string().nullable(),
+}).strict();
+export const ServiceSchema = z.object({
+    unit: z.string(), active_state: z.string(), sub_state: z.string(),
+}).strict();
+export const HelloFrameSchema = z.object({
+    type: z.literal("hello"), protocol_version: z.literal(PROTOCOL_VERSION),
+    agent_version: z.string(), hostname: z.string(),
+    os: z.object({ platform: z.enum(["linux", "darwin"]), release: z.string(), arch: z.string() }).strict(),
+    cpu_count: z.number(), boot_time: isoTimestamp, capabilities: CapabilitiesSchema,
+    sources: z.array(SourceSchema),
+}).strict();
+export const HeartbeatFrameSchema = z.object({
+    type: z.literal("heartbeat"), seq: z.number().int().min(1), collected_at: isoTimestamp,
+    host: HostSchema, processes: z.array(ProcessSchema).max(100),
+    services: z.array(ServiceSchema).max(50), capabilities: CapabilitiesSchema,
+    sources: z.array(SourceSchema).optional(),
+}).strict();
+const configuration = {
+    interval_sec: z.number(), watched_services: z.array(z.string()), nginx_enabled: z.boolean(),
+};
+export const WelcomeFrameSchema = z.object({
+    type: z.literal("welcome"), server_id: z.string(), connection_generation: z.number(), ...configuration,
+}).strict();
+export const ConfigFrameSchema = z.object({ type: z.literal("config"), ...configuration }).strict();
+export const LogsTailParamsSchema = z.object({ source_id: z.string(), lines: z.literal(LOG_LINES_OPTIONS) }).strict();
+export const ServiceStatusParamsSchema = z.object({ unit: z.string() }).strict();
+export const Pm2DescribeParamsSchema = z.object({ name: z.string() }).strict();
+export const NginxSourcesParamsSchema = z.object({}).strict();
+const request = { type: z.literal("request"), request_id: z.uuid() };
+export const RequestFrameSchema = z.discriminatedUnion("action", [
+    z.object({ ...request, action: z.literal("logs.tail"), params: LogsTailParamsSchema }).strict(),
+    z.object({ ...request, action: z.literal("service.status"), params: ServiceStatusParamsSchema }).strict(),
+    z.object({ ...request, action: z.literal("pm2.describe"), params: Pm2DescribeParamsSchema }).strict(),
+    z.object({ ...request, action: z.literal("nginx.sources"), params: NginxSourcesParamsSchema }).strict(),
+]);
+export const LogsTailPayloadSchema = z.object({
+    lines: z.array(z.string()), truncated: z.boolean(), bytes: z.number(), source_id: z.string(),
+}).strict();
+export const ServiceStatusPayloadSchema = ServiceSchema;
+export const Pm2DescribePayloadSchema = ProcessSchema;
+export const NginxSourcesPayloadSchema = z.object({ sources: z.array(SourceSchema) }).strict();
+export const ResponseErrorSchema = z.object({
+    code: z.enum(["not_found", "permission_denied", "unsupported", "timeout", "too_large", "internal"]),
+    message: z.string(),
+}).strict();
+export const SuccessResponseFrameSchema = z.object({
+    type: z.literal("response"), request_id: z.string(), ok: z.literal(true),
+    payload: z.union([LogsTailPayloadSchema, ServiceStatusPayloadSchema, Pm2DescribePayloadSchema, NginxSourcesPayloadSchema]),
+}).strict();
+export const ErrorResponseFrameSchema = z.object({
+    type: z.literal("response"), request_id: z.string(), ok: z.literal(false), error: ResponseErrorSchema,
+}).strict();
+export const ResponseFrameSchema = z.discriminatedUnion("ok", [SuccessResponseFrameSchema, ErrorResponseFrameSchema]);
+export const AgentFrameSchema = z.discriminatedUnion("type", [HelloFrameSchema, HeartbeatFrameSchema, ResponseFrameSchema]);
+export const GatewayFrameSchema = z.discriminatedUnion("type", [WelcomeFrameSchema, ConfigFrameSchema, RequestFrameSchema]);
+function parseFrame(text, schema) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return { ok: false, error };
+        throw error;
+    }
+    const result = schema.safeParse(value);
+    return result.success ? { ok: true, frame: result.data } : { ok: false, error: result.error };
+}
+export function parseAgentFrame(text) {
+    return parseFrame(text, AgentFrameSchema);
+}
+export function parseGatewayFrame(text) {
+    return parseFrame(text, GatewayFrameSchema);
+}

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@the-seeker/server-agent",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": { "theseeker-agent": "dist/cli.js" },
+  "engines": { "node": ">=20" },
+  "files": ["dist", "scripts", "README.md"],
+  "publishConfig": { "access": "public" },
+  "scripts": { "build": "tsc -p tsconfig.json", "test": "vitest run" },
+  "dependencies": { "systeminformation": "^5", "ws": "^8", "zod": "^4.4.3" },
+  "devDependencies": { "@types/node": "^20", "@types/ws": "^8", "typescript": "^5.9.3", "vitest": "^4.1.7" }
+}

package/scripts/install.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# The Seeker monitoring agent installer.
+#   TOKEN=sa_... [ENDPOINT=wss://ingest.theseeker.io/agent/ws] ./install.sh [--add-groups]
+set -euo pipefail
+
+TOKEN="${TOKEN:-}"
+ENDPOINT="${ENDPOINT:-wss://ingest.theseeker.io/agent/ws}"
+
+if [ -z "$TOKEN" ]; then
+  echo "TOKEN is required (TOKEN=sa_... ./install.sh)"
+  exit 1
+fi
+
+command -v node >/dev/null || { echo "Node.js 20+ required"; exit 1; }
+
+if [ "$(uname -s)" = "Darwin" ]; then
+  npm i -g @the-seeker/server-agent@latest
+  theseeker-agent install --token "$TOKEN" --endpoint "$ENDPOINT" --user "$USER" "$@"
+else
+  sudo npm i -g @the-seeker/server-agent@latest
+  sudo theseeker-agent install --token "$TOKEN" --endpoint "$ENDPOINT" --user "$USER" "$@"
+fi