homeio

1import { chmod, mkdtemp, mkdir, readFile, writeFile } from "node:fs/promises";
2import os from "node:os";
3import path from "node:path";
4import { beforeEach, describe, expect, it, vi } from "vitest";
5
6const { execFileMock } = vi.hoisted(() => ({
7  execFileMock: vi.fn(),
8}));
9
10vi.mock("node:child_process", () => ({
11  execFile: execFileMock,
12}));
13
14import {
15  getSystemPreferences,
16  resetPreferencesCacheForTests,
17  updateSystemPreferences,
18} from "@/lib/server/modules/system/preferences-service";
19
20function resolveExecFileCallback(args: unknown[]) {
21  const maybeCallback = args.at(-1);
22  if (typeof maybeCallback !== "function") {
23    throw new Error("Expected execFile callback");
24  }
25
26  return maybeCallback as (error: Error | null, stdout?: string, stderr?: string) => void;
27}
28
29describe("preferences-service", () => {
30  beforeEach(async () => {
31    execFileMock.mockReset();
32    resetPreferencesCacheForTests();
33    const root = await mkdtemp(path.join(os.tmpdir(), "homeio-preferences-"));
34    const timezonePath = path.join(root, "timezone");
35    const hostsPath = path.join(root, "hosts");
36
37    await mkdir(path.dirname(hostsPath), { recursive: true });
38    await writeFile(timezonePath, "Etc/UTC\n", "utf8");
39    await writeFile(hostsPath, "127.0.0.1 localhost\n127.0.1.1 homeio homeio.local\n", "utf8");
40
41    process.env.HOMEIO_TIMEZONE_FILE_PATH = timezonePath;
42    process.env.HOMEIO_HOSTS_FILE_PATH = hostsPath;
43  });
44
45  it("reads the host once for repeated Settings loads, and shows a saved change at once", async () => {
46    let currentHostname = "homeio";
47    execFileMock.mockImplementation((command: string, args: string[], ...rest: unknown[]) => {
48      const callback = resolveExecFileCallback(rest);
49      if (command === "hostnamectl" && args[0] === "set-hostname") currentHostname = args[1] ?? currentHostname;
50      if (command === "hostnamectl" && args[0] === "--static") return callback(null, `${currentHostname}\n`, "");
51      if (command === "timedatectl" && args[0] === "show") return callback(null, "Etc/UTC\n", "");
52      callback(null, "", "");
53    });
54    const hostnameReads = () =>
55      execFileMock.mock.calls.filter(([command, args]) => command === "hostnamectl" && args[0] === "--static").length;
56
57    await getSystemPreferences();
58    await getSystemPreferences();
59    expect(hostnameReads()).toBe(1);
60
61    await updateSystemPreferences({ hostname: "nas", timezone: "Etc/UTC" });
62    expect(await getSystemPreferences()).toEqual({ hostname: "nas", timezone: "Etc/UTC" });
63  });
64
65  it("restarts avahi after hostname changes and rewrites the hosts file", async () => {
66    let currentHostname = "homeio";
67    const calls: Array<{ command: string; args: string[] }> = [];
68
69    execFileMock.mockImplementation((command: string, args: string[], ...rest: unknown[]) => {
70      calls.push({ command, args });
71      const callback = resolveExecFileCallback(rest);
72
73      if (command === "hostnamectl" && args[0] === "--static") {
74        callback(null, `${currentHostname}\n`, "");
75        return;
76      }
77
78      if (command === "hostname") {
79        callback(null, `${currentHostname}\n`, "");
80        return;
81      }
82
83      if (command === "timedatectl" && args[0] === "show") {
84        callback(null, "Etc/UTC\n", "");
85        return;
86      }
87
88      if (command === "hostnamectl" && args[0] === "set-hostname") {
89        currentHostname = args[1] ?? currentHostname;
90        callback(null, "", "");
91        return;
92      }
93
94      if (command === "systemctl" && args[0] === "restart") {
95        callback(null, "", "");
96        return;
97      }
98
99      callback(null, "", "");
100    });
101
102    const preferences = await updateSystemPreferences({
103      hostname: "homeai",
104      timezone: "Etc/UTC",
105    });
106
107    expect(preferences.hostname).toBe("homeai");
108    expect(calls).toEqual(
109      expect.arrayContaining([
110        { command: "hostnamectl", args: ["set-hostname", "homeai"] },
111        { command: "systemctl", args: ["restart", "avahi-daemon"] },
112      ]),
113    );
114
115    const hostsContent = await readFile(process.env.HOMEIO_HOSTS_FILE_PATH!, "utf8");
116    expect(hostsContent).toContain("127.0.1.1 homeai homeai.local");
117  });
118
119  it("falls back to the hostname command when hostnamectl is unavailable", async () => {
120    let currentHostname = "homeio";
121    const calls: Array<{ command: string; args: string[] }> = [];
122
123    execFileMock.mockImplementation((command: string, args: string[], ...rest: unknown[]) => {
124      calls.push({ command, args });
125      const callback = resolveExecFileCallback(rest);
126
127      if (command === "hostnamectl" && args[0] === "--static") {
128        const error = Object.assign(new Error("spawn hostnamectl ENOENT"), { code: "ENOENT" });
129        callback(error as Error, "", "");
130        return;
131      }
132
133      if (command === "hostname" && args.length === 0) {
134        callback(null, `${currentHostname}\n`, "");
135        return;
136      }
137
138      if (command === "hostname" && args.length === 1) {
139        currentHostname = args[0] ?? currentHostname;
140        callback(null, "", "");
141        return;
142      }
143
144      if (command === "timedatectl" && args[0] === "show") {
145        callback(null, "Etc/UTC\n", "");
146        return;
147      }
148
149      if (command === "hostnamectl" && args[0] === "set-hostname") {
150        const error = Object.assign(new Error("spawn hostnamectl ENOENT"), { code: "ENOENT" });
151        callback(error as Error, "", "");
152        return;
153      }
154
155      if (command === "systemctl" && args[0] === "restart") {
156        callback(null, "", "");
157        return;
158      }
159
160      callback(null, "", "");
161    });
162
163    const preferences = await updateSystemPreferences({
164      hostname: "homeai",
165      timezone: "Etc/UTC",
166    });
167
168    expect(preferences.hostname).toBe("homeai");
169    expect(calls).toEqual(
170      expect.arrayContaining([{ command: "hostname", args: ["homeai"] }]),
171    );
172  });
173
174  it("skips system hostname change when container lacks SYS_ADMIN but still updates hosts file", async () => {
175    execFileMock.mockImplementation((command: string, args: string[], ...rest: unknown[]) => {
176      const callback = resolveExecFileCallback(rest);
177
178      if (command === "hostnamectl" && args[0] === "--static") {
179        const error = Object.assign(new Error("spawn hostnamectl ENOENT"), { code: "ENOENT" });
180        callback(error as Error, "", "");
181        return;
182      }
183
184      if (command === "hostname" && args.length === 0) {
185        callback(null, "homeio\n", "");
186        return;
187      }
188
189      if (command === "hostname" && args.length === 1) {
190        const error = new Error("Command failed: hostname homeio\nhostname: sethostname: Operation not permitted");
191        callback(error, "", "");
192        return;
193      }
194
195      if (command === "timedatectl" && args[0] === "show") {
196        callback(null, "Etc/UTC\n", "");
197        return;
198      }
199
200      if (command === "systemctl" && args[0] === "restart") {
201        callback(null, "", "");
202        return;
203      }
204
205      callback(null, "", "");
206    });
207
208    await updateSystemPreferences({ hostname: "homeai", timezone: "Etc/UTC" });
209
210    const hostsContent = await readFile(process.env.HOMEIO_HOSTS_FILE_PATH!, "utf8");
211    expect(hostsContent).toContain("127.0.1.1 homeai homeai.local");
212  });
213
214  it("falls back to writing the timezone file when timedatectl is unavailable", async () => {
215    execFileMock.mockImplementation((command: string, args: string[], ...rest: unknown[]) => {
216      const callback = resolveExecFileCallback(rest);
217
218      if (command === "hostnamectl" && args[0] === "--static") {
219        callback(null, "homeio\n", "");
220        return;
221      }
222
223      if (command === "timedatectl" && args[0] === "show") {
224        callback(null, "Etc/UTC\n", "");
225        return;
226      }
227
228      if (command === "timedatectl" && args[0] === "set-timezone") {
229        const error = Object.assign(new Error("spawn timedatectl ENOENT"), { code: "ENOENT" });
230        callback(error as Error, "", "");
231        return;
232      }
233
234      callback(null, "", "");
235    });
236
237    await updateSystemPreferences({
238      hostname: "homeio",
239      timezone: "Europe/Paris",
240    });
241
242    const timezoneContent = await readFile(process.env.HOMEIO_TIMEZONE_FILE_PATH!, "utf8");
243    expect(timezoneContent.trim()).toBe("Europe/Paris");
244  });
245
246  it("does not fail when the timezone file is root-owned and cannot be written", async () => {
247    const readonlyRoot = await mkdtemp(path.join(os.tmpdir(), "homeio-readonly-"));
248    process.env.HOMEIO_TIMEZONE_FILE_PATH = path.join(readonlyRoot, "timezone");
249    await chmod(readonlyRoot, 0o444);
250
251    try {
252      execFileMock.mockImplementation((command: string, args: string[], ...rest: unknown[]) => {
253        const callback = resolveExecFileCallback(rest);
254
255        if (command === "hostnamectl" && args[0] === "--static") {
256          callback(null, "homeio\n", "");
257          return;
258        }
259
260        if (command === "timedatectl" && args[0] === "show") {
261          callback(null, "Etc/UTC\n", "");
262          return;
263        }
264
265        if (command === "timedatectl" && args[0] === "set-timezone") {
266          const error = Object.assign(new Error("spawn timedatectl ENOENT"), { code: "ENOENT" });
267          callback(error as Error, "", "");
268          return;
269        }
270
271        callback(null, "", "");
272      });
273
274      await expect(
275        updateSystemPreferences({ hostname: "homeio", timezone: "Europe/Paris" }),
276      ).resolves.not.toThrow();
277    } finally {
278      await chmod(readonlyRoot, 0o755);
279    }
280  });
281
282  it("does not fail the hostname update when avahi-daemon is unavailable", async () => {
283    let currentHostname = "homeio";
284
285    execFileMock.mockImplementation((command: string, args: string[], ...rest: unknown[]) => {
286      const callback = resolveExecFileCallback(rest);
287
288      if (command === "hostnamectl" && args[0] === "--static") {
289        callback(null, `${currentHostname}\n`, "");
290        return;
291      }
292
293      if (command === "hostname") {
294        callback(null, `${currentHostname}\n`, "");
295        return;
296      }
297
298      if (command === "timedatectl" && args[0] === "show") {
299        callback(null, "Etc/UTC\n", "");
300        return;
301      }
302
303      if (command === "hostnamectl" && args[0] === "set-hostname") {
304        currentHostname = args[1] ?? currentHostname;
305        callback(null, "", "");
306        return;
307      }
308
309      if (command === "systemctl" && args[0] === "restart") {
310        const error = new Error("Unit avahi-daemon.service could not be found.") as Error & {
311          stdout?: string;
312          stderr?: string;
313        };
314        error.stderr = "Unit avahi-daemon.service could not be found.";
315        callback(error, "", "Unit avahi-daemon.service could not be found.");
316        return;
317      }
318
319      callback(null, "", "");
320    });
321
322    const preferences = await updateSystemPreferences({
323      hostname: "homeai",
324      timezone: "Etc/UTC",
325    });
326
327    expect(preferences.hostname).toBe("homeai");
328    const hostsContent = await readFile(process.env.HOMEIO_HOSTS_FILE_PATH!, "utf8");
329    expect(hostsContent).toContain("127.0.1.1 homeai homeai.local");
330  });
331});
332