@phystack/device-simulator 6.3.0

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

@@ -0,0 +1,181 @@
+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;
+    }
+  });
+});

package/src/commands/list.ts

@@ -0,0 +1,25 @@
+import { listSimulators } from "../utils/simulator-config";
+
+export default function simulatorList(): void {
+  const devices = listSimulators();
+
+  if (devices.length === 0) {
+    console.log(
+      'No provisioned simulators. Use "phy simulator start --connect <name>" to create one.',
+    );
+    return;
+  }
+
+  const header = `${"NAME".padEnd(20)} ${"ENV".padEnd(8)} ${"DEVICE ID".padEnd(38)} PROVISIONED`;
+  console.log(header);
+  console.log("-".repeat(header.length));
+
+  for (const d of devices) {
+    const envLabel =
+      d.environment === "prod" || !d.environment ? "" : d.environment;
+    const date = d.provisionedAt ? d.provisionedAt.split("T")[0] : "unknown";
+    console.log(
+      `${d.name.padEnd(20)} ${envLabel.padEnd(8)} ${d.deviceId.padEnd(38)} ${date}`,
+    );
+  }
+}

package/src/commands/remove.ts

@@ -0,0 +1,16 @@
+import { removeSimulator } from "../utils/simulator-config";
+
+export default function simulatorRemove(name: string): void {
+  if (!name) {
+    console.error("Usage: phy simulator remove <name>");
+    process.exit(1);
+  }
+
+  const removed = removeSimulator(name);
+  if (removed) {
+    console.log(`Removed simulator "${name}".`);
+  } else {
+    console.error(`Simulator "${name}" not found.`);
+    process.exit(1);
+  }
+}