@phystack/device-simulator 6.3.0

package/src/commands/run.ts

@@ -0,0 +1,518 @@
+import chalk from "chalk";
+import path from "path";
+import fs from "fs-extra";
+import { spawn, spawnSync, execSync } from "child_process";
+import { io as socketIOClient } from "socket.io-client";
+import { getAppConfigByPath, saveAppConfig } from "../utils/simulator-config";
+import { AppConfig, AppTypeEnum, TwinTypeEnum } from "../simulator/types";
+
+const SIMULATOR_URL = "http://localhost:55000";
+
+const APP_TYPE_TO_TWIN_TYPE: Record<
+  AppTypeEnum,
+  TwinTypeEnum.Screen | TwinTypeEnum.Edge
+> = {
+  [AppTypeEnum.Screen]: TwinTypeEnum.Screen,
+  [AppTypeEnum.Edge]: TwinTypeEnum.Edge,
+};
+
+const SUPPORTED_APP_TYPES = new Set<string>(Object.values(AppTypeEnum));
+
+// Test seam: these pure helpers are covered by unit tests in __tests__/.
+// They carry no side effects and are exported solely so the test suite can
+// assert arg-parsing/type-detection/docker-arg behavior without spawning a
+// dev server or Docker. Runtime behavior is unchanged.
+export function resolveAppType(
+  optionType?: string,
+  pkgType?: string,
+): AppTypeEnum {
+  const raw = (optionType || pkgType || "").toLowerCase();
+  if (!raw) {
+    throw new Error(
+      'Cannot detect app type. Set "application-type" in package.json or pass --type.',
+    );
+  }
+  if (!SUPPORTED_APP_TYPES.has(raw)) {
+    throw new Error(
+      `Unsupported app type "${raw}". Supported types: ${[...SUPPORTED_APP_TYPES].join(", ")}`,
+    );
+  }
+  return raw as AppTypeEnum;
+}
+
+async function tryReadSettingsFiles(
+  appPath: string,
+  files: string[],
+): Promise<Record<string, any> | null> {
+  for (const settingsPath of files) {
+    if (await fs.pathExists(settingsPath)) {
+      try {
+        const data = await fs.readJSON(settingsPath);
+        const settings = data?.app?.gridApp?.settings;
+        if (settings) {
+          console.log(
+            chalk.dim(
+              `Read settings from ${path.relative(appPath, settingsPath)}`,
+            ),
+          );
+          return settings;
+        }
+      } catch (err) {
+        console.log(
+          `[simulator] Failed to read ${path.relative(appPath, settingsPath)}: ${err.message}`,
+        );
+      }
+    }
+  }
+  return null;
+}
+
+async function readLocalSettings(
+  appPath: string,
+  settingsDir = "src/settings",
+): Promise<Record<string, any>> {
+  const settingsFiles = [path.join(appPath, settingsDir, "index.json")];
+
+  const settings = await tryReadSettingsFiles(appPath, settingsFiles);
+  if (settings) return settings;
+
+  // If neither exists, try running init-settings.js then retry
+  const initScript = path.join(appPath, "scripts", "init-settings.js");
+  if (await fs.pathExists(initScript)) {
+    console.log(chalk.dim("No settings found, running init-settings.js..."));
+    try {
+      execSync("node scripts/init-settings.js", {
+        cwd: appPath,
+        stdio: "pipe",
+      });
+    } catch (err) {
+      console.log(`[simulator] init-settings.js failed: ${err.message}`);
+    }
+
+    const retrySettings = await tryReadSettingsFiles(appPath, settingsFiles);
+    if (retrySettings) return retrySettings;
+  }
+
+  return {};
+}
+
+function connectSimulator(): Promise<ReturnType<typeof socketIOClient>> {
+  return new Promise((resolve, reject) => {
+    const socket = socketIOClient(SIMULATOR_URL, {
+      reconnectionAttempts: 1,
+      timeout: 3000,
+    });
+    socket.on("connect", () => resolve(socket));
+    socket.on("connect_error", (err: Error) => {
+      reject(new Error(`Cannot connect to simulator: ${err.message}`));
+    });
+  });
+}
+
+function sendSimulatorMessage(
+  socket: ReturnType<typeof socketIOClient>,
+  payload: Record<string, any>,
+): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error("Timeout waiting for simulator response"));
+    }, 10000);
+
+    socket.emit("simulator", payload, (response: any) => {
+      clearTimeout(timer);
+      resolve(response);
+    });
+  });
+}
+
+async function createTwinViaSimulator(
+  type: TwinTypeEnum.Screen | TwinTypeEnum.Edge,
+  desiredProperties: Record<string, any>,
+  reuseId?: string,
+): Promise<{ id: string }> {
+  const socket = await connectSimulator();
+  try {
+    const response = await sendSimulatorMessage(socket, {
+      method: "createInstanceTwin",
+      data: { type, desiredProperties, id: reuseId },
+    });
+    if (response?.status === "success" && response?.twin) {
+      return response.twin;
+    }
+    throw new Error(response?.message || "Failed to create twin");
+  } finally {
+    socket.disconnect();
+  }
+}
+
+export default async (
+  appPath: string,
+  options: { type?: string; devCommand?: string; settingsDir?: string } = {},
+): Promise<void> => {
+  // 1. Resolve path
+  const resolvedPath = path.resolve(appPath);
+  if (!(await fs.pathExists(resolvedPath))) {
+    console.error(chalk.red(`Path does not exist: ${resolvedPath}`));
+    process.exit(1);
+  }
+
+  // 2. Read package.json
+  const pkgPath = path.join(resolvedPath, "package.json");
+  if (!(await fs.pathExists(pkgPath))) {
+    console.error(
+      chalk.red(
+        `No package.json found at ${resolvedPath}. If this is a Python edge app, ensure the scaffold includes a package.json with "application-type": "edge".`,
+      ),
+    );
+    process.exit(1);
+  }
+
+  const pkg = await fs.readJSON(pkgPath);
+  const appName = pkg.name || path.basename(resolvedPath);
+
+  // 3. Resolve app type
+  const appType = resolveAppType(options.type, pkg["application-type"]);
+
+  const startCommand = resolveStartCommand(options, pkg, appType);
+
+  // 4. Check simulator is running
+  let isRunning = false;
+  try {
+    const socket = await connectSimulator();
+    socket.disconnect();
+    isRunning = true;
+  } catch (err) {
+    console.log(`[simulator] Connection check failed: ${err.message}`);
+    isRunning = false;
+  }
+
+  if (!isRunning) {
+    console.error(
+      chalk.red(
+        "Simulator is not running. Start it first with `phy simulator start`.",
+      ),
+    );
+    process.exit(1);
+  }
+
+  // 5. Twin reconciliation (use "local" as tenantId for config storage)
+  const localTenantId = "local";
+  const appConfig = await getAppConfigByPath(localTenantId, resolvedPath);
+  let twinId: string | undefined = appConfig?.twinId;
+
+  const persistedTwinId = twinId;
+
+  const localSettings = await readLocalSettings(
+    resolvedPath,
+    options.settingsDir,
+  );
+  if (Object.keys(localSettings).length > 0) {
+    console.log(
+      chalk.green(
+        `Loaded ${Object.keys(localSettings).length} settings from local files`,
+      ),
+    );
+  }
+
+  // Always (re)create twin with fresh settings — reuse persisted ID for stable twin across restarts
+  const twinType = APP_TYPE_TO_TWIN_TYPE[appType];
+  if (persistedTwinId) {
+    console.log(
+      chalk.dim(`Reusing instance ID ${persistedTwinId} for ${appName}`),
+    );
+  } else {
+    console.log(
+      chalk.dim(`Creating new ${appType} instance for ${appName}...`),
+    );
+  }
+  const twin = await createTwinViaSimulator(
+    twinType,
+    { settings: localSettings, appName, appVersion: pkg.version || "0.0.0" },
+    persistedTwinId,
+  );
+  twinId = twin.id;
+  if (persistedTwinId) {
+    console.log(chalk.green(`Recreated twin with existing ID ${twinId}`));
+  } else {
+    console.log(chalk.green(`Created twin with new ID ${twinId}`));
+  }
+
+  // Save/update app config
+  const newAppConfig: AppConfig = {
+    name: appName,
+    type: appType,
+    path: resolvedPath,
+    twinId,
+    devCommand: startCommand || "docker",
+  };
+  await saveAppConfig(localTenantId, newAppConfig);
+
+  // 6. Type-specific launch
+  if (appType === AppTypeEnum.Screen) {
+    await launchWithStartCommand(
+      resolvedPath,
+      pkg,
+      startCommand!,
+      twinId,
+      appName,
+      appType,
+    );
+  } else if (appType === AppTypeEnum.Edge) {
+    const dockerfilePath = path.join(resolvedPath, "Dockerfile");
+    if (await fs.pathExists(dockerfilePath)) {
+      await launchWithDocker(resolvedPath, pkg, twinId, appName);
+    } else if (startCommand) {
+      await launchWithStartCommand(
+        resolvedPath,
+        pkg,
+        startCommand,
+        twinId,
+        appName,
+        appType,
+      );
+    } else {
+      throw new Error(
+        'No Dockerfile or start script found. Add a Dockerfile or a "start" script in package.json.',
+      );
+    }
+  }
+};
+
+export function resolveStartCommand(
+  options: { devCommand?: string },
+  pkg: any,
+  appType: AppTypeEnum,
+): string | undefined {
+  if (options.devCommand) return options.devCommand;
+  if (pkg.scripts?.start) return "npm start";
+
+  // For edge apps with a Dockerfile, start command is optional
+  if (appType === AppTypeEnum.Edge) return undefined;
+
+  throw new Error(
+    "No start script found in package.json. Pass --dev-command to specify one.",
+  );
+}
+
+async function launchWithStartCommand(
+  resolvedPath: string,
+  pkg: any,
+  startCommand: string,
+  twinId: string,
+  appName: string,
+  appType: AppTypeEnum,
+): Promise<void> {
+  console.log("");
+  console.log(chalk.green.bold(`Starting ${appName}`));
+  console.log(chalk.dim("─".repeat(40)));
+  console.log(`  ${chalk.cyan("Type:")}      ${appType}`);
+  console.log(`  ${chalk.cyan("Twin ID:")}   ${twinId}`);
+  console.log(`  ${chalk.cyan("Path:")}      ${resolvedPath}`);
+  console.log(`  ${chalk.cyan("Command:")}   ${startCommand}`);
+  console.log(chalk.dim("─".repeat(40)));
+  console.log("");
+
+  const env = {
+    ...process.env,
+    TWIN_ID: twinId,
+    PHYSTACK_SIMULATOR_URL: SIMULATOR_URL,
+  };
+
+  const child = spawn(startCommand, {
+    cwd: resolvedPath,
+    stdio: "inherit",
+    env,
+    shell: true,
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Start command exited with code ${code}`));
+      }
+    });
+
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+async function readContainerConfig(appPath: string): Promise<any | null> {
+  const settingsPath = path.join(appPath, "settings.json");
+  if (!(await fs.pathExists(settingsPath))) return null;
+  return fs.readJSON(settingsPath);
+}
+
+export function buildDockerRunArgs(
+  config: any,
+  image: string,
+  twinId: string,
+): string[] {
+  const args = ["run", "--rm", "--name", `simulator-${Date.now()}`];
+
+  // --- Environment variables (mirrors device-phyos: TWIN_ID, TZ, custom Env) ---
+  args.push("-e", `TWIN_ID=${twinId}`);
+  args.push("-e", `PHYSTACK_SIMULATOR_URL=http://host.docker.internal:55000`);
+  if (process.env.TZ) {
+    args.push("-e", `TZ=${process.env.TZ}`);
+  }
+
+  // --- Network: mirrors device-phyos NetworkMode + ExtraHosts ---
+  const isHostNetwork = config?.HostConfig?.NetworkMode === "host";
+  if (isHostNetwork) {
+    args.push("--network", "host");
+    // In host mode, production maps phyos → 127.0.0.1
+    args.push("--add-host", "phyos:127.0.0.1");
+  } else {
+    // Bridge mode (default): simulator needs host.docker.internal for callback
+    args.push("--add-host=host.docker.internal:host-gateway");
+    // In bridge mode, production maps phyos → 172.26.128.1
+    args.push("--add-host", "phyos:host-gateway");
+  }
+
+  if (config) {
+    // Custom env vars from settings.json
+    for (const env of config.Env || []) {
+      args.push("-e", env);
+    }
+
+    // --- Entrypoint (production passes Entrypoint from createOptions) ---
+    if (config.Entrypoint) {
+      const ep = Array.isArray(config.Entrypoint)
+        ? config.Entrypoint
+        : [config.Entrypoint];
+      args.push("--entrypoint", ep[0]);
+    }
+
+    // --- Port bindings ---
+    const ports = config.HostConfig?.PortBindings || {};
+    for (const [containerPort, bindings] of Object.entries(ports)) {
+      for (const binding of bindings as any[]) {
+        args.push(
+          "-p",
+          `${binding.HostPort}:${containerPort.replace("/tcp", "")}`,
+        );
+      }
+    }
+
+    // --- Volume binds ---
+    for (const bind of config.HostConfig?.Binds || []) {
+      args.push("-v", bind);
+    }
+
+    // --- Devices ---
+    for (const device of config.HostConfig?.Devices || []) {
+      args.push("--device", device.PathOnHost);
+    }
+
+    // --- GPU / DeviceRequests (production detects nvidia runtime) ---
+    for (const req of config.HostConfig?.DeviceRequests || []) {
+      const isGpu =
+        req.Capabilities &&
+        req.Capabilities.some((cap: string[]) => cap.includes("gpu"));
+      if (isGpu) {
+        args.push("--gpus", "all");
+      }
+    }
+
+    // --- Privileged ---
+    if (config.HostConfig?.Privileged) {
+      args.push("--privileged");
+    }
+
+    // --- Resource limits ---
+    if (config.HostConfig?.Memory > 0) {
+      args.push("--memory", String(config.HostConfig.Memory));
+    }
+    if (config.HostConfig?.CpuShares > 0) {
+      args.push("--cpu-shares", String(config.HostConfig.CpuShares));
+    }
+
+    // --- Ulimits ---
+    for (const ulimit of config.HostConfig?.Ulimits || []) {
+      args.push("--ulimit", `${ulimit.Name}=${ulimit.Soft}:${ulimit.Hard}`);
+    }
+
+    // --- Read-only root filesystem ---
+    if (config.HostConfig?.ReadonlyRootfs) {
+      args.push("--read-only");
+    }
+  }
+
+  args.push(image);
+
+  // --- Custom CMD (production passes Cmd from createOptions) ---
+  if (config?.Cmd) {
+    args.push(...config.Cmd);
+  }
+
+  return args;
+}
+
+async function launchWithDocker(
+  appPath: string,
+  pkg: any,
+  twinId: string,
+  appName: string,
+): Promise<void> {
+  const imageName = pkg.name.replace(/[^a-z0-9_.-]/g, "-");
+  const imageTag = `${imageName}:${pkg.version || "latest"}`;
+
+  // Build
+  console.log("");
+  console.log(chalk.green.bold(`Building Docker image for ${appName}`));
+  console.log(chalk.dim(`Image: ${imageTag}`));
+  console.log("");
+
+  const buildResult = spawnSync("docker", ["build", "-t", imageTag, "."], {
+    cwd: appPath,
+    stdio: "inherit",
+  });
+  if (buildResult.status !== 0) {
+    throw new Error(`Docker build failed with exit code ${buildResult.status}`);
+  }
+
+  // Read container config from settings.json
+  const containerConfig = await readContainerConfig(appPath);
+
+  // Run
+  const dockerArgs = buildDockerRunArgs(containerConfig, imageTag, twinId);
+
+  console.log("");
+  console.log(chalk.green.bold(`Starting ${appName}`));
+  console.log(chalk.dim("─".repeat(40)));
+  console.log(`  ${chalk.cyan("Type:")}      edge (Docker)`);
+  console.log(`  ${chalk.cyan("Twin ID:")}   ${twinId}`);
+  console.log(`  ${chalk.cyan("Path:")}      ${appPath}`);
+  console.log(`  ${chalk.cyan("Image:")}     ${imageTag}`);
+  console.log(chalk.dim("─".repeat(40)));
+  console.log(chalk.dim(`docker ${dockerArgs.join(" ")}`));
+  console.log("");
+
+  const child = spawn("docker", dockerArgs, {
+    cwd: appPath,
+    stdio: "inherit",
+  });
+
+  // Graceful shutdown
+  const containerName = dockerArgs[dockerArgs.indexOf("--name") + 1];
+  const cleanup = () => {
+    spawnSync("docker", ["stop", containerName], { stdio: "pipe" });
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+
+  await new Promise<void>((resolve, reject) => {
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Docker exited with code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}