@wangyaoshen/remux 0.3.8-dev.a8ceb0c

package/tests/service.test.js

@@ -0,0 +1,267 @@
+/**
+ * Unit tests for launchd service management (install/uninstall/status).
+ * Tests plist generation, path handling, and launchctl interaction.
+ * Mocks fs and child_process to avoid side effects.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import path from "path";
+import { homedir } from "os";
+
+// We'll dynamically import the module after mocking
+let service;
+let mockFs;
+let mockExecSync;
+
+const PLIST_PATH = path.join(
+  homedir(),
+  "Library",
+  "LaunchAgents",
+  "com.remux.agent.plist",
+);
+const LOG_DIR = path.join(homedir(), ".remux", "logs");
+
+beforeEach(async () => {
+  vi.resetModules();
+
+  // Mock fs
+  mockFs = {
+    existsSync: vi.fn().mockReturnValue(false),
+    writeFileSync: vi.fn(),
+    unlinkSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    readFileSync: vi.fn(),
+  };
+  vi.doMock("fs", () => ({ default: mockFs, ...mockFs }));
+
+  // Mock child_process
+  mockExecSync = vi.fn().mockReturnValue("");
+  vi.doMock("child_process", () => ({
+    execSync: mockExecSync,
+  }));
+
+  service = await import("../src/service.ts");
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("generatePlist", () => {
+  it("generates valid plist XML with correct structure", () => {
+    const xml = service.generatePlist({});
+    expect(xml).toContain('<?xml version="1.0" encoding="UTF-8"?>');
+    expect(xml).toContain("<!DOCTYPE plist");
+    expect(xml).toContain('<plist version="1.0">');
+    expect(xml).toContain("<key>Label</key>");
+    expect(xml).toContain("<string>com.remux.agent</string>");
+    expect(xml).toContain("<key>RunAtLoad</key>");
+    expect(xml).toContain("<true/>");
+    expect(xml).toContain("<key>KeepAlive</key>");
+    expect(xml).toContain("<key>ProgramArguments</key>");
+    expect(xml).toContain("<key>StandardOutPath</key>");
+    expect(xml).toContain("<key>StandardErrorPath</key>");
+    expect(xml).toContain("</plist>");
+  });
+
+  it("includes node and server.js in ProgramArguments", () => {
+    const xml = service.generatePlist({});
+    // Should contain the node executable path
+    expect(xml).toContain(process.execPath);
+    // Should contain server.js path
+    expect(xml).toContain("server.js");
+  });
+
+  it("includes extra args in ProgramArguments", () => {
+    const xml = service.generatePlist({ args: ["--verbose", "--debug"] });
+    expect(xml).toContain("<string>--verbose</string>");
+    expect(xml).toContain("<string>--debug</string>");
+  });
+
+  it("sets PORT in EnvironmentVariables when port option given", () => {
+    const xml = service.generatePlist({ port: 9999 });
+    expect(xml).toContain("<key>PORT</key>");
+    expect(xml).toContain("<string>9999</string>");
+  });
+
+  it("includes REMUX_TOKEN from env if set", () => {
+    const origToken = process.env.REMUX_TOKEN;
+    process.env.REMUX_TOKEN = "my-secret-token";
+    try {
+      const xml = service.generatePlist({});
+      expect(xml).toContain("<key>REMUX_TOKEN</key>");
+      expect(xml).toContain("<string>my-secret-token</string>");
+    } finally {
+      if (origToken === undefined) delete process.env.REMUX_TOKEN;
+      else process.env.REMUX_TOKEN = origToken;
+    }
+  });
+
+  it("omits REMUX_TOKEN when not set", () => {
+    const origToken = process.env.REMUX_TOKEN;
+    delete process.env.REMUX_TOKEN;
+    try {
+      const xml = service.generatePlist({});
+      expect(xml).not.toContain("<key>REMUX_TOKEN</key>");
+    } finally {
+      if (origToken !== undefined) process.env.REMUX_TOKEN = origToken;
+    }
+  });
+
+  it("sets correct log paths", () => {
+    const xml = service.generatePlist({});
+    expect(xml).toContain(path.join(LOG_DIR, "remux.log"));
+    expect(xml).toContain(path.join(LOG_DIR, "remux.err"));
+  });
+
+  it("sets WorkingDirectory to package directory", () => {
+    const xml = service.generatePlist({});
+    expect(xml).toContain("<key>WorkingDirectory</key>");
+  });
+});
+
+describe("installService", () => {
+  it("creates log directory", () => {
+    service.installService({});
+    expect(mockFs.mkdirSync).toHaveBeenCalledWith(LOG_DIR, {
+      recursive: true,
+    });
+  });
+
+  it("writes plist file to LaunchAgents", () => {
+    service.installService({});
+    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+      PLIST_PATH,
+      expect.stringContaining("com.remux.agent"),
+    );
+  });
+
+  it("runs launchctl load", () => {
+    service.installService({});
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringContaining("launchctl load"),
+      expect.any(Object),
+    );
+  });
+
+  it("passes port option through to plist", () => {
+    service.installService({ port: 4000 });
+    const writtenXml = mockFs.writeFileSync.mock.calls[0][1];
+    expect(writtenXml).toContain("<string>4000</string>");
+  });
+
+  it("unloads existing service before installing", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    service.installService({});
+    // Should unload first, then load
+    const calls = mockExecSync.mock.calls.map((c) => c[0]);
+    const unloadIdx = calls.findIndex((c) => c.includes("launchctl unload"));
+    const loadIdx = calls.findIndex((c) => c.includes("launchctl load"));
+    expect(unloadIdx).toBeLessThan(loadIdx);
+  });
+});
+
+describe("uninstallService", () => {
+  it("runs launchctl unload", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    service.uninstallService();
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringContaining("launchctl unload"),
+      expect.any(Object),
+    );
+  });
+
+  it("removes plist file", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    service.uninstallService();
+    expect(mockFs.unlinkSync).toHaveBeenCalledWith(PLIST_PATH);
+  });
+
+  it("handles missing plist gracefully", () => {
+    mockFs.existsSync.mockReturnValue(false);
+    // Should not throw
+    expect(() => service.uninstallService()).not.toThrow();
+  });
+});
+
+describe("serviceStatus", () => {
+  it("returns not installed when plist missing", () => {
+    mockFs.existsSync.mockReturnValue(false);
+    const status = service.serviceStatus();
+    expect(status.installed).toBe(false);
+    expect(status.running).toBe(false);
+    expect(status.pid).toBeUndefined();
+  });
+
+  it("returns installed + running with PID when launchctl finds it", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    // launchctl list output: PID, last exit status, label
+    mockExecSync.mockReturnValue("12345\t0\tcom.remux.agent\n");
+    const status = service.serviceStatus();
+    expect(status.installed).toBe(true);
+    expect(status.running).toBe(true);
+    expect(status.pid).toBe(12345);
+  });
+
+  it("returns installed but not running when PID is -", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockExecSync.mockReturnValue("-\t0\tcom.remux.agent\n");
+    const status = service.serviceStatus();
+    expect(status.installed).toBe(true);
+    expect(status.running).toBe(false);
+    expect(status.pid).toBeUndefined();
+  });
+
+  it("returns installed but not running when launchctl throws", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockExecSync.mockImplementation(() => {
+      throw new Error("Could not find service");
+    });
+    const status = service.serviceStatus();
+    expect(status.installed).toBe(true);
+    expect(status.running).toBe(false);
+  });
+});
+
+describe("handleServiceCommand", () => {
+  it("returns false for non-service commands", () => {
+    expect(service.handleServiceCommand([])).toBe(false);
+    expect(service.handleServiceCommand(["node", "server.js"])).toBe(false);
+    expect(service.handleServiceCommand(["node", "server.js", "start"])).toBe(
+      false,
+    );
+  });
+
+  it("returns true for service commands", () => {
+    expect(
+      service.handleServiceCommand(["node", "server.js", "service", "install"]),
+    ).toBe(true);
+    expect(
+      service.handleServiceCommand([
+        "node",
+        "server.js",
+        "service",
+        "uninstall",
+      ]),
+    ).toBe(true);
+    expect(
+      service.handleServiceCommand(["node", "server.js", "service", "status"]),
+    ).toBe(true);
+  });
+
+  it("parses --port flag for install", () => {
+    service.handleServiceCommand([
+      "node",
+      "server.js",
+      "service",
+      "install",
+      "--port",
+      "3000",
+    ]);
+    // Verify that writeFileSync was called with port in the plist
+    const writtenXml = mockFs.writeFileSync.mock.calls[0]?.[1];
+    if (writtenXml) {
+      expect(writtenXml).toContain("<string>3000</string>");
+    }
+  });
+});

package/tests/store.test.js

@@ -0,0 +1,369 @@
+/**
+ * Tests for SQLite store (src/store.ts).
+ * Device CRUD, trust levels, pairing, and session/tab persistence.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Database from "better-sqlite3";
+import {
+  _resetDbForTest,
+  closeDb,
+  upsertSession,
+  upsertTab,
+  loadSessions,
+  removeSession,
+  removeStaleTab,
+  createDevice,
+  findDeviceById,
+  findDeviceByFingerprint,
+  listDevices,
+  updateDeviceTrust,
+  renameDevice,
+  deleteDevice,
+  touchDevice,
+  hasAnyDevice,
+  computeFingerprint,
+  createPairCode,
+  consumePairCode,
+} from "../src/store.ts";
+
+/** Create an in-memory SQLite DB with the same schema as store.ts. */
+function createTestDb() {
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      name TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS tabs (
+      id INTEGER PRIMARY KEY,
+      session_name TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT 'Tab',
+      scrollback BLOB,
+      ended INTEGER NOT NULL DEFAULT 0,
+      FOREIGN KEY (session_name) REFERENCES sessions(name) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS devices (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      fingerprint TEXT NOT NULL,
+      trust TEXT NOT NULL DEFAULT 'untrusted',
+      created_at INTEGER NOT NULL,
+      last_seen INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS pair_codes (
+      code TEXT PRIMARY KEY,
+      created_by TEXT NOT NULL,
+      expires_at INTEGER NOT NULL,
+      FOREIGN KEY (created_by) REFERENCES devices(id) ON DELETE CASCADE
+    );
+  `);
+  return db;
+}
+
+describe("store: session/tab persistence", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  it("upserts and loads sessions", () => {
+    upsertSession("main", 1000);
+    upsertSession("work", 2000);
+
+    const sessions = loadSessions();
+    expect(sessions).toHaveLength(2);
+    expect(sessions[0].name).toBe("main");
+    expect(sessions[0].createdAt).toBe(1000);
+    expect(sessions[1].name).toBe("work");
+  });
+
+  it("upserts and loads tabs with scrollback as BLOB", () => {
+    upsertSession("main", 1000);
+    const scrollback = Buffer.from("hello world terminal output");
+    upsertTab({
+      id: 1,
+      sessionName: "main",
+      title: "Tab 1",
+      scrollback,
+      ended: false,
+    });
+    upsertTab({
+      id: 2,
+      sessionName: "main",
+      title: "Tab 2",
+      scrollback: null,
+      ended: true,
+    });
+
+    const sessions = loadSessions();
+    expect(sessions[0].tabs).toHaveLength(2);
+    expect(Buffer.isBuffer(sessions[0].tabs[0].scrollback)).toBe(true);
+    expect(sessions[0].tabs[0].scrollback.toString()).toBe(
+      "hello world terminal output",
+    );
+    expect(sessions[0].tabs[0].ended).toBe(false);
+    expect(sessions[0].tabs[1].scrollback).toBeNull();
+    expect(sessions[0].tabs[1].ended).toBe(true);
+  });
+
+  it("upsert updates existing tab data", () => {
+    upsertSession("main", 1000);
+    upsertTab({
+      id: 1,
+      sessionName: "main",
+      title: "Tab 1",
+      scrollback: Buffer.from("old"),
+      ended: false,
+    });
+
+    upsertTab({
+      id: 1,
+      sessionName: "main",
+      title: "Renamed",
+      scrollback: Buffer.from("new data"),
+      ended: false,
+    });
+
+    const sessions = loadSessions();
+    expect(sessions[0].tabs).toHaveLength(1);
+    expect(sessions[0].tabs[0].title).toBe("Renamed");
+    expect(sessions[0].tabs[0].scrollback.toString()).toBe("new data");
+  });
+
+  it("removeSession cascades to tabs", () => {
+    upsertSession("temp", 3000);
+    upsertTab({
+      id: 10,
+      sessionName: "temp",
+      title: "Tab",
+      scrollback: null,
+      ended: false,
+    });
+
+    removeSession("temp");
+    const sessions = loadSessions();
+    expect(sessions).toHaveLength(0);
+  });
+
+  it("removeStaleTab deletes individual tabs", () => {
+    upsertSession("main", 1000);
+    upsertTab({
+      id: 1,
+      sessionName: "main",
+      title: "Tab 1",
+      scrollback: null,
+      ended: false,
+    });
+    upsertTab({
+      id: 2,
+      sessionName: "main",
+      title: "Tab 2",
+      scrollback: null,
+      ended: false,
+    });
+
+    removeStaleTab(1);
+    const sessions = loadSessions();
+    expect(sessions[0].tabs).toHaveLength(1);
+    expect(sessions[0].tabs[0].id).toBe(2);
+  });
+});
+
+describe("store: device CRUD", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  it("creates a device with generated ID", () => {
+    const device = createDevice("fp123", "untrusted");
+    expect(device.id).toHaveLength(16);
+    expect(device.fingerprint).toBe("fp123");
+    expect(device.trust).toBe("untrusted");
+    expect(device.name).toMatch(/^Device-/);
+  });
+
+  it("creates a device with custom name", () => {
+    const device = createDevice("fp123", "trusted", "My Phone");
+    expect(device.name).toBe("My Phone");
+    expect(device.trust).toBe("trusted");
+  });
+
+  it("findDeviceById returns device or null", () => {
+    const device = createDevice("fp-find", "untrusted");
+    const found = findDeviceById(device.id);
+    expect(found).not.toBeNull();
+    expect(found.fingerprint).toBe("fp-find");
+
+    const notFound = findDeviceById("nonexistent");
+    expect(notFound).toBeNull();
+  });
+
+  it("findDeviceByFingerprint returns device or null", () => {
+    createDevice("fp-search", "untrusted");
+    const found = findDeviceByFingerprint("fp-search");
+    expect(found).not.toBeNull();
+
+    const notFound = findDeviceByFingerprint("nonexistent");
+    expect(notFound).toBeNull();
+  });
+
+  it("listDevices returns all devices", () => {
+    const d1 = createDevice("fp1", "untrusted");
+    const d2 = createDevice("fp2", "trusted");
+
+    const devices = listDevices();
+    expect(devices).toHaveLength(2);
+    const ids = devices.map((d) => d.id);
+    expect(ids).toContain(d1.id);
+    expect(ids).toContain(d2.id);
+  });
+
+  it("hasAnyDevice returns correct boolean", () => {
+    expect(hasAnyDevice()).toBe(false);
+    createDevice("fp-check", "untrusted");
+    expect(hasAnyDevice()).toBe(true);
+  });
+});
+
+describe("store: trust levels", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  it("updateDeviceTrust changes trust level", () => {
+    const device = createDevice("fp-trust", "untrusted");
+    expect(device.trust).toBe("untrusted");
+
+    updateDeviceTrust(device.id, "trusted");
+    const updated = findDeviceById(device.id);
+    expect(updated.trust).toBe("trusted");
+
+    updateDeviceTrust(device.id, "blocked");
+    const blocked = findDeviceById(device.id);
+    expect(blocked.trust).toBe("blocked");
+  });
+
+  it("updateDeviceTrust returns false for nonexistent device", () => {
+    const result = updateDeviceTrust("nonexistent", "trusted");
+    expect(result).toBe(false);
+  });
+
+  it("renameDevice changes the device name", () => {
+    const device = createDevice("fp-rename", "untrusted");
+    renameDevice(device.id, "New Name");
+    const updated = findDeviceById(device.id);
+    expect(updated.name).toBe("New Name");
+  });
+
+  it("deleteDevice removes the device", () => {
+    const device = createDevice("fp-del", "untrusted");
+    expect(deleteDevice(device.id)).toBe(true);
+    expect(findDeviceById(device.id)).toBeNull();
+    expect(deleteDevice("nonexistent")).toBe(false);
+  });
+
+  it("touchDevice updates last_seen", () => {
+    const device = createDevice("fp-touch", "untrusted");
+    const before = device.lastSeen;
+
+    // Small delay to ensure timestamp changes
+    const now = Date.now() + 1000;
+    const origNow = Date.now;
+
+    touchDevice(device.id);
+    const updated = findDeviceById(device.id);
+    expect(updated.lastSeen).toBeGreaterThanOrEqual(before);
+  });
+});
+
+describe("store: pairing codes", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  it("creates a valid 6-digit pair code", () => {
+    const device = createDevice("fp-pair", "trusted");
+    const pc = createPairCode(device.id);
+    expect(pc.code).toHaveLength(6);
+    expect(Number(pc.code)).toBeGreaterThanOrEqual(100000);
+    expect(Number(pc.code)).toBeLessThan(1000000);
+    expect(pc.expiresAt).toBeGreaterThan(Date.now());
+    expect(pc.createdBy).toBe(device.id);
+  });
+
+  it("consumePairCode returns creator and is one-time use", () => {
+    const device = createDevice("fp-pair-consume", "trusted");
+    const pc = createPairCode(device.id);
+
+    const creator = consumePairCode(pc.code);
+    expect(creator).toBe(device.id);
+
+    // Second use should fail (one-time)
+    const second = consumePairCode(pc.code);
+    expect(second).toBeNull();
+  });
+
+  it("expired code returns null", () => {
+    const device = createDevice("fp-pair-expired", "trusted");
+    // Manually insert an expired code
+    db.prepare(
+      "INSERT INTO pair_codes (code, created_by, expires_at) VALUES (?, ?, ?)",
+    ).run("999999", device.id, Date.now() - 1000);
+
+    const result = consumePairCode("999999");
+    expect(result).toBeNull();
+  });
+
+  it("invalid code returns null", () => {
+    const result = consumePairCode("000000");
+    expect(result).toBeNull();
+  });
+});
+
+describe("store: computeFingerprint", () => {
+  it("produces consistent 16-char hex fingerprints", () => {
+    const fp = computeFingerprint("Mozilla/5.0", "en-US");
+    expect(fp).toHaveLength(16);
+    expect(fp).toMatch(/^[a-f0-9]{16}$/);
+
+    // Same input => same output
+    const fp2 = computeFingerprint("Mozilla/5.0", "en-US");
+    expect(fp2).toBe(fp);
+  });
+
+  it("different inputs produce different fingerprints", () => {
+    const fp1 = computeFingerprint("Chrome/120", "en-US");
+    const fp2 = computeFingerprint("Safari/17", "en-US");
+    expect(fp1).not.toBe(fp2);
+  });
+});

package/tests/tunnel.test.js

@@ -0,0 +1,67 @@
+/**
+ * Unit tests for tunnel support (CLI arg parsing + URL building).
+ * Does NOT spawn cloudflared — pure logic tests only.
+ */
+
+import { describe, it, expect } from "vitest";
+import { parseTunnelArgs, buildTunnelAccessUrl } from "../src/tunnel.js";
+
+// ── parseTunnelArgs ─────────────────────────────────────────────
+
+describe("parseTunnelArgs", () => {
+  it("returns auto when no tunnel flags present", () => {
+    const result = parseTunnelArgs(["node", "server.js"]);
+    expect(result.tunnelMode).toBe("auto");
+  });
+
+  it("returns enable when --tunnel is passed", () => {
+    const result = parseTunnelArgs(["node", "server.js", "--tunnel"]);
+    expect(result.tunnelMode).toBe("enable");
+  });
+
+  it("returns disable when --no-tunnel is passed", () => {
+    const result = parseTunnelArgs(["node", "server.js", "--no-tunnel"]);
+    expect(result.tunnelMode).toBe("disable");
+  });
+
+  it("--no-tunnel takes precedence over --tunnel", () => {
+    const result = parseTunnelArgs(["node", "server.js", "--tunnel", "--no-tunnel"]);
+    expect(result.tunnelMode).toBe("disable");
+  });
+
+  it("works with other flags mixed in", () => {
+    const result = parseTunnelArgs(["node", "server.js", "--password", "secret", "--tunnel"]);
+    expect(result.tunnelMode).toBe("enable");
+  });
+
+  it("ignores unrelated flags", () => {
+    const result = parseTunnelArgs(["node", "server.js", "--password", "secret", "--port", "9000"]);
+    expect(result.tunnelMode).toBe("auto");
+  });
+});
+
+// ── buildTunnelAccessUrl ────────────────────────────────────────
+
+describe("buildTunnelAccessUrl", () => {
+  const BASE = "https://abc-xyz.trycloudflare.com";
+
+  it("appends token when token auth is used", () => {
+    const url = buildTunnelAccessUrl(BASE, "mytoken123", null);
+    expect(url).toBe(`${BASE}?token=mytoken123`);
+  });
+
+  it("returns plain URL when password auth is used (no token)", () => {
+    const url = buildTunnelAccessUrl(BASE, null, "mypassword");
+    expect(url).toBe(BASE);
+  });
+
+  it("returns plain URL when no auth", () => {
+    const url = buildTunnelAccessUrl(BASE, null, null);
+    expect(url).toBe(BASE);
+  });
+
+  it("appends token even when password is also set (token takes priority)", () => {
+    const url = buildTunnelAccessUrl(BASE, "tok", "pw");
+    expect(url).toBe(`${BASE}?token=tok`);
+  });
+});