homeio

1import "server-only";
2
3import { randomUUID } from "node:crypto";
4import { readFile } from "node:fs/promises";
5import path from "node:path";
6import { eq, sql } from "drizzle-orm";
7import { db } from "@/lib/server/db/drizzle";
8import { settings } from "@/lib/server/db/schema";
9import { serverEnv } from "@/lib/server/env";
10import { logServerAction } from "@/lib/server/logging/logger";
11import { isContainerRuntime } from "@/lib/server/modules/system/update-service";
12import type {
13  TelemetryPingPayload,
14  TelemetrySettings,
15} from "@/lib/shared/contracts/telemetry";
16
17/** First ping waits for startup to settle, then one every 12 hours. */
18const FIRST_PING_DELAY_MS = 60_000;
19const PING_INTERVAL_MS = 12 * 60 * 60_000;
20const PING_TIMEOUT_MS = 10_000;
21
22let started = false;
23
24async function ensureSettingsRow() {
25  await db.execute(sql`
26    INSERT INTO settings (id, appearance_json, updated_at)
27    VALUES ('singleton', '{}', NOW())
28    ON CONFLICT (id) DO NOTHING
29  `);
30}
31
32async function readTelemetryRow() {
33  await ensureSettingsRow();
34
35  const rows = await db
36    .select({
37      enabled: settings.telemetryEnabled,
38      instanceId: settings.telemetryInstanceId,
39    })
40    .from(settings)
41    .where(eq(settings.id, "singleton"))
42    .limit(1);
43
44  return rows[0] ?? { enabled: true, instanceId: null };
45}
46
47/** The random ID this server reports under, created on first use. */
48async function resolveInstanceId(existing: string | null) {
49  if (existing) return existing;
50
51  const instanceId = randomUUID();
52  await db
53    .update(settings)
54    .set({ telemetryInstanceId: instanceId })
55    .where(eq(settings.id, "singleton"));
56  return instanceId;
57}
58
59async function readCurrentVersion() {
60  const raw = await readFile(path.join(process.cwd(), "package.json"), "utf8");
61  const parsed = JSON.parse(raw) as { version?: string };
62  return parsed.version?.trim() || "unknown";
63}
64
65const OS_RELEASE_PATH = "/etc/os-release";
66const DISTRO_ID = /^[a-z0-9._-]{1,32}$/;
67const DISTRO_VERSION = /^[0-9a-z._-]{1,16}$/i;
68
69/** ID and VERSION_ID from os-release text; anything unexpected becomes null. */
70export function parseOsRelease(text: string) {
71  const fields = new Map<string, string>();
72  for (const line of text.split("\n")) {
73    const match = line.match(/^([A-Z_]+)=(.*)$/);
74    if (match) fields.set(match[1], match[2].trim().replace(/^(["'])(.*)\1$/, "$2"));
75  }
76  const id = fields.get("ID")?.toLowerCase() ?? "";
77  const version = fields.get("VERSION_ID") ?? "";
78  return {
79    distro: DISTRO_ID.test(id) ? id : null,
80    distroVersion: DISTRO_ID.test(id) && DISTRO_VERSION.test(version) ? version : null,
81  };
82}
83
84async function readHostSystem(): Promise<Pick<TelemetryPingPayload, "install" | "distro" | "distroVersion">> {
85  // Inside a container, os-release describes the image, not the host.
86  if (isContainerRuntime()) return { install: "docker", distro: null, distroVersion: null };
87  try {
88    return { install: "host", ...parseOsRelease(await readFile(OS_RELEASE_PATH, "utf8")) };
89  } catch {
90    return { install: "host", distro: null, distroVersion: null };
91  }
92}
93
94export async function getTelemetrySettings(): Promise<TelemetrySettings> {
95  const row = await readTelemetryRow();
96  const disabledByEnv = !serverEnv.HOMEIO_TELEMETRY;
97  return {
98    enabled: row.enabled && !disabledByEnv,
99    disabledByEnv,
100  };
101}
102
103export async function setTelemetryEnabled(enabled: boolean) {
104  await ensureSettingsRow();
105  await db
106    .update(settings)
107    .set({ telemetryEnabled: enabled, updatedAt: new Date() })
108    .where(eq(settings.id, "singleton"));
109}
110
111export function buildTelemetryPayload(
112  instanceId: string,
113  version: string,
114  system: Pick<TelemetryPingPayload, "install" | "distro" | "distroVersion">,
115): TelemetryPingPayload {
116  return {
117    instanceId,
118    version,
119    arch: process.arch,
120    platform: process.platform,
121    ...system,
122  };
123}
124
125function telemetryAllowedByEnv() {
126  return (
127    serverEnv.HOMEIO_TELEMETRY &&
128    !serverEnv.DEMO_MODE &&
129    serverEnv.NODE_ENV === "production"
130  );
131}
132
133/**
134 * Report this server to homeio.app/stats. Best-effort: a failed ping is
135 * logged at debug level and never surfaces to the user.
136 */
137export async function sendTelemetryPing(fetchImpl: typeof fetch = fetch) {
138  if (!telemetryAllowedByEnv()) return false;
139
140  try {
141    const row = await readTelemetryRow();
142    if (!row.enabled) return false;
143
144    const payload = buildTelemetryPayload(
145      await resolveInstanceId(row.instanceId),
146      await readCurrentVersion(),
147      await readHostSystem(),
148    );
149
150    const response = await fetchImpl(serverEnv.HOMEIO_TELEMETRY_URL, {
151      method: "POST",
152      headers: { "Content-Type": "application/json" },
153      body: JSON.stringify(payload),
154      signal: AbortSignal.timeout(PING_TIMEOUT_MS),
155    });
156
157    if (!response.ok) {
158      throw new Error(`Stats endpoint answered ${response.status}`);
159    }
160    return true;
161  } catch (error) {
162    logServerAction({
163      level: "debug",
164      layer: "service",
165      action: "telemetry.ping",
166      status: "error",
167      message: "Anonymous stats ping failed",
168      error,
169    });
170    return false;
171  }
172}
173
174export function startTelemetry() {
175  if (started || !telemetryAllowedByEnv()) return;
176  started = true;
177
178  setTimeout(() => void sendTelemetryPing(), FIRST_PING_DELAY_MS).unref();
179  setInterval(() => void sendTelemetryPing(), PING_INTERVAL_MS).unref();
180}
181