pi-remote-control 1.0.0

package/tests/cli.test.ts

@@ -0,0 +1,361 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, expect, it } from "vitest";
+import { main, readInstalledPiVersion, type CliDependencies } from "../src/cli.js";
+
+describe("daemon CLI", () => {
+  it("reads the installed Pi package version", async () => {
+    await expect(readInstalledPiVersion()).resolves.toMatch(/^\d+\.\d+\.\d+/);
+  });
+  it("starts the HTTP server with state dir and bind overrides", async () => {
+    const lines: string[] = [];
+    const calls: unknown[] = [];
+    const deps: CliDependencies = {
+      getStateDir: () => "/tmp/default-state",
+      ensureStateDir: async (stateDir) => {
+        calls.push({ ensureStateDir: stateDir });
+      },
+      loadConfig: async () => ({ bindAddress: "127.0.0.1:17373" }),
+      saveConfig: async (stateDir, config) => {
+        calls.push({ saveConfig: stateDir, config });
+      },
+      acquireLock: async (stateDir) => {
+        calls.push({ acquireLock: stateDir });
+        return { path: `${stateDir}/daemon.lock`, release: async () => calls.push({ releaseLock: true }) };
+      },
+      startServer: async (options) => {
+        calls.push({ startServer: options });
+        return { address: "127.0.0.1:9999", close: async () => undefined };
+      },
+      openStore: () => ({
+        close: () => undefined,
+        authenticateToken: async () => false,
+        createPairingCode: async () => ({ pairCode: "123456", expiresAt: "2026-05-09T00:01:00.000Z" }),
+        claimPairingCode: async () => undefined,
+      }),
+      getPiVersion: async () => {
+        calls.push({ getPiVersion: true });
+        return "0.74.0-test";
+      },
+      waitForShutdown: async () => undefined,
+      removeFile: async (path) => {
+        calls.push({ removeFile: path });
+      },
+      writeLine: (line) => lines.push(line),
+      env: { PI_REMOTE_CONTROL_DEV_TOKEN: "test-token" },
+    };
+
+    const code = await main(["start", "--state-dir", "/tmp/state", "--bind", "127.0.0.1:0"], deps);
+
+    expect(code).toBe(0);
+    expect(calls).toEqual([
+      { ensureStateDir: "/tmp/state" },
+      { acquireLock: "/tmp/state" },
+      { saveConfig: "/tmp/state", config: { bindAddress: "127.0.0.1:17373" } },
+      { getPiVersion: true },
+      {
+        startServer: expect.objectContaining({
+          stateDir: "/tmp/state",
+          config: { bindAddress: "127.0.0.1:0" },
+          piVersion: "0.74.0-test",
+        }),
+      },
+      { releaseLock: true },
+    ]);
+    expect(lines).toContain("pi-remote-control listening on http://127.0.0.1:9999");
+  });
+
+  it("creates config.json on first real start", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-remote-control-cli-"));
+    try {
+      const code = await main(["start", "--state-dir", root], {
+        openStore: () => ({
+          close: () => undefined,
+          authenticateToken: async () => false,
+          createPairingCode: async () => ({ pairCode: "123456", expiresAt: "2026-05-09T00:01:00.000Z" }),
+          claimPairingCode: async () => undefined,
+        }),
+        startServer: async () => ({ address: "127.0.0.1:9999", close: async () => undefined }),
+        waitForShutdown: async () => undefined,
+        writeLine: () => undefined,
+      });
+
+      expect(code).toBe(0);
+      await expect(readFile(join(root, "config.json"), "utf8")).resolves.toContain("127.0.0.1:17373");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("writes default config when config file is missing", async () => {
+    const calls: unknown[] = [];
+    const missing = new Error("missing") as Error & { code: string };
+    missing.code = "ENOENT";
+
+    const code = await main(["start"], {
+      getStateDir: () => "/tmp/state",
+      ensureStateDir: async () => undefined,
+      acquireLock: async () => ({ path: "/tmp/state/daemon.lock", release: async () => calls.push({ releaseLock: true }) }),
+      loadConfig: async () => {
+        throw missing;
+      },
+      saveConfig: async (stateDir, config) => calls.push({ saveConfig: stateDir, config }),
+      openStore: () => ({
+        close: () => calls.push({ closeStore: true }),
+        authenticateToken: async () => false,
+        createPairingCode: async () => ({ pairCode: "123456", expiresAt: "2026-05-09T00:01:00.000Z" }),
+        claimPairingCode: async () => undefined,
+      }),
+      startServer: async () => ({ address: "127.0.0.1:9999", close: async () => undefined }),
+      removeFile: async () => undefined,
+      waitForShutdown: async () => undefined,
+      writeLine: () => undefined,
+    });
+
+    expect(code).toBe(0);
+    expect(calls).toContainEqual({
+      saveConfig: "/tmp/state",
+      config: { bindAddress: "127.0.0.1:17373" },
+    });
+  });
+
+  it("does not start when daemon lock is already held", async () => {
+    const lines: string[] = [];
+    const calls: unknown[] = [];
+    const code = await main(["start"], {
+      getStateDir: () => "/tmp/state",
+      ensureStateDir: async () => undefined,
+      acquireLock: async (stateDir) => {
+        calls.push({ acquireLock: stateDir });
+        return undefined;
+      },
+      loadConfig: async () => ({ bindAddress: "127.0.0.1:0" }),
+      startServer: async () => {
+        throw new Error("should not start");
+      },
+      writeLine: (line) => lines.push(line),
+    });
+
+    expect(code).toBe(1);
+    expect(calls).toEqual([{ acquireLock: "/tmp/state" }]);
+    expect(lines).toEqual(["pi-remote-control is already running"]);
+  });
+
+  it("starts with persistent store authentication and pairing", async () => {
+    let startOptions: Parameters<NonNullable<CliDependencies["startServer"]>>[0] | undefined;
+    const calls: unknown[] = [];
+    const code = await main(["start"], {
+      getStateDir: () => "/tmp/state",
+      ensureStateDir: async () => undefined,
+      loadConfig: async () => ({ bindAddress: "127.0.0.1:0" }),
+      saveConfig: async (stateDir, config) => calls.push({ saveConfig: stateDir, config }),
+      acquireLock: async (stateDir) => {
+        calls.push({ acquireLock: stateDir });
+        return { path: `${stateDir}/daemon.lock`, release: async () => calls.push({ releaseLock: true }) };
+      },
+      openStore: (stateDir) => {
+        calls.push({ openStore: stateDir });
+        return {
+          close: () => calls.push({ closeStore: true }),
+          authenticateToken: async (token) => token === "stored-token",
+          createPairingCode: async () => ({ pairCode: "123456", expiresAt: "2026-05-09T00:01:00.000Z" }),
+          claimPairingCode: async () => ({ deviceId: "dev_1", token: "prd_1", daemonName: "pi-remote-control" }),
+        };
+      },
+      startServer: async (options) => {
+        startOptions = options;
+        return { address: "127.0.0.1:9999", close: async () => undefined };
+      },
+      removeFile: async () => undefined,
+      waitForShutdown: async () => undefined,
+      writeLine: () => undefined,
+    });
+
+    expect(code).toBe(0);
+    expect(calls).toEqual([
+      { acquireLock: "/tmp/state" },
+      { saveConfig: "/tmp/state", config: { bindAddress: "127.0.0.1:0" } },
+      { openStore: "/tmp/state" },
+      { closeStore: true },
+      { releaseLock: true },
+    ]);
+    await expect(startOptions?.authenticateToken?.("stored-token")).resolves.toBe(true);
+    await expect(startOptions?.pairService?.createPairingCode?.()).resolves.toEqual({
+      pairCode: "123456",
+      expiresAt: "2026-05-09T00:01:00.000Z",
+    });
+  });
+
+
+  it("reports stopped status when no lock file exists", async () => {
+    const lines: string[] = [];
+    const deps: CliDependencies = {
+      getStateDir: () => "/tmp/state",
+      readTextFile: async () => {
+        const error = new Error("missing") as Error & { code: string };
+        error.code = "ENOENT";
+        throw error;
+      },
+      writeLine: (line) => lines.push(line),
+    };
+
+    const code = await main(["status"], deps);
+
+    expect(code).toBe(1);
+    expect(lines).toEqual(["pi-remote-control is stopped"]);
+  });
+
+  it("removes stale lock when status finds a missing process", async () => {
+    const lines: string[] = [];
+    const calls: unknown[] = [];
+    const code = await main(["status", "--state-dir", "/tmp/state"], {
+      readTextFile: async () => "1234\n",
+      isProcessRunning: () => false,
+      removeFile: async (path) => calls.push({ removeFile: path }),
+      writeLine: (line) => lines.push(line),
+    });
+
+    expect(code).toBe(1);
+    expect(calls).toEqual([{ removeFile: "/tmp/state/daemon.lock" }]);
+    expect(lines).toEqual(["pi-remote-control is stopped (stale lock removed, pid 1234)"]);
+  });
+
+  it("reports running status from lock file", async () => {
+    const lines: string[] = [];
+    const code = await main(["status", "--state-dir", "/tmp/state"], {
+      readTextFile: async (path) => {
+        expect(path).toBe("/tmp/state/daemon.lock");
+        return "1234\n";
+      },
+      isProcessRunning: (pid) => pid === 1234,
+      writeLine: (line) => lines.push(line),
+    });
+
+    expect(code).toBe(0);
+    expect(lines).toEqual(["pi-remote-control is running (pid 1234)"]);
+  });
+
+  it("reports stopped when stopping without a lock file", async () => {
+    const lines: string[] = [];
+    const code = await main(["stop", "--state-dir", "/tmp/state"], {
+      readTextFile: async () => {
+        const error = new Error("missing") as Error & { code: string };
+        error.code = "ENOENT";
+        throw error;
+      },
+      writeLine: (line) => lines.push(line),
+    });
+
+    expect(code).toBe(1);
+    expect(lines).toEqual(["pi-remote-control is not running"]);
+  });
+
+  it("removes stale lock when stopping a missing process", async () => {
+    const lines: string[] = [];
+    const calls: unknown[] = [];
+    const code = await main(["stop", "--state-dir", "/tmp/state"], {
+      readTextFile: async () => "1234\n",
+      sendSignal: () => {
+        const error = new Error("missing process") as Error & { code: string };
+        error.code = "ESRCH";
+        throw error;
+      },
+      removeFile: async (path) => calls.push({ removeFile: path }),
+      writeLine: (line) => lines.push(line),
+    });
+
+    expect(code).toBe(0);
+    expect(calls).toEqual([{ removeFile: "/tmp/state/daemon.lock" }]);
+    expect(lines).toEqual(["pi-remote-control stale lock removed (pid 1234)"]);
+  });
+
+  it("stops a running daemon from its lock file", async () => {
+    const lines: string[] = [];
+    const calls: unknown[] = [];
+    const code = await main(["stop", "--state-dir", "/tmp/state"], {
+      readTextFile: async () => "1234\n",
+      sendSignal: (pid, signal) => {
+        calls.push({ sendSignal: pid, signal });
+      },
+      removeFile: async (path) => {
+        calls.push({ removeFile: path });
+      },
+      writeLine: (line) => lines.push(line),
+    });
+
+    expect(code).toBe(0);
+    expect(calls).toEqual([
+      { sendSignal: 1234, signal: "SIGTERM" },
+      { removeFile: "/tmp/state/daemon.lock" },
+    ]);
+    expect(lines).toEqual(["pi-remote-control stop requested (pid 1234)"]);
+  });
+
+  it("prints a helpful pairing setup message when advertisedBaseUrl is missing", async () => {
+    const lines: string[] = [];
+    const calls: unknown[] = [];
+    const code = await main(["pair", "--state-dir", "/tmp/state"], {
+      ensureStateDir: async (stateDir) => calls.push({ ensureStateDir: stateDir }),
+      loadConfig: async () => ({ bindAddress: "127.0.0.1:17373" }),
+      openStore: () => {
+        throw new Error("store should not open without advertisedBaseUrl");
+      },
+      writeLine: (line) => lines.push(line),
+    });
+
+    expect(code).toBe(1);
+    expect(calls).toEqual([{ ensureStateDir: "/tmp/state" }]);
+    expect(lines).toEqual([
+      "advertisedBaseUrl is required for QR pairing.",
+      "Set ~/.pi/remote-control/config.json or PI_REMOTE_CONTROL_ADVERTISED_BASE_URL to an iOS-reachable URL.",
+      "Example: https://macbook.tailnet.ts.net:17373",
+    ]);
+  });
+
+  it("uses PI_REMOTE_CONTROL_URL as pairing URL fallback", async () => {
+    const lines: string[] = [];
+    const code = await main(["pair", "--state-dir", "/tmp/state"], {
+      env: { PI_REMOTE_CONTROL_URL: "https://macbook.tailnet.ts.net:17373" },
+      ensureStateDir: async () => undefined,
+      loadConfig: async () => ({ bindAddress: "127.0.0.1:17373" }),
+      openStore: () => ({
+        close: () => undefined,
+        authenticateToken: async () => false,
+        createPairingCode: async () => ({ pairCode: "123456", expiresAt: "2026-05-09T00:01:00.000Z" }),
+        claimPairingCode: async () => undefined,
+      }),
+      writeLine: (line) => lines.push(line),
+    });
+
+    expect(code).toBe(0);
+    expect(lines[0]).toBe("Scan with Pi iOS app:");
+    expect(lines[1]).toContain("█");
+    expect(lines.at(-1)).toBe("Expires at: 2026-05-09T00:01:00.000Z");
+  });
+
+  it("creates and prints local TUI pairing QR and expiry", async () => {
+    const lines: string[] = [];
+    const calls: unknown[] = [];
+    const code = await main(["pair", "--state-dir", "/tmp/state"], {
+      ensureStateDir: async (stateDir) => calls.push({ ensureStateDir: stateDir }),
+      loadConfig: async () => ({ bindAddress: "127.0.0.1:17373", advertisedBaseUrl: "https://macbook.tailnet.ts.net:17373" }),
+      openStore: (stateDir) => {
+        calls.push({ openStore: stateDir });
+        return {
+          close: () => calls.push({ closeStore: true }),
+          authenticateToken: async () => false,
+          createPairingCode: async () => ({ pairCode: "123456", expiresAt: "2026-05-09T00:01:00.000Z" }),
+          claimPairingCode: async () => undefined,
+        };
+      },
+      writeLine: (line) => lines.push(line),
+    });
+
+    expect(code).toBe(0);
+    expect(calls).toEqual([{ ensureStateDir: "/tmp/state" }, { openStore: "/tmp/state" }, { closeStore: true }]);
+    expect(lines[0]).toBe("Scan with Pi iOS app:");
+    expect(lines[1]).toContain("█");
+    expect(lines.slice(2)).toEqual(["Expires at: 2026-05-09T00:01:00.000Z"]);
+  });
+});

package/tests/config.test.ts

@@ -0,0 +1,35 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, expect, it } from "vitest";
+import { DEFAULT_BIND_ADDRESS, defaultDaemonConfig, loadDaemonConfig, saveDaemonConfig } from "../src/config.js";
+
+describe("daemon config", () => {
+  it("has a safe localhost default", () => {
+    expect(defaultDaemonConfig()).toEqual({ bindAddress: DEFAULT_BIND_ADDRESS });
+  });
+
+  it("loads defaults when config.json does not exist", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-remote-control-config-"));
+    try {
+      await expect(loadDaemonConfig(root)).resolves.toEqual({ bindAddress: DEFAULT_BIND_ADDRESS });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("round-trips saved config", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-remote-control-config-"));
+    const config = {
+      bindAddress: "100.64.0.1:17373",
+      advertisedBaseUrl: "https://macbook.tailnet.ts.net:17373",
+    };
+
+    try {
+      await saveDaemonConfig(root, config);
+      await expect(loadDaemonConfig(root)).resolves.toEqual(config);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});

package/tests/daemon-store.test.ts

@@ -0,0 +1,54 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, expect, it } from "vitest";
+import { openDaemonStore } from "../src/persistence/daemon-store.js";
+
+describe("daemon store", () => {
+  it("rejects duplicate pairing claims", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-remote-control-store-"));
+    try {
+      const store = openDaemonStore(root);
+      const pair = await store.createPairingCode(new Date("2026-05-09T00:00:00.000Z"), 60_000);
+
+      await expect(store.claimPairingCode(pair.pairCode, "iPhone", new Date("2026-05-09T00:00:30.000Z"))).resolves.toBeDefined();
+      await expect(store.claimPairingCode(pair.pairCode, "iPad", new Date("2026-05-09T00:00:40.000Z"))).resolves.toBeUndefined();
+      store.close();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("authenticates claimed device tokens", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-remote-control-store-"));
+    try {
+      const store = openDaemonStore(root);
+      const pair = await store.createPairingCode(new Date("2026-05-09T00:00:00.000Z"), 60_000);
+      const claimed = await store.claimPairingCode(pair.pairCode, "iPhone", new Date("2026-05-09T00:00:30.000Z"));
+
+      await expect(store.authenticateToken(claimed!.token)).resolves.toBe(true);
+      await expect(store.authenticateToken("prd_wrong")).resolves.toBe(false);
+      store.close();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("creates and persists pairing codes", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-remote-control-store-"));
+    try {
+      const store = openDaemonStore(root);
+      const pair = await store.createPairingCode(new Date("2026-05-09T00:00:00.000Z"), 60_000);
+      store.close();
+
+      const reopened = openDaemonStore(root);
+      const claimed = await reopened.claimPairingCode(pair.pairCode, "iPhone", new Date("2026-05-09T00:00:30.000Z"));
+      reopened.close();
+
+      expect(pair).toMatchObject({ pairCode: expect.stringMatching(/^\d{6}$/), expiresAt: "2026-05-09T00:01:00.000Z" });
+      expect(claimed).toMatchObject({ deviceId: expect.stringMatching(/^dev_/), token: expect.stringMatching(/^prd_/), daemonName: "pi-remote-control" });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});