homeio

1import "server-only";
2
3import net from "node:net";
4import { serverEnv } from "@/lib/server/env";
5import { logServerAction } from "@/lib/server/logging/logger";
6import type {
7  ConnectNetworkRequest,
8  NetworkEvent,
9  NetworkServiceErrorCode,
10  NetworkStatus,
11  WifiAccessPoint,
12} from "@/lib/shared/contracts/network";
13
14type HelperRequest = {
15  id: string;
16  method: string;
17  params?: unknown;
18  requestId?: string;
19};
20
21type HelperErrorPayload = {
22  code?: NetworkServiceErrorCode;
23  message?: string;
24};
25
26type HelperResponse = {
27  id?: string;
28  ok?: boolean;
29  result?: unknown;
30  error?: HelperErrorPayload;
31  type?: string;
32  event?: NetworkEvent;
33};
34
35type HelperCallOptions = {
36  requestId?: string;
37  timeoutMs?: number;
38};
39
40type HelperEventSubscriptionOptions = {
41  requestId?: string;
42  onError?: (error: unknown) => void;
43};
44
45const DEFAULT_TIMEOUT_MS = 8_000;
46const HELPER_UNAVAILABLE_BACKOFF_MS = 10_000;
47let helperUnavailableUntil = 0;
48
49function parseNetworkServiceErrorCode(value: unknown): NetworkServiceErrorCode {
50  if (
51    value === "helper_unavailable" ||
52    value === "network_manager_unavailable" ||
53    value === "auth_failed" ||
54    value === "timeout" ||
55    value === "invalid_request" ||
56    value === "internal_error"
57  ) {
58    return value;
59  }
60
61  return "internal_error";
62}
63
64export class NetworkHelperError extends Error {
65  readonly code: NetworkServiceErrorCode;
66  readonly statusCode: number;
67
68  constructor(
69    message: string,
70    options?: {
71      code?: NetworkServiceErrorCode;
72      statusCode?: number;
73      cause?: unknown;
74    },
75  ) {
76    super(message, {
77      cause: options?.cause,
78    });
79    this.name = "NetworkHelperError";
80    this.code = options?.code ?? "internal_error";
81    this.statusCode = options?.statusCode ?? 500;
82  }
83}
84
85function mapSocketError(error: unknown) {
86  if (!(error instanceof Error)) {
87    return new NetworkHelperError("DBus helper request failed");
88  }
89
90  const nodeError = error as NodeJS.ErrnoException;
91  const code = nodeError.code ?? "";
92  if (code === "ENOENT" || code === "ECONNREFUSED") {
93    return new NetworkHelperError("DBus helper unavailable", {
94      code: "helper_unavailable",
95      statusCode: 503,
96      cause: error,
97    });
98  }
99
100  if (code === "ETIMEDOUT") {
101    return new NetworkHelperError("DBus helper timeout", {
102      code: "timeout",
103      statusCode: 504,
104      cause: error,
105    });
106  }
107
108  return new NetworkHelperError(error.message, {
109    cause: error,
110  });
111}
112
113function parseJsonLine(line: string): HelperResponse | null {
114  try {
115    const parsed = JSON.parse(line) as unknown;
116    if (!parsed || typeof parsed !== "object") return null;
117    return parsed as HelperResponse;
118  } catch {
119    return null;
120  }
121}
122
123async function callHelper<T>(
124  method: string,
125  params: unknown,
126  options?: HelperCallOptions,
127) {
128  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
129  const requestId = options?.requestId;
130  const callId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
131  if (Date.now() < helperUnavailableUntil) {
132    throw new NetworkHelperError("DBus helper unavailable", {
133      code: "helper_unavailable",
134      statusCode: 503,
135    });
136  }
137
138  const startedAt = performance.now();
139
140  try {
141    const result = await new Promise<T>((resolve, reject) => {
142      const socket = net.createConnection({
143        path: serverEnv.DBUS_HELPER_SOCKET_PATH,
144      });
145      let settled = false;
146      let buffer = "";
147
148      const request: HelperRequest = {
149        id: callId,
150        method,
151        params,
152        requestId,
153      };
154
155      const timeout = setTimeout(() => {
156        if (settled) return;
157        settled = true;
158        socket.destroy();
159        reject(
160          new NetworkHelperError("DBus helper timeout", {
161            code: "timeout",
162            statusCode: 504,
163          }),
164        );
165      }, timeoutMs);
166
167      const finalize = (fn: () => void) => {
168        if (settled) return;
169        settled = true;
170        clearTimeout(timeout);
171        socket.end();
172        fn();
173      };
174
175      socket.on("connect", () => {
176        socket.write(`${JSON.stringify(request)}\n`);
177      });
178
179      socket.on("data", (chunk) => {
180        buffer += chunk.toString("utf8");
181        let newline = buffer.indexOf("\n");
182
183        while (newline >= 0) {
184          const line = buffer.slice(0, newline).trim();
185          buffer = buffer.slice(newline + 1);
186          newline = buffer.indexOf("\n");
187
188          if (!line) continue;
189          const message = parseJsonLine(line);
190          if (!message) continue;
191          if (message.type === "event") continue;
192          if (message.id !== callId) continue;
193
194          if (!message.ok) {
195            const helperCode = parseNetworkServiceErrorCode(message.error?.code);
196            const statusCode =
197              helperCode === "auth_failed"
198                ? 401
199                : helperCode === "helper_unavailable"
200                  ? 503
201                  : helperCode === "network_manager_unavailable"
202                    ? 503
203                    : helperCode === "timeout"
204                      ? 504
205                      : helperCode === "invalid_request"
206                        ? 400
207                        : 500;
208
209            finalize(() =>
210              reject(
211                new NetworkHelperError(
212                  message.error?.message ?? "DBus helper request failed",
213                  {
214                    code: helperCode,
215                    statusCode,
216                  },
217                ),
218              ),
219            );
220            return;
221          }
222
223          finalize(() => resolve(message.result as T));
224          return;
225        }
226      });
227
228      socket.on("error", (error) => {
229        finalize(() => reject(mapSocketError(error)));
230      });
231
232      socket.on("close", () => {
233        if (settled) return;
234        settled = true;
235        clearTimeout(timeout);
236        reject(
237          new NetworkHelperError("DBus helper closed before response", {
238            code: "helper_unavailable",
239            statusCode: 503,
240          }),
241        );
242      });
243    });
244
245    helperUnavailableUntil = 0;
246    return result;
247  } catch (error) {
248    const mapped =
249      error instanceof NetworkHelperError ? error : mapSocketError(error);
250
251    if (
252      mapped.code === "helper_unavailable" ||
253      mapped.code === "timeout" ||
254      mapped.code === "network_manager_unavailable"
255    ) {
256      helperUnavailableUntil = Math.max(
257        helperUnavailableUntil,
258        Date.now() + HELPER_UNAVAILABLE_BACKOFF_MS,
259      );
260      logServerAction({
261        level: "warn",
262        layer: "system",
263        action: "dbus.network.call",
264        status: "error",
265        requestId,
266        durationMs: Number((performance.now() - startedAt).toFixed(2)),
267        message: mapped.message,
268        meta: {
269          method,
270          timeoutMs,
271        },
272        error: mapped,
273      });
274    } else {
275      logServerAction({
276        level: "error",
277        layer: "system",
278        action: "dbus.network.call",
279        status: "error",
280        requestId,
281        durationMs: Number((performance.now() - startedAt).toFixed(2)),
282        message: mapped.message,
283        meta: {
284          method,
285          timeoutMs,
286        },
287        error: mapped,
288      });
289    }
290
291    throw mapped;
292  }
293}
294
295export function isNetworkHelperUnavailableError(error: unknown) {
296  return error instanceof NetworkHelperError && error.code === "helper_unavailable";
297}
298
299export async function getNetworkStatusFromHelper(options?: HelperCallOptions) {
300  return callHelper<NetworkStatus>("network.getStatus", {}, options);
301}
302
303export async function scanWifiNetworksFromHelper(options?: HelperCallOptions) {
304  return callHelper<WifiAccessPoint[]>("network.scan", {}, options);
305}
306
307export async function connectWifiFromHelper(
308  input: ConnectNetworkRequest,
309  options?: HelperCallOptions,
310) {
311  return callHelper<NetworkStatus>("network.connect", input, options);
312}
313
314export async function disconnectWifiFromHelper(
315  input: { iface?: string },
316  options?: HelperCallOptions,
317) {
318  return callHelper<NetworkStatus>("network.disconnect", input, options);
319}
320
321export function subscribeToHelperEvents(
322  onEvent: (event: NetworkEvent) => void,
323  options?: HelperEventSubscriptionOptions,
324) {
325  const socket = net.createConnection({
326    path: serverEnv.DBUS_HELPER_SOCKET_PATH,
327  });
328  let buffer = "";
329
330  socket.on("data", (chunk) => {
331    buffer += chunk.toString("utf8");
332    let newline = buffer.indexOf("\n");
333
334    while (newline >= 0) {
335      const line = buffer.slice(0, newline).trim();
336      buffer = buffer.slice(newline + 1);
337      newline = buffer.indexOf("\n");
338
339      if (!line) continue;
340      const message = parseJsonLine(line);
341      if (!message || message.type !== "event" || !message.event) continue;
342      onEvent(message.event);
343    }
344  });
345
346  socket.on("error", (error) => {
347    if (options?.onError) {
348      options.onError(mapSocketError(error));
349    }
350  });
351
352  socket.on("close", () => {
353    if (options?.onError) {
354      options.onError(
355        new NetworkHelperError("DBus helper event stream closed", {
356          code: "helper_unavailable",
357          statusCode: 503,
358        }),
359      );
360    }
361  });
362
363  return () => {
364    socket.destroy();
365  };
366}
367