@50arms/platform-mcp 0.0.0-stage → 0.1.436

package/dist/machine-daemon.js

@@ -0,0 +1,553 @@
+// src/machine-daemon/run.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+
+// ../machine-vitals/src/probes.ts
+import { statfsSync, readFileSync } from "node:fs";
+import { cpus as osCpus, freemem, totalmem, platform as osPlatform } from "node:os";
+import { execFileSync } from "node:child_process";
+function readDisk(path, statfs = statfsSync) {
+  const stats = statfs(path);
+  return {
+    free_disk_bytes: stats.bavail * stats.bsize,
+    total_disk_bytes: stats.blocks * stats.bsize
+  };
+}
+function readMemory(getFree = freemem, getTotal = totalmem) {
+  const total = getTotal();
+  const free = getFree();
+  return { mem_used_bytes: total - free, mem_total_bytes: total };
+}
+function sumCpuTotals(cpus) {
+  let busy = 0;
+  let total = 0;
+  for (const cpu of cpus) {
+    const cpuBusy = cpu.user + cpu.nice + cpu.sys + cpu.irq;
+    busy += cpuBusy;
+    total += cpuBusy + cpu.idle;
+  }
+  return { busy, total };
+}
+function osCpuTimes() {
+  return osCpus().map((c) => c.times);
+}
+function readCpuCores(getCpus = osCpuTimes) {
+  return getCpus().length;
+}
+var CpuBusyWindow = class {
+  constructor(windowMs = 5 * 6e4, getCpus = osCpuTimes, now = Date.now) {
+    this.windowMs = windowMs;
+    this.getCpus = getCpus;
+    this.now = now;
+  }
+  windowMs;
+  getCpus;
+  now;
+  samples = [];
+  sample() {
+    const at = this.now();
+    const totals = sumCpuTotals(this.getCpus());
+    this.samples.push({ at, ...totals });
+    while (this.samples.length > 2 && this.samples[1].at <= at - this.windowMs) {
+      this.samples.shift();
+    }
+    const first = this.samples[0];
+    const last = this.samples[this.samples.length - 1];
+    const deltaTotal = last.total - first.total;
+    if (this.samples.length < 2 || deltaTotal <= 0) return null;
+    const pct = (last.busy - first.busy) / deltaTotal * 100;
+    return Math.round(pct * 10) / 10;
+  }
+};
+function parseMeminfoSwap(meminfo) {
+  const field = (name) => {
+    const match = new RegExp(`^${name}:\\s+(\\d+)\\s+kB$`, "m").exec(meminfo);
+    if (!match) throw new Error(`readSwap: ${name} missing from /proc/meminfo`);
+    return Number(match[1]) * 1024;
+  };
+  const total = field("SwapTotal");
+  const free = field("SwapFree");
+  return { swap_total_bytes: total, swap_used_bytes: total - free };
+}
+function parsePageFileJson(json) {
+  const parsed = JSON.parse(json);
+  const rows = Array.isArray(parsed) ? parsed : [parsed];
+  let total = 0;
+  let used = 0;
+  for (const row of rows) {
+    if (typeof row !== "object" || row === null) {
+      throw new Error("readSwap: Win32_PageFileUsage row is not an object");
+    }
+    const r = row;
+    if (typeof r.AllocatedBaseSize !== "number" || typeof r.CurrentUsage !== "number") {
+      throw new Error("readSwap: Win32_PageFileUsage row lacks AllocatedBaseSize/CurrentUsage");
+    }
+    total += r.AllocatedBaseSize * 1024 * 1024;
+    used += r.CurrentUsage * 1024 * 1024;
+  }
+  return { swap_total_bytes: total, swap_used_bytes: used };
+}
+var PAGEFILE_SCRIPT = "Get-CimInstance Win32_PageFileUsage | Select-Object AllocatedBaseSize,CurrentUsage | ConvertTo-Json -Compress";
+function readSwap(deps = {}) {
+  const platform = deps.platform ?? osPlatform();
+  if (platform === "linux") {
+    return parseMeminfoSwap((deps.readFile ?? ((p) => readFileSync(p, "utf8")))("/proc/meminfo"));
+  }
+  if (platform === "win32") {
+    const run = deps.runPowerShell ?? ((script) => execFileSync(
+      "powershell.exe",
+      ["-NoProfile", "-NonInteractive", "-Command", script],
+      { encoding: "utf8", windowsHide: true }
+    ));
+    return parsePageFileJson(run(PAGEFILE_SCRIPT).trim() || "[]");
+  }
+  throw new Error(`readSwap: unsupported platform ${platform}`);
+}
+function createMachineVitalsCollector(deps) {
+  const getCpus = deps.getCpus ?? osCpuTimes;
+  const now = deps.now ?? Date.now;
+  const cpuWindow = new CpuBusyWindow(deps.cpuWindowMs ?? 5 * 6e4, getCpus, now);
+  return () => {
+    const disk = readDisk(deps.diskPath, deps.statfs);
+    const memory = readMemory(deps.getFree, deps.getTotal);
+    const swap = readSwap(deps.swap);
+    const cpu_busy_pct_5m = cpuWindow.sample();
+    return {
+      ...disk,
+      ...memory,
+      ...swap,
+      cpu_cores: readCpuCores(getCpus),
+      cpu_busy_pct_5m,
+      sampled_at: now()
+    };
+  };
+}
+
+// src/machine-daemon/autostart.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+var TASK_NAME = "danxbot-machine-daemon";
+var UNIT_NAME = "danxbot-machine-daemon.service";
+function runHidden(file, args) {
+  return execFileSync2(file, args, { encoding: "utf8", windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+}
+function disableAutostart(deps) {
+  if (deps.platform === "win32") {
+    deps.run("schtasks", ["/Change", "/TN", TASK_NAME, "/DISABLE"]);
+    return;
+  }
+  if (deps.platform === "linux") {
+    deps.run("systemctl", ["--user", "disable", UNIT_NAME]);
+    return;
+  }
+  throw new Error(`no start-at-logon entry for platform ${deps.platform}`);
+}
+
+// src/machine-daemon/beat.ts
+var BEAT_INTERVAL_MS = 6e4;
+function stopOnRefusal(deps) {
+  const onDisk = deps.readBearer();
+  if (onDisk !== null && onDisk !== deps.config.bearer) {
+    deps.log("install-daemon replaced this machine's reporting bearer: this process is the old bundle, so it exits and the start entry runs the new one.");
+    return { reason: "replaced" };
+  }
+  deps.log("the dashboard refused this machine's reporting bearer (HTTP 401): re-run install-daemon. The daemon has stopped beating.");
+  return { reason: "refused" };
+}
+async function postAsMachine(config, fetchFn, route, payload) {
+  try {
+    const res = await fetchFn(`${config.dashboard_url.replace(/\/+$/, "")}${route}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.bearer}` },
+      body: JSON.stringify({ machine_id: config.machine_id, ...payload })
+    });
+    return { status: res.status, error: res.status === 200 ? null : `HTTP ${res.status}`, text: await res.text() };
+  } catch (err) {
+    return { status: null, error: err instanceof Error ? err.message : String(err), text: "" };
+  }
+}
+async function sendBeat(deps, vitals) {
+  const { status, error } = await postAsMachine(deps.config, deps.fetchFn, "/api/machines/heartbeat", { vitals });
+  return { status, error };
+}
+async function runBeatLoop(deps) {
+  let ticks = 0;
+  for (; ; ) {
+    if (deps.maxTicks !== void 0 && ticks >= deps.maxTicks) return { reason: "ticks-exhausted" };
+    if (!deps.installed()) {
+      deps.log("the daemon's config is gone (uninstall-daemon removed it): stopping.");
+      return { reason: "uninstalled" };
+    }
+    ticks += 1;
+    const beatAt = deps.now();
+    let vitals = null;
+    let outcome;
+    try {
+      vitals = deps.collect();
+      outcome = await sendBeat(deps, vitals);
+    } catch (err) {
+      outcome = { status: null, error: `vitals: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const next = new Date(beatAt.getTime() + BEAT_INTERVAL_MS);
+    deps.writeStatus({
+      pid: deps.pid,
+      last_beat_at: beatAt.toISOString(),
+      last_beat_ok: outcome.status === 200,
+      last_error: outcome.error,
+      next_beat_at: next.toISOString()
+    });
+    if (outcome.status === 200) {
+      deps.log(`beat ok at ${beatAt.toISOString()}`);
+    } else if (outcome.status === 401) {
+      return stopOnRefusal(deps);
+    } else {
+      deps.log(`beat failed at ${beatAt.toISOString()}: ${outcome.error}; retrying on the next tick`);
+    }
+    if (deps.reporter.refused()) return stopOnRefusal(deps);
+    deps.reporter.tick(beatAt);
+    if (deps.maxTicks !== void 0 && ticks >= deps.maxTicks) return { reason: "ticks-exhausted" };
+    await deps.sleep(Math.max(0, next.getTime() - deps.now().getTime()));
+  }
+}
+
+// src/machine-toolkit/contract.ts
+var CONTRACT_VERSION = 2;
+var REQUIRED_METRICS = ["docker_data_disk_bytes", "unowned_docker_resource_count", "orphan_process_count"];
+var HEALTH_ITEM_LISTS = ["unowned_docker_resources", "orphan_processes"];
+var ContractViolation = class extends Error {
+  constructor(command, path, what) {
+    super(`${command} output does not match machine-toolkit contract v${CONTRACT_VERSION}: ${path} ${what}`);
+    this.name = "ContractViolation";
+  }
+};
+var isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var join = (path, key) => path === "" ? key : `${path}.${key}`;
+function objectAt(v, path, fail) {
+  if (!isObject(v)) return fail(path, "must be an object");
+  return v;
+}
+function exactKeys(o, path, keys, fail) {
+  for (const k of keys) if (!(k in o)) fail(join(path, k), "is required");
+  for (const k of Object.keys(o)) if (!keys.includes(k)) fail(join(path, k), "is not part of the contract");
+}
+function stringAt(o, key, path, fail) {
+  const v = o[key];
+  if (typeof v !== "string" || v === "") return fail(join(path, key), "must be a non-empty string");
+  return v;
+}
+function listAt(v, path, fail) {
+  if (!Array.isArray(v)) return fail(path, "must be a list");
+  return v;
+}
+function checkItem(v, path, extra, fail) {
+  const o = objectAt(v, path, fail);
+  exactKeys(o, path, ["id", "detail", ...extra], fail);
+  stringAt(o, "id", path, fail);
+  if (typeof o.detail !== "string") fail(join(path, "detail"), "must be a string");
+  for (const k of extra) stringAt(o, k, path, fail);
+}
+function checkItems(v, path, extra, fail) {
+  listAt(v, path, fail).forEach((item, i) => checkItem(item, `${path}[${i}]`, extra, fail));
+}
+function checkMetric(v, path, fail) {
+  const o = objectAt(v, path, fail);
+  exactKeys(o, path, ["value", "reason", "source", "age_seconds"], fail);
+  if (o.value === null) {
+    if (typeof o.reason !== "string" || o.reason === "") fail(`${path}.reason`, "must say why the value is null");
+  } else {
+    if (typeof o.value !== "number" || !Number.isFinite(o.value) || o.value < 0) fail(`${path}.value`, "must be null or a finite number of at least 0");
+    if (o.reason !== null) fail(`${path}.reason`, "must be null when the value was read");
+  }
+  if (o.source !== "fresh" && o.source !== "cached") fail(`${path}.source`, "must be 'fresh' or 'cached'");
+  if (typeof o.age_seconds !== "number" || !Number.isFinite(o.age_seconds) || o.age_seconds < 0) fail(`${path}.age_seconds`, "must be a number of at least 0");
+  if (o.source === "fresh" && o.age_seconds !== 0) fail(`${path}.age_seconds`, "must be 0 for a fresh reading");
+}
+function checkEnvelope(o, fail) {
+  if (o.contract_version !== CONTRACT_VERSION) fail("contract_version", `must be ${CONTRACT_VERSION}`);
+  stringAt(o, "toolkit_version", "", fail);
+  stringAt(o, "profile", "", fail);
+  const at = stringAt(o, "measured_at", "", fail);
+  if (Number.isNaN(new Date(at).getTime())) fail("measured_at", "must be an ISO time");
+}
+var ENVELOPE_KEYS = ["contract_version", "toolkit_version", "profile", "measured_at"];
+var VALIDATORS = {
+  health(o, fail) {
+    exactKeys(o, "", [...ENVELOPE_KEYS, "metrics", "items"], fail);
+    checkEnvelope(o, fail);
+    const metrics = objectAt(o.metrics, "metrics", fail);
+    for (const name of REQUIRED_METRICS) if (!(name in metrics)) fail(`metrics.${name}`, "is required");
+    for (const [name, metric] of Object.entries(metrics)) checkMetric(metric, `metrics.${name}`, fail);
+    const items = objectAt(o.items, "items", fail);
+    exactKeys(items, "items", HEALTH_ITEM_LISTS, fail);
+    for (const list of HEALTH_ITEM_LISTS) checkItems(items[list], `items.${list}`, [], fail);
+  },
+  sweep(o, fail) {
+    exactKeys(o, "", [...ENVELOPE_KEYS, "dry_run", "kinds"], fail);
+    checkEnvelope(o, fail);
+    if (typeof o.dry_run !== "boolean") fail("dry_run", "must be true or false");
+    listAt(o.kinds, "kinds", fail).forEach((k, i) => {
+      const path = `kinds[${i}]`;
+      const kind = objectAt(k, path, fail);
+      exactKeys(kind, path, ["kind", "removed", "kept", "failed", "flagged"], fail);
+      stringAt(kind, "kind", path, fail);
+      checkItems(kind.removed, `${path}.removed`, [], fail);
+      checkItems(kind.kept, `${path}.kept`, ["reason"], fail);
+      checkItems(kind.failed, `${path}.failed`, ["error"], fail);
+      checkItems(kind.flagged, `${path}.flagged`, ["reason"], fail);
+    });
+  },
+  maintain(o, fail) {
+    exactKeys(o, "", [...ENVELOPE_KEYS, "steps"], fail);
+    checkEnvelope(o, fail);
+    listAt(o.steps, "steps", fail).forEach((s, i) => {
+      const path = `steps[${i}]`;
+      const step = objectAt(s, path, fail);
+      exactKeys(step, path, ["name", "status", "detail"], fail);
+      stringAt(step, "name", path, fail);
+      if (step.status !== "done" && step.status !== "skipped" && step.status !== "failed") fail(`${path}.status`, "must be 'done', 'skipped' or 'failed'");
+      if (typeof step.detail !== "string") fail(join(path, "detail"), "must be a string");
+    });
+  },
+  "label-check"(o, fail) {
+    exactKeys(o, "", [...ENVELOPE_KEYS, "unowned", "malformed"], fail);
+    checkEnvelope(o, fail);
+    checkItems(o.unowned, "unowned", ["reason"], fail);
+    checkItems(o.malformed, "malformed", ["reason"], fail);
+  }
+};
+function assertContract(command, report) {
+  const fail = (path, what) => {
+    throw new ContractViolation(command, path === "" ? "(document)" : path, what);
+  };
+  VALIDATORS[command](objectAt(report, "", fail), fail);
+}
+
+// src/machine-toolkit/deadline.ts
+var realScheduler = (fire, ms) => {
+  const timer = setTimeout(fire, ms);
+  return () => clearTimeout(timer);
+};
+
+// src/machine-toolkit/errors.ts
+function errorCode(err) {
+  const failure = err;
+  if (typeof failure?.code === "string" || typeof failure?.code === "number") return String(failure.code);
+  return failure?.killed === true ? "timed out" : "unexpected error";
+}
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/machine-daemon/report.ts
+var REPORT_INTERVAL_MS = 5 * 60 * 1e3;
+var REPORT_TICK_TOLERANCE_MS = 1e3;
+var REPORT_TIMEOUT_MS = 3e4;
+function runHealthChild(opts) {
+  return new Promise((resolve) => {
+    const timeoutMs = opts.timeoutMs ?? REPORT_TIMEOUT_MS;
+    const schedule = opts.schedule ?? realScheduler;
+    let stdout = "";
+    let settled = false;
+    let cancel = () => {
+    };
+    const finish = (run) => {
+      if (settled) return;
+      settled = true;
+      cancel();
+      resolve(run);
+    };
+    const child = opts.spawnFn(opts.nodePath, [opts.toolkitPath, "health", "--json"], { windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
+    cancel = schedule(() => {
+      child.kill();
+      finish({ kind: "timed-out" });
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.on("error", (err) => finish({ kind: "failed", reason: errorCode(err) }));
+    child.on("close", (code) => finish({ kind: "exited", code, stdout }));
+  });
+}
+function reportPayload(run) {
+  if (run.kind === "timed-out") return { report_error: `health did not finish within ${REPORT_TIMEOUT_MS / 1e3} s: the machine is saturated` };
+  if (run.kind === "failed") return { report_error: `health could not start (${run.reason})` };
+  if (run.code !== 0 && run.code !== 2) return { report_error: `health exited ${run.code ?? "on a signal"}` };
+  let parsed;
+  try {
+    parsed = JSON.parse(run.stdout);
+  } catch {
+    return { report_error: "health printed output that is not JSON" };
+  }
+  try {
+    assertContract("health", parsed);
+  } catch (err) {
+    if (err instanceof ContractViolation) return { report_error: err.message };
+    throw err;
+  }
+  return { report: parsed };
+}
+function storedKind(text) {
+  try {
+    const { stored } = JSON.parse(text);
+    return stored === "report" || stored === "report_error" ? stored : null;
+  } catch {
+    return null;
+  }
+}
+function createReporter(deps) {
+  let lastStartMs = null;
+  let running = false;
+  let refused = false;
+  const run = async (startedAt) => {
+    const payload = reportPayload(await deps.runHealth());
+    const reportError = "report_error" in payload ? payload.report_error : null;
+    const sent = await postAsMachine(deps.config, deps.fetchFn, "/api/machines/report", payload);
+    let outcome;
+    let error = reportError ?? sent.error;
+    if (sent.status === 200) {
+      const stored = storedKind(sent.text);
+      if (stored === null) {
+        outcome = "failed";
+        error = "the dashboard answered 200 without saying what it stored";
+        deps.log(`report failed at ${startedAt.toISOString()}: ${error}`);
+      } else if (stored === "report_error" && reportError === null) {
+        outcome = "report-refused";
+        error = "the dashboard stored this report as a report error";
+        deps.log(`report refused at ${startedAt.toISOString()}: ${error}`);
+      } else {
+        outcome = reportError === null ? "sent" : "error-sent";
+        deps.log(reportError === null ? `report sent at ${startedAt.toISOString()}` : `report error sent at ${startedAt.toISOString()}: ${reportError}`);
+      }
+    } else if (sent.status === 429) {
+      outcome = "throttled";
+      deps.log("the dashboard refused this report as too soon (HTTP 429): the next due run tries again");
+    } else if (sent.status === 401) {
+      outcome = "refused";
+      refused = true;
+      deps.log("the dashboard refused this machine's reporting bearer on a report (HTTP 401)");
+    } else {
+      outcome = "failed";
+      deps.log(`report failed at ${startedAt.toISOString()}: ${sent.error}; the next due run tries again`);
+    }
+    if (deps.installed()) deps.writeStatus({ last_report_at: startedAt.toISOString(), last_report_outcome: outcome, last_report_error: error });
+  };
+  return {
+    tick(startedAt) {
+      if (lastStartMs !== null && startedAt.getTime() - lastStartMs < REPORT_INTERVAL_MS - REPORT_TICK_TOLERANCE_MS) return null;
+      if (running) {
+        deps.log("the last health report is still running: skipping this one");
+        return null;
+      }
+      lastStartMs = startedAt.getTime();
+      running = true;
+      return run(startedAt).catch((err) => deps.log(`report failed at ${startedAt.toISOString()}: ${errMessage(err)}; the next due run tries again`)).finally(() => {
+        running = false;
+      });
+    },
+    refused: () => refused
+  };
+}
+
+// src/machine-daemon/state.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join as join2 } from "node:path";
+var MACHINE_DAEMON_DIR_NAME = ".danxbot";
+function createStatusWriter(write) {
+  let current = {
+    pid: process.pid,
+    last_beat_at: null,
+    last_beat_ok: null,
+    last_error: null,
+    next_beat_at: null,
+    last_report_at: null,
+    last_report_outcome: null,
+    last_report_error: null
+  };
+  const merge = (fields) => {
+    current = { ...current, ...fields };
+    write(current);
+  };
+  return { beat: merge, report: merge };
+}
+function danxbotHome() {
+  return join2(homedir(), MACHINE_DAEMON_DIR_NAME);
+}
+function daemonConfigPath(home = danxbotHome()) {
+  return join2(home, "machine-daemon.json");
+}
+function daemonStatusPath(home = danxbotHome()) {
+  return join2(home, "machine-daemon-status.json");
+}
+function daemonBundleDir(home = danxbotHome()) {
+  return join2(home, "machine-daemon");
+}
+function toolkitBundlePath(home = danxbotHome()) {
+  return join2(daemonBundleDir(home), "machine-toolkit.js");
+}
+function writeOwnerOnlyJson(file, value) {
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  if (process.platform !== "win32") chmodSync(tmp, 384);
+  renameSync(tmp, file);
+}
+function readJsonIfPresent(file) {
+  if (!existsSync(file)) return null;
+  return JSON.parse(readFileSync2(file, "utf8"));
+}
+
+// src/machine-daemon/run.ts
+function finishBeatStop(stop, disable) {
+  if (stop.reason === "refused") disable();
+  return 0;
+}
+function readBearerOnDisk() {
+  try {
+    return readJsonIfPresent(daemonConfigPath())?.bearer ?? null;
+  } catch {
+    return null;
+  }
+}
+async function runDaemonProcess() {
+  const config = readJsonIfPresent(daemonConfigPath());
+  if (config === null) {
+    console.error("[machine-daemon] no config: run npx @50arms/platform-mcp install-daemon first");
+    return 2;
+  }
+  const fetchFn = fetch;
+  const now = () => /* @__PURE__ */ new Date();
+  const log = (line) => console.log(`[machine-daemon] ${line}`);
+  const status = createStatusWriter((value) => writeOwnerOnlyJson(daemonStatusPath(), value));
+  const stop = await runBeatLoop({
+    config,
+    collect: createMachineVitalsCollector({ diskPath: homedir2() }),
+    fetchFn,
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    now,
+    writeStatus: status.beat,
+    log,
+    pid: process.pid,
+    installed: () => existsSync2(daemonConfigPath()),
+    readBearer: readBearerOnDisk,
+    reporter: createReporter({
+      config,
+      runHealth: () => runHealthChild({ spawnFn: spawn, nodePath: process.execPath, toolkitPath: toolkitBundlePath() }),
+      fetchFn,
+      writeStatus: status.report,
+      log,
+      installed: () => existsSync2(daemonConfigPath())
+    })
+  });
+  return finishBeatStop(stop, () => disableAutostart({ platform: process.platform, run: runHidden }));
+}
+
+// src/machine-daemon/entry.ts
+runDaemonProcess().then(
+  (code) => process.exit(code),
+  (err) => {
+    console.error(`[machine-daemon] fatal: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+);