@phystack/device-simulator 6.3.4 → 6.3.6

package/src/__tests__/e2e/binary.e2e.test.ts

@@ -1,394 +0,0 @@
-import { afterAll, describe, expect, test } from "bun:test";
-import { spawn, spawnSync, type ChildProcess } from "child_process";
-import fs from "fs";
-import net from "net";
-import os from "os";
-import path from "path";
-import { fileURLToPath } from "url";
-import { io as socketIOClient, type Socket } from "socket.io-client";
-
-// --- Locate package root + the compiled binary ----------------------------
-const PACKAGE_ROOT = path.resolve(
-  path.dirname(fileURLToPath(import.meta.url)),
-  "../../..",
-);
-const BINARY = path.join(PACKAGE_ROOT, "device-simulator-test");
-
-// Build the host binary once, here, if it isn't already present. This is the
-// crux of the e2e suite: every assertion below runs against the COMPILED Bun
-// binary (a child process), never against the TypeScript source.
-function ensureBinaryBuilt(): void {
-  if (fs.existsSync(BINARY)) return;
-  const result = spawnSync(
-    "bash",
-    ["build-binary.sh", "", "./device-simulator-test"],
-    {
-      cwd: PACKAGE_ROOT,
-      stdio: "pipe",
-      encoding: "utf8",
-    },
-  );
-  if (result.status !== 0) {
-    throw new Error(
-      `Failed to build the device-simulator test binary: ${result.stderr || result.stdout}`,
-    );
-  }
-}
-ensureBinaryBuilt();
-
-// Each e2e gets its own throwaway HOME so the child binary's config-paths
-// (CONFIG_DIR = $HOME/.config/phystack-cli) resolve under a temp dir — never the
-// real home. The binary reads HOME from its spawn env (process env, not the OS
-// user db, for the child). Tracked for afterAll cleanup.
-const tempHomes: string[] = [];
-function makeTempHome(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sim-e2e-home-"));
-  tempHomes.push(dir);
-  return dir;
-}
-
-// Track spawned simulator processes so we always kill them, even on assertion
-// failure (cleanup is the sanctioned use of afterAll/finally per the test rules).
-const runningProcesses: ChildProcess[] = [];
-function trackProcess(child: ChildProcess): ChildProcess {
-  runningProcesses.push(child);
-  return child;
-}
-
-afterAll(() => {
-  for (const child of runningProcesses) {
-    if (!child.killed) {
-      try {
-        child.kill("SIGKILL");
-      } catch (error) {
-        console.error(
-          `Failed to kill simulator process ${child.pid}: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      }
-    }
-  }
-  for (const dir of tempHomes) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// --- Helpers ---------------------------------------------------------------
-
-function runBinary(
-  args: string[],
-  home: string,
-): { status: number | null; stdout: string; stderr: string } {
-  const result = spawnSync(BINARY, args, {
-    env: { ...process.env, HOME: home, USERPROFILE: home },
-    encoding: "utf8",
-    timeout: 15000,
-  });
-  return {
-    status: result.status,
-    stdout: result.stdout ?? "",
-    stderr: result.stderr ?? "",
-  };
-}
-
-function getFreePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.unref();
-    server.on("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      if (address && typeof address === "object") {
-        const { port } = address;
-        server.close(() => resolve(port));
-      } else {
-        server.close(() =>
-          reject(new Error("Could not determine a free port")),
-        );
-      }
-    });
-  });
-}
-
-function waitForListening(port: number, timeoutMs = 10000): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  return new Promise((resolve, reject) => {
-    const attempt = () => {
-      const socket = net.connect(port, "127.0.0.1");
-      socket.on("connect", () => {
-        socket.end();
-        resolve();
-      });
-      socket.on("error", () => {
-        socket.destroy();
-        if (Date.now() > deadline) {
-          reject(
-            new Error(
-              `Simulator did not start listening on port ${port} in time`,
-            ),
-          );
-        } else {
-          setTimeout(attempt, 100);
-        }
-      });
-    };
-    attempt();
-  });
-}
-
-function startSimulator(port: number, home: string): ChildProcess {
-  const child = spawn(BINARY, ["start", "--port", String(port)], {
-    env: { ...process.env, HOME: home, USERPROFILE: home },
-    stdio: "pipe",
-  });
-  return trackProcess(child);
-}
-
-function connectClient(port: number): Promise<Socket> {
-  return new Promise((resolve, reject) => {
-    const socket = socketIOClient(`http://localhost:${port}`, {
-      reconnectionAttempts: 1,
-      timeout: 5000,
-    });
-    socket.on("connect", () => resolve(socket));
-    socket.on("connect_error", (error: Error) =>
-      reject(new Error(`Cannot connect to simulator: ${error.message}`)),
-    );
-    setTimeout(
-      () => reject(new Error("Timed out connecting to simulator")),
-      8000,
-    );
-  });
-}
-
-function emitSimulator(
-  socket: Socket,
-  payload: Record<string, unknown>,
-): Promise<any> {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(
-      () => reject(new Error("Timed out waiting for simulator ack")),
-      8000,
-    );
-    socket.emit("simulator", payload, (response: any) => {
-      clearTimeout(timer);
-      resolve(response);
-    });
-  });
-}
-
-// --- 1. CLI surface parity -------------------------------------------------
-
-describe("e2e: CLI surface (compiled binary)", () => {
-  test("--help lists every command", () => {
-    const home = makeTempHome();
-    const { stdout, status } = runBinary(["--help"], home);
-    expect(status).toBe(0);
-    expect(stdout).toContain("start");
-    expect(stdout).toContain("run");
-    expect(stdout).toContain("list");
-    expect(stdout).toContain("remove");
-    expect(stdout).toContain("Local device simulator for app development");
-  });
-
-  test("start --help shows the exact option strings and defaults", () => {
-    const home = makeTempHome();
-    const { stdout } = runBinary(["start", "--help"], home);
-    expect(stdout).toContain("-p, --port <port>");
-    expect(stdout).toContain('(default: "55000")');
-    expect(stdout).toContain("--connect <name>");
-  });
-
-  test("run --help shows the type / dev-command / settings-dir options", () => {
-    const home = makeTempHome();
-    const { stdout } = runBinary(["run", "--help"], home);
-    expect(stdout).toContain("--type <type>");
-    expect(stdout).toContain("--dev-command <command>");
-    expect(stdout).toContain("--settings-dir <path>");
-    expect(stdout).toMatch(/run \[options\] <path>/);
-  });
-
-  test("--version prints a semver", () => {
-    const home = makeTempHome();
-    const { stdout, status } = runBinary(["--version"], home);
-    expect(status).toBe(0);
-    expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
-  });
-});
-
-// --- 2. list / remove against a temp HOME ---------------------------------
-
-describe("e2e: list / remove persistence contract (compiled binary)", () => {
-  test("seeded simulator shows in list, then remove deletes it", () => {
-    const home = makeTempHome();
-    const simulatorsDir = path.join(
-      home,
-      ".config",
-      "phystack-cli",
-      "simulators",
-    );
-    fs.mkdirSync(simulatorsDir, { recursive: true });
-
-    const seeded = {
-      name: "foo",
-      deviceId: "device-foo-123",
-      accessKey: "key-foo",
-      serialNumber: "SIM-FOO",
-      environment: "dev",
-      provisionedAt: "2026-06-16T12:00:00.000Z",
-      tenantId: "tenant-foo",
-    };
-    fs.writeFileSync(
-      path.join(simulatorsDir, "foo.json"),
-      JSON.stringify(seeded, null, 2),
-    );
-
-    const listed = runBinary(["list"], home);
-    expect(listed.status).toBe(0);
-    expect(listed.stdout).toContain("foo");
-    expect(listed.stdout).toContain("device-foo-123");
-
-    const removed = runBinary(["remove", "foo"], home);
-    expect(removed.status).toBe(0);
-    expect(removed.stdout).toContain('Removed simulator "foo".');
-    expect(fs.existsSync(path.join(simulatorsDir, "foo.json"))).toBe(false);
-
-    const emptyList = runBinary(["list"], home);
-    expect(emptyList.stdout).toContain("No provisioned simulators");
-  });
-
-  test("remove of a non-existent simulator exits non-zero", () => {
-    const home = makeTempHome();
-    const { status, stderr } = runBinary(["remove", "ghost"], home);
-    expect(status).not.toBe(0);
-    expect(stderr).toContain('Simulator "ghost" not found.');
-  });
-
-  test("list with no config prints the empty-state hint", () => {
-    const home = makeTempHome();
-    const { stdout, status } = runBinary(["list"], home);
-    expect(status).toBe(0);
-    expect(stdout).toContain("No provisioned simulators");
-  });
-});
-
-// --- 3. start server + socket.io handshake (the heart) --------------------
-
-describe("e2e: start server + socket.io protocol (compiled binary)", () => {
-  test("full twin handshake: status, create, get, report patch echo", async () => {
-    const home = makeTempHome();
-    const port = await getFreePort();
-    const child = startSimulator(port, home);
-    let client: Socket | undefined;
-
-    try {
-      await waitForListening(port);
-      client = await connectClient(port);
-
-      // ping → pong
-      expect(await emitSimulator(client, { method: "ping" })).toEqual({
-        status: "success",
-        message: "pong",
-      });
-
-      // getDeviceStatus reports the synthetic local Device twin. tenantId is the
-      // deterministic mockObjectId('local') the simulator derives at startup.
-      const status = await emitSimulator(client, { method: "getDeviceStatus" });
-      expect(status.status).toBe("success");
-      expect(status.socketConnected).toBe(true);
-      expect(status.tenantId).toBe("25bf8e1a2393f1108d37029b");
-      expect(status.displayName).toBe("Local Simulator");
-      expect(status.twins.Device).toHaveLength(1);
-
-      // createInstanceTwin registers a Screen twin and echoes it back.
-      const created = await emitSimulator(client, {
-        method: "createInstanceTwin",
-        data: { type: "Screen", desiredProperties: { appName: "e2e-app" } },
-      });
-      expect(created.status).toBe("success");
-      const twinId = created.twin.id as string;
-      expect(twinId).toBeTruthy();
-      expect(created.twin.type).toBe("Screen");
-      expect(created.twin.properties.desired).toEqual({ appName: "e2e-app" });
-
-      // getTwinById round-trips the freshly created twin.
-      const fetched = await emitSimulator(client, {
-        method: "getTwinById",
-        data: { twinId },
-      });
-      expect(fetched.status).toBe("success");
-      expect(fetched.twin.id).toBe(twinId);
-
-      // Subscribe to the twin so the reported-property patch is echoed back as a
-      // twinMessage/twinUpdated to this socket.
-      const twinUpdate = new Promise<any>((resolve, reject) => {
-        const timer = setTimeout(
-          () => reject(new Error("No twinUpdated received")),
-          8000,
-        );
-        client!.on("twinMessage", (message: any) => {
-          if (message?.method === "twinUpdated" && message?.twinId === twinId) {
-            clearTimeout(timer);
-            resolve(message);
-          }
-        });
-      });
-      await emitSimulator(client, { method: "twinSubscribe", twinId });
-
-      // reportScreenTwinProperties merges reported props and emits twinUpdated.
-      const reported = await emitSimulator(client, {
-        method: "reportScreenTwinProperties",
-        twinId,
-        data: { online: true },
-      });
-      expect(reported.status).toBe("success");
-      expect(reported.twin.properties.reported).toEqual({ online: true });
-
-      // The simulator pushed the update back over the socket (twinMessage).
-      const echoed = await twinUpdate;
-      expect(echoed.data.id).toBe(twinId);
-      expect(echoed.data.properties.reported).toEqual({ online: true });
-
-      // Unknown method → structured error.
-      expect(await emitSimulator(client, { method: "bogusMethod" })).toEqual({
-        status: "error",
-        message: "Unknown method: bogusMethod",
-      });
-    } finally {
-      if (client) client.disconnect();
-      child.kill("SIGTERM");
-    }
-  });
-
-  test("start persists the device identity under the temp HOME (not the real home)", async () => {
-    const home = makeTempHome();
-    const port = await getFreePort();
-    const child = startSimulator(port, home);
-
-    try {
-      await waitForListening(port);
-      const deviceConfigPath = path.join(
-        home,
-        ".config",
-        "phystack-cli",
-        "simulator",
-        "tenants",
-        "local",
-        "device.json",
-      );
-      // Give the start sequence a beat to flush the device config to disk.
-      const deadline = Date.now() + 5000;
-      while (!fs.existsSync(deviceConfigPath) && Date.now() < deadline) {
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
-      expect(fs.existsSync(deviceConfigPath)).toBe(true);
-      const config = JSON.parse(fs.readFileSync(deviceConfigPath, "utf8"));
-      expect(config.tenantId).toBe("25bf8e1a2393f1108d37029b");
-      expect(typeof config.deviceId).toBe("string");
-      expect(typeof config.deviceTwinId).toBe("string");
-    } finally {
-      child.kill("SIGTERM");
-    }
-  });
-});

package/src/__tests__/preload.ts

@@ -1,44 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-
-// Bun runs every test file in a SINGLE process with a SHARED module registry.
-// config-paths.ts computes CONFIG_DIR from os.homedir() at import time, and
-// os.homedir() ignores process.env.HOME on macOS/Linux (it reads the OS user
-// database). If any test file imports config-paths (directly or transitively,
-// e.g. via commands/run -> utils/simulator-config) before an override is in
-// place, CONFIG_DIR locks onto the REAL ~/.config/phystack-cli and every later
-// override is too late — tests then read/write the user's real config.
-//
-// This preload runs BEFORE any test module is evaluated (wired via
-// bunfig.toml [test].preload), so it is the single, authoritative place to
-// redirect os.homedir() to a throwaway temp dir for the whole suite. Persistence
-// tests share this one config root; they use unique device/tenant/simulator
-// names so they don't collide.
-//
-// Exported so individual test files can reference the same root and assert
-// isolation.
-export const SUITE_TEST_HOME: string = fs.mkdtempSync(
-  path.join(os.tmpdir(), "ps-sim-suite-home-"),
-);
-
-const realHomedir = os.homedir;
-(os as { homedir: () => string }).homedir = () => SUITE_TEST_HOME;
-process.env.HOME = SUITE_TEST_HOME;
-process.env.USERPROFILE = SUITE_TEST_HOME;
-
-// Best-effort cleanup of the suite temp dir when the process exits. Restoring
-// the original homedir keeps any post-test tooling honest.
-process.on("exit", () => {
-  (os as { homedir: () => string }).homedir = realHomedir;
-  try {
-    fs.rmSync(SUITE_TEST_HOME, { recursive: true, force: true });
-  } catch (error) {
-    // Surface but don't fail the run — the temp dir is under os.tmpdir().
-    console.error(
-      `Failed to remove suite test home ${SUITE_TEST_HOME}: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    );
-  }
-});

package/src/command.ts

@@ -1,66 +0,0 @@
-import { Command } from "commander";
-import { handleError } from "./utils";
-import start from "./commands/start";
-import run from "./commands/run";
-import simulatorList from "./commands/list";
-import simulatorRemove from "./commands/remove";
-
-// Re-export the simulator domain types so consumers (e.g. the legacy CLI's
-// utils/simulator-config) can resolve them from the package rather than the
-// now-removed tools/cli/src/simulator/ tree.
-export type {
-  SimulatorConfig,
-  DeviceConfig,
-  AppConfig,
-  TwinResponse,
-  EventPayload,
-} from "./simulator/types";
-export { AppTypeEnum, TwinTypeEnum } from "./simulator/types";
-export type { SimulatorConnectConfig } from "./utils/simulator-config";
-
-/**
- * Build the `simulator` command tree as a standalone commander Command so the
- * legacy CLI (tools/cli) can `program.addCommand(buildSimulatorCommand())` and
- * preserve the `phy simulator …` surface unchanged.
- */
-export function buildSimulatorCommand() {
-  const simulator = new Command("simulator");
-  simulator.description("Local device simulator for app development");
-
-  simulator
-    .command("start")
-    .description("Start the local simulator server")
-    .option("-p, --port <port>", "Port to listen on", "55000")
-    .option("--connect <name>", "Connect to phyhub as a provisioned device")
-    .action(handleError(start));
-
-  simulator
-    .command("run <path>")
-    .description(
-      "Run an app connected to the simulator (reconciles twin, spawns dev server)",
-    )
-    .option("--type <type>", "Override app type detection (screen or edge)")
-    .option(
-      "--dev-command <command>",
-      "Override dev command (default: npm run dev)",
-    )
-    .option(
-      "--settings-dir <path>",
-      "Settings directory path (default: src/settings)",
-    )
-    .action(handleError(run));
-
-  simulator
-    .command("list")
-    .description("List all provisioned simulator devices")
-    .action(simulatorList);
-
-  simulator
-    .command("remove <name>")
-    .description("Remove a saved simulator device")
-    .action(simulatorRemove);
-
-  return simulator;
-}
-
-export default buildSimulatorCommand;

package/src/commands/__tests__/run-helpers.test.ts

@@ -1,181 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  buildDockerRunArgs,
-  resolveAppType,
-  resolveStartCommand,
-} from "../run";
-import { AppTypeEnum } from "../../simulator/types";
-
-describe("resolveAppType", () => {
-  test("option type takes precedence over package type", () => {
-    expect(resolveAppType("screen", "edge")).toBe(AppTypeEnum.Screen);
-  });
-
-  test("falls back to the package application-type when no option", () => {
-    expect(resolveAppType(undefined, "edge")).toBe(AppTypeEnum.Edge);
-  });
-
-  test("lowercases the raw value before matching", () => {
-    expect(resolveAppType("SCREEN")).toBe(AppTypeEnum.Screen);
-  });
-
-  test("throws when neither option nor package type is provided", () => {
-    expect(() => resolveAppType()).toThrow(
-      'Cannot detect app type. Set "application-type" in package.json or pass --type.',
-    );
-  });
-
-  test("throws on an unsupported type", () => {
-    expect(() => resolveAppType("cloud")).toThrow(
-      /Unsupported app type "cloud"/,
-    );
-  });
-});
-
-describe("resolveStartCommand", () => {
-  test("explicit --dev-command wins", () => {
-    expect(
-      resolveStartCommand(
-        { devCommand: "bun run dev" },
-        {},
-        AppTypeEnum.Screen,
-      ),
-    ).toBe("bun run dev");
-  });
-
-  test("uses `npm start` when package.json has a start script", () => {
-    expect(
-      resolveStartCommand(
-        {},
-        { scripts: { start: "node index.js" } },
-        AppTypeEnum.Screen,
-      ),
-    ).toBe("npm start");
-  });
-
-  test("edge app without a start script returns undefined (Docker path)", () => {
-    expect(resolveStartCommand({}, {}, AppTypeEnum.Edge)).toBeUndefined();
-  });
-
-  test("screen app without a start script throws", () => {
-    expect(() => resolveStartCommand({}, {}, AppTypeEnum.Screen)).toThrow(
-      "No start script found in package.json. Pass --dev-command to specify one.",
-    );
-  });
-});
-
-describe("buildDockerRunArgs", () => {
-  const TWIN_ID = "twin-xyz";
-  const IMAGE = "my-image:1.0.0";
-
-  test("null config: base args, TWIN_ID + bridge-mode host mapping, image last", () => {
-    const args = buildDockerRunArgs(null, IMAGE, TWIN_ID);
-
-    expect(args[0]).toBe("run");
-    expect(args).toContain("--rm");
-    expect(args[args.length - 1]).toBe(IMAGE);
-
-    const twinEnvIndex = args.indexOf("TWIN_ID=twin-xyz");
-    expect(twinEnvIndex).toBeGreaterThan(-1);
-    expect(args[twinEnvIndex - 1]).toBe("-e");
-
-    // Bridge mode (no host network): host.docker.internal + phyos→host-gateway
-    expect(args).toContain("--add-host=host.docker.internal:host-gateway");
-    const phyosIndex = args.indexOf("phyos:host-gateway");
-    expect(phyosIndex).toBeGreaterThan(-1);
-    expect(args[phyosIndex - 1]).toBe("--add-host");
-
-    expect(args).toContain("-e");
-    expect(args).toContain(
-      "PHYSTACK_SIMULATOR_URL=http://host.docker.internal:55000",
-    );
-  });
-
-  test("host network mode switches the host mappings", () => {
-    const args = buildDockerRunArgs(
-      { HostConfig: { NetworkMode: "host" } },
-      IMAGE,
-      TWIN_ID,
-    );
-    expect(args).toContain("--network");
-    expect(args).toContain("host");
-    expect(args).toContain("phyos:127.0.0.1");
-    expect(args).not.toContain("--add-host=host.docker.internal:host-gateway");
-  });
-
-  test("custom Env, Entrypoint, port bindings, binds and Cmd are translated", () => {
-    const config = {
-      Env: ["FOO=bar", "BAZ=qux"],
-      Entrypoint: ["/entry.sh"],
-      Cmd: ["--flag", "value"],
-      HostConfig: {
-        PortBindings: { "8080/tcp": [{ HostPort: "9090" }] },
-        Binds: ["/host/path:/container/path"],
-      },
-    };
-    const args = buildDockerRunArgs(config, IMAGE, TWIN_ID);
-
-    expect(args).toContain("FOO=bar");
-    expect(args).toContain("BAZ=qux");
-
-    const entrypointIndex = args.indexOf("--entrypoint");
-    expect(entrypointIndex).toBeGreaterThan(-1);
-    expect(args[entrypointIndex + 1]).toBe("/entry.sh");
-
-    const portIndex = args.indexOf("-p");
-    expect(portIndex).toBeGreaterThan(-1);
-    expect(args).toContain("9090:8080");
-
-    const volIndex = args.indexOf("-v");
-    expect(args[volIndex + 1]).toBe("/host/path:/container/path");
-
-    // Cmd is appended AFTER the image.
-    const imageIndex = args.indexOf(IMAGE);
-    expect(args.slice(imageIndex + 1)).toEqual(["--flag", "value"]);
-  });
-
-  test("resource limits, privileged, readonly, ulimits, gpu device requests", () => {
-    const config = {
-      HostConfig: {
-        Privileged: true,
-        ReadonlyRootfs: true,
-        Memory: 536870912,
-        CpuShares: 512,
-        Ulimits: [{ Name: "nofile", Soft: 1024, Hard: 2048 }],
-        Devices: [{ PathOnHost: "/dev/ttyUSB0" }],
-        DeviceRequests: [{ Capabilities: [["gpu"]] }],
-      },
-    };
-    const args = buildDockerRunArgs(config, IMAGE, TWIN_ID);
-
-    expect(args).toContain("--privileged");
-    expect(args).toContain("--read-only");
-
-    const memIndex = args.indexOf("--memory");
-    expect(args[memIndex + 1]).toBe("536870912");
-
-    const cpuIndex = args.indexOf("--cpu-shares");
-    expect(args[cpuIndex + 1]).toBe("512");
-
-    const ulimitIndex = args.indexOf("--ulimit");
-    expect(args[ulimitIndex + 1]).toBe("nofile=1024:2048");
-
-    const deviceIndex = args.indexOf("--device");
-    expect(args[deviceIndex + 1]).toBe("/dev/ttyUSB0");
-
-    expect(args).toContain("--gpus");
-    expect(args).toContain("all");
-  });
-
-  test("TZ env is forwarded when set in the environment", () => {
-    const originalTz = process.env.TZ;
-    process.env.TZ = "Europe/Stockholm";
-    try {
-      const args = buildDockerRunArgs(null, IMAGE, TWIN_ID);
-      expect(args).toContain("TZ=Europe/Stockholm");
-    } finally {
-      if (originalTz === undefined) delete process.env.TZ;
-      else process.env.TZ = originalTz;
-    }
-  });
-});