homeio

1const ALLOWED_METHODS = new Set([
2  "network.getStatus",
3  "network.scan",
4  "network.connect",
5  "network.disconnect",
6]);
7
8class HelperProtocolError extends Error {
9  constructor(message, options = {}) {
10    super(message, {
11      cause: options.cause,
12    });
13    this.name = "HelperProtocolError";
14    this.code = options.code ?? "invalid_request";
15    this.statusCode = options.statusCode ?? 400;
16  }
17}
18
19function isRecord(value) {
20  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
21}
22
23function asOptionalString(value) {
24  if (typeof value !== "string") return null;
25  const trimmed = value.trim();
26  return trimmed.length > 0 ? trimmed : null;
27}
28
29function validateConnectParams(params) {
30  if (!isRecord(params)) {
31    throw new HelperProtocolError("Invalid connect parameters");
32  }
33
34  const ssid = asOptionalString(params.ssid);
35  if (!ssid || ssid.length > 128) {
36    throw new HelperProtocolError("Invalid ssid");
37  }
38
39  const password = params.password;
40  if (password !== undefined && (typeof password !== "string" || password.length < 1 || password.length > 128)) {
41    throw new HelperProtocolError("Invalid password");
42  }
43
44  return {
45    ssid,
46    password,
47  };
48}
49
50function validateDisconnectParams(params) {
51  if (params === undefined || params === null) {
52    return {};
53  }
54
55  if (!isRecord(params)) {
56    throw new HelperProtocolError("Invalid disconnect parameters");
57  }
58
59  const iface = asOptionalString(params.iface);
60  if (params.iface !== undefined && (!iface || iface.length > 64)) {
61    throw new HelperProtocolError("Invalid iface");
62  }
63
64  return iface ? { iface } : {};
65}
66
67function validateMethodParams(method, params) {
68  if (method === "network.getStatus" || method === "network.scan") {
69    return {};
70  }
71
72  if (method === "network.connect") {
73    return validateConnectParams(params);
74  }
75
76  if (method === "network.disconnect") {
77    return validateDisconnectParams(params);
78  }
79
80  throw new HelperProtocolError("Method not allowed");
81}
82
83function parseRpcRequest(line) {
84  let parsed;
85  try {
86    parsed = JSON.parse(line);
87  } catch {
88    throw new HelperProtocolError("Invalid JSON request");
89  }
90
91  if (!isRecord(parsed)) {
92    throw new HelperProtocolError("Request payload must be an object");
93  }
94
95  const id = asOptionalString(parsed.id);
96  const method = asOptionalString(parsed.method);
97  const requestId = asOptionalString(parsed.requestId);
98
99  if (!id || id.length > 128) {
100    throw new HelperProtocolError("Missing or invalid request id");
101  }
102
103  if (!method || !ALLOWED_METHODS.has(method)) {
104    throw new HelperProtocolError("Method not allowed");
105  }
106
107  return {
108    id,
109    method,
110    requestId,
111    params: validateMethodParams(method, parsed.params),
112  };
113}
114
115function toErrorPayload(error) {
116  if (
117    error &&
118    typeof error === "object" &&
119    "code" in error &&
120    "message" in error &&
121    typeof error.code === "string" &&
122    typeof error.message === "string"
123  ) {
124    return {
125      code: error.code,
126      message: error.message,
127    };
128  }
129
130  if (error instanceof HelperProtocolError) {
131    return {
132      code: error.code,
133      message: error.message,
134    };
135  }
136
137  if (error instanceof Error) {
138    return {
139      code: "internal_error",
140      message: error.message,
141    };
142  }
143
144  return {
145    code: "internal_error",
146    message: "Unknown error",
147  };
148}
149
150export { ALLOWED_METHODS, HelperProtocolError, parseRpcRequest, toErrorPayload };
151