@firstpick/pi-package-remote-webui 0.1.0

package/tests/remote-args.test.mjs

@@ -0,0 +1,112 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  DEFAULT_PORT,
+  buildRemoteWidgetLines,
+  formatStatus,
+  generateQrLines,
+  parseRemoteArgs,
+  requiresOpenConfirmation,
+  selectLanUrl,
+  tokenizeArgs,
+} from "../lib/remote-core.mjs";
+
+test("tokenizeArgs handles quoted values", () => {
+  assert.deepEqual(tokenizeArgs('status --name "mobile phone" --port 31500'), ["status", "--name", "mobile phone", "--port", "31500"]);
+});
+
+test("parseRemoteArgs defaults to open on the default port", () => {
+  assert.deepEqual(parseRemoteArgs(""), {
+    action: "open",
+    port: DEFAULT_PORT,
+    name: undefined,
+    yes: false,
+  });
+});
+
+test("parseRemoteArgs supports action, port, name, and confirmation bypass", () => {
+  assert.deepEqual(parseRemoteArgs('status --port 31500 --name "mobile phone" --yes'), {
+    action: "status",
+    port: 31500,
+    name: "mobile phone",
+    yes: true,
+  });
+});
+
+test("parseRemoteArgs supports numeric port shortcut", () => {
+  assert.deepEqual(parseRemoteArgs("refresh 31501 -y"), {
+    action: "refresh",
+    port: 31501,
+    name: undefined,
+    yes: true,
+  });
+});
+
+test("parseRemoteArgs rejects invalid ports and unknown options", () => {
+  assert.throws(() => parseRemoteArgs("--port 70000"), /port/i);
+  assert.throws(() => parseRemoteArgs("--bogus"), /Unknown option/);
+});
+
+test("requiresOpenConfirmation is only bypassed for /remote --yes", () => {
+  assert.equal(requiresOpenConfirmation(parseRemoteArgs("")), true);
+  assert.equal(requiresOpenConfirmation(parseRemoteArgs("--yes")), false);
+  assert.equal(requiresOpenConfirmation(parseRemoteArgs("status")), false);
+});
+
+test("selectLanUrl chooses the first HTTP LAN URL", () => {
+  assert.equal(
+    selectLanUrl({ networkUrls: ["ftp://ignored", "http://192.168.1.20:31415/", "http://10.0.0.5:31415/"] }),
+    "http://192.168.1.20:31415/",
+  );
+});
+
+test("formatStatus renders offline and online states", () => {
+  assert.match(formatStatus({ online: false, url: "http://127.0.0.1:31415/", health: { error: "offline" } }), /Online:\s+no/);
+  assert.match(
+    formatStatus({
+      online: true,
+      url: "http://192.168.1.20:31415/",
+      health: { data: { webuiVersion: "0.3.8" } },
+      network: { open: true, host: "0.0.0.0", port: 31415, networkUrls: ["http://192.168.1.20:31415/"] },
+    }),
+    /open to LAN/,
+  );
+});
+
+test("buildRemoteWidgetLines includes QR, URL, auth state, and close instruction", () => {
+  const lines = buildRemoteWidgetLines({
+    url: "http://192.168.1.20:31415/",
+    qrLines: ["QR-A", "QR-B"],
+    network: { auth: { enabled: true, pin: "1234" } },
+    started: true,
+  });
+  assert(lines.includes("QR-A"));
+  assert(lines.includes("http://192.168.1.20:31415/"));
+  assert(lines.some((line) => line.includes("PIN 1234")));
+  assert(lines.some((line) => line.includes("/remote close")));
+  assert(lines.some((line) => line.includes("Started a Pi Web UI server")));
+});
+
+test("generateQrLines accepts an injected QR module", async () => {
+  const lines = await generateQrLines("http://example.test/", {
+    qrcodeModule: {
+      generate(value, options, callback) {
+        assert.equal(value, "http://example.test/");
+        assert.equal(options.small, true);
+        callback("QR\nCODE");
+      },
+    },
+  });
+  assert.deepEqual(lines, ["QR", "CODE"]);
+});
+
+test("generateQrLines reports QR failures without duplicating the URL", async () => {
+  const lines = await generateQrLines("http://example.test/", {
+    qrcodeModule: {
+      generate() {
+        throw new Error("boom");
+      },
+    },
+  });
+  assert.deepEqual(lines, ["[QR generation failed: boom]"]);
+});

package/tests/remote-webui-control.test.mjs

@@ -0,0 +1,128 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { once } from "node:events";
+import { RemoteWebuiController, closeRemoteWebui, openRemoteWebui } from "../lib/remote-core.mjs";
+
+async function withMockWebui(handler, fn) {
+  const server = createServer(handler);
+  server.listen(0, "127.0.0.1");
+  await once(server, "listening");
+  const { port } = server.address();
+  try {
+    return await fn(port);
+  } finally {
+    server.close();
+    await once(server, "close");
+  }
+}
+
+function sendJson(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+
+test("openRemoteWebui starts when offline, opens network, and returns a LAN URL", async () => {
+  const calls = [];
+  let online = false;
+  let networkOpen = false;
+
+  await withMockWebui((req, res) => {
+    calls.push(`${req.method} ${req.url}`);
+    if (req.url === "/api/health" && req.method === "GET") {
+      if (!online) return sendJson(res, 503, { ok: false, error: "offline" });
+      return sendJson(res, 200, { ok: true, webuiVersion: "0.3.8" });
+    }
+    if (req.url === "/api/network" && req.method === "GET") {
+      return sendJson(res, 200, {
+        ok: true,
+        data: {
+          open: networkOpen,
+          opening: false,
+          closing: false,
+          host: networkOpen ? "0.0.0.0" : "127.0.0.1",
+          port: 0,
+          localUrl: "http://127.0.0.1/",
+          networkUrls: networkOpen ? ["http://192.168.1.44:31415/"] : [],
+        },
+      });
+    }
+    if (req.url === "/api/network/open" && req.method === "POST") {
+      networkOpen = true;
+      return sendJson(res, 202, { ok: true, data: { opening: true } });
+    }
+    sendJson(res, 404, { ok: false, error: "not found" });
+  }, async (port) => {
+    const controller = new RemoteWebuiController({ sleepImpl: () => Promise.resolve() });
+    const result = await openRemoteWebui({ port }, {
+      controller,
+      startWebui: async () => {
+        calls.push("startWebui");
+        online = true;
+      },
+    });
+
+    assert.equal(result.started, true);
+    assert.equal(result.url, "http://192.168.1.44:31415/");
+    assert.deepEqual(calls, [
+      "GET /api/health",
+      "startWebui",
+      "GET /api/health",
+      "GET /api/network",
+      "POST /api/network/open",
+      "GET /api/network",
+    ]);
+  });
+});
+
+test("openRemoteWebui reuses an already open WebUI", async () => {
+  let startCalled = false;
+
+  await withMockWebui((req, res) => {
+    if (req.url === "/api/health" && req.method === "GET") return sendJson(res, 200, { ok: true, webuiVersion: "0.3.8" });
+    if (req.url === "/api/network" && req.method === "GET") {
+      return sendJson(res, 200, {
+        ok: true,
+        data: {
+          open: true,
+          opening: false,
+          closing: false,
+          host: "0.0.0.0",
+          port: 0,
+          localUrl: "http://127.0.0.1/",
+          networkUrls: ["http://10.0.0.8:31415/"],
+        },
+      });
+    }
+    sendJson(res, 404, { ok: false });
+  }, async (port) => {
+    const controller = new RemoteWebuiController({ sleepImpl: () => Promise.resolve() });
+    const result = await openRemoteWebui({ port }, {
+      controller,
+      startWebui: async () => {
+        startCalled = true;
+      },
+    });
+
+    assert.equal(startCalled, false);
+    assert.equal(result.started, false);
+    assert.equal(result.url, "http://10.0.0.8:31415/");
+  });
+});
+
+test("closeRemoteWebui calls the close endpoint when online", async () => {
+  const calls = [];
+
+  await withMockWebui((req, res) => {
+    calls.push(`${req.method} ${req.url}`);
+    if (req.url === "/api/health" && req.method === "GET") return sendJson(res, 200, { ok: true, webuiVersion: "0.3.8" });
+    if (req.url === "/api/network/close" && req.method === "POST") return sendJson(res, 202, { ok: true, data: { open: false } });
+    sendJson(res, 404, { ok: false });
+  }, async (port) => {
+    const controller = new RemoteWebuiController({ sleepImpl: () => Promise.resolve() });
+    const result = await closeRemoteWebui({ port }, { controller });
+
+    assert.equal(result.online, true);
+    assert.deepEqual(calls, ["GET /api/health", "POST /api/network/close"]);
+  });
+});

package/tests/run-all.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(__dirname, "..");
+const tests = [
+  path.join("tests", "remote-args.test.mjs"),
+  path.join("tests", "remote-webui-control.test.mjs"),
+];
+
+const result = spawnSync(process.execPath, ["--test", ...tests], {
+  cwd: packageRoot,
+  stdio: "inherit",
+});
+
+if (result.error) {
+  console.error(result.error);
+  process.exit(1);
+}
+process.exit(result.status ?? 1);