homeio

1#!/usr/bin/env node
2
3import process from "node:process";
4import net from "node:net";
5import { parseRpcRequest, toErrorPayload } from "./protocol.mjs";
6import { SOCKET_GROUP, SOCKET_PATH } from "./config.mjs";
7import { log } from "./logger.mjs";
8import { HelperServiceError, toCodeFromError } from "./errors.mjs";
9import { ensureSocketDirectory, ensureSocketPermissions, safeUnlink } from "./socket-fs.mjs";
10import { withTimeout } from "./async-utils.mjs";
11import { createNetworkService, decodeSsid } from "./network-service.mjs";
12
13const activeSockets = new Set();
14let helperServer = null;
15
16const networkService = createNetworkService({ log });
17const {
18  attachDbusEventBridge,
19  connectNetwork,
20  disconnectNetwork,
21  getNetworkStatus,
22  scanNetworks,
23} = networkService;
24
25function broadcastEvent(event) {
26  const payload = `${JSON.stringify({
27    type: "event",
28    event,
29  })}\n`;
30
31  for (const socket of activeSockets) {
32    if (!socket.writable) continue;
33    socket.write(payload);
34  }
35}
36
37async function handleRpcRequest(request) {
38  if (request.method === "network.getStatus") {
39    return withTimeout(getNetworkStatus());
40  }
41
42  if (request.method === "network.scan") {
43    return withTimeout(scanNetworks(), 15_000);
44  }
45
46  if (request.method === "network.connect") {
47    return withTimeout(connectNetwork(request.params, request.requestId), 20_000);
48  }
49
50  if (request.method === "network.disconnect") {
51    return withTimeout(disconnectNetwork(request.params), 10_000);
52  }
53
54  throw new HelperServiceError("Method not allowed", {
55    code: "invalid_request",
56    statusCode: 400,
57  });
58}
59
60async function start() {
61  await ensureSocketDirectory(SOCKET_PATH, SOCKET_GROUP);
62  await safeUnlink(SOCKET_PATH);
63
64  helperServer = net.createServer((socket) => {
65    activeSockets.add(socket);
66    let buffer = "";
67
68    socket.on("data", (chunk) => {
69      buffer += chunk.toString("utf8");
70      let newline = buffer.indexOf("\n");
71
72      while (newline >= 0) {
73        const line = buffer.slice(0, newline).trim();
74        buffer = buffer.slice(newline + 1);
75        newline = buffer.indexOf("\n");
76
77        if (!line) continue;
78
79        let parsedRequest = null;
80        try {
81          parsedRequest = parseRpcRequest(line);
82        } catch (error) {
83          const helperError = toCodeFromError(error);
84          socket.write(
85            `${JSON.stringify({
86              id: null,
87              ok: false,
88              error: {
89                code: helperError.code,
90                message: helperError.message,
91              },
92            })}\n`,
93          );
94          continue;
95        }
96
97        const startedAt = performance.now();
98        log({
99          action: "dbus.network.rpc",
100          status: "start",
101          requestId: parsedRequest.requestId ?? parsedRequest.id,
102          meta: {
103            method: parsedRequest.method,
104          },
105        });
106
107        void handleRpcRequest(parsedRequest)
108          .then((result) => {
109            socket.write(
110              `${JSON.stringify({
111                id: parsedRequest.id,
112                ok: true,
113                result,
114              })}\n`,
115            );
116
117            log({
118              action: "dbus.network.rpc",
119              status: "success",
120              requestId: parsedRequest.requestId ?? parsedRequest.id,
121              durationMs: Number((performance.now() - startedAt).toFixed(2)),
122              meta: {
123                method: parsedRequest.method,
124              },
125            });
126          })
127          .catch((error) => {
128            const helperError = toCodeFromError(error);
129            socket.write(
130              `${JSON.stringify({
131                id: parsedRequest.id,
132                ok: false,
133                error: toErrorPayload(helperError),
134              })}\n`,
135            );
136
137            log({
138              level: helperError.statusCode >= 500 ? "error" : "warn",
139              action: "dbus.network.rpc",
140              status: "error",
141              requestId: parsedRequest.requestId ?? parsedRequest.id,
142              durationMs: Number((performance.now() - startedAt).toFixed(2)),
143              meta: {
144                method: parsedRequest.method,
145              },
146              error: helperError,
147            });
148          });
149      }
150    });
151
152    socket.on("error", (error) => {
153      log({
154        level: "warn",
155        action: "dbus.network.socket",
156        status: "error",
157        message: "Client socket error",
158        error,
159      });
160    });
161
162    socket.on("close", () => {
163      activeSockets.delete(socket);
164    });
165  });
166
167  await new Promise((resolve, reject) => {
168    helperServer.once("error", reject);
169    helperServer.listen(SOCKET_PATH, resolve);
170  });
171
172  await ensureSocketPermissions(SOCKET_PATH, SOCKET_GROUP);
173
174  log({
175    action: "dbus.network.helper.start",
176    status: "success",
177    meta: {
178      socketPath: SOCKET_PATH,
179      socketGroup: SOCKET_GROUP,
180    },
181  });
182
183  attachDbusEventBridge(broadcastEvent).catch((error) => {
184    const mapped = toCodeFromError(error);
185    log({
186      level: "warn",
187      action: "dbus.network.events.start",
188      status: "error",
189      message: "DBus event bridge failed to start; helper will continue without events",
190      error: mapped,
191    });
192  });
193}
194
195async function shutdown(signal) {
196  log({
197    action: "dbus.network.helper.stop",
198    status: "start",
199    message: `Received ${signal}, shutting down helper`,
200  });
201
202  if (helperServer) {
203    await new Promise((resolve) => {
204      helperServer.close(() => resolve(undefined));
205    });
206  }
207
208  await safeUnlink(SOCKET_PATH);
209  process.exit(0);
210}
211
212process.on("SIGINT", () => {
213  void shutdown("SIGINT");
214});
215
216process.on("SIGTERM", () => {
217  void shutdown("SIGTERM");
218});
219
220start().catch((error) => {
221  const mapped = toCodeFromError(error);
222  log({
223    level: "error",
224    action: "dbus.network.helper.start",
225    status: "error",
226    message: "Failed to start DBus helper",
227    error: mapped,
228  });
229  process.exit(1);
230});
231
232export {
233  HelperServiceError,
234  connectNetwork,
235  decodeSsid,
236  disconnectNetwork,
237  getNetworkStatus,
238  scanNetworks,
239  toCodeFromError,
240};
241