@simplysm/sd-cli 13.0.100 → 14.0.1

package/src/commands/device.ts

@@ -1,140 +0,0 @@
-import path from "path";
-import { fsx } from "@simplysm/core-node";
-import { consola } from "consola";
-import type { SdConfig, SdClientPackageConfig } from "../sd-config.types";
-import { loadSdConfig } from "../utils/sd-config";
-import { Capacitor } from "../capacitor/capacitor";
-import { Electron } from "../electron/electron";
-
-//#region Types
-
-/**
- * Device command options
- */
-export interface DeviceOptions {
-  /** Package name (required) */
-  package: string;
-  /** Development server URL (optional, uses server config from sd.config.ts if not specified) */
-  url?: string;
-  /** Additional options to pass to sd.config.ts */
-  options: string[];
-}
-
-//#endregion
-
-//#region Main
-
-/**
- * Runs an app on an Android device.
- *
- * - Runs app on connected Android device
- * - Connects development server URL to WebView to support Hot Reload
- *
- * @param options - device execution options
- * @returns resolves when complete
- */
-export async function runDevice(options: DeviceOptions): Promise<void> {
-  const { package: packageName, url } = options;
-  const cwd = process.cwd();
-  const logger = consola.withTag("sd:cli:device");
-
-  logger.debug("device start", { package: packageName, url });
-
-  // Load sd.config.ts
-  let sdConfig: SdConfig;
-  try {
-    sdConfig = await loadSdConfig({ cwd, dev: true, options: options.options });
-    logger.debug("sd.config.ts loaded");
-  } catch (err) {
-    logger.error(`Failed to load sd.config.ts: ${err instanceof Error ? err.message : err}`);
-    process.exitCode = 1;
-    return;
-  }
-
-  // Verify package config
-  const pkgConfig = sdConfig.packages[packageName];
-  if (pkgConfig == null) {
-    logger.error(`Package not found: ${packageName}`);
-    process.exitCode = 1;
-    return;
-  }
-
-  if (pkgConfig.target !== "client") {
-    logger.error(`Only client target packages are supported: ${packageName} (current: ${pkgConfig.target})`);
-    process.exitCode = 1;
-    return;
-  }
-
-  const clientConfig: SdClientPackageConfig = pkgConfig;
-  const pkgDir = path.join(cwd, "packages", packageName);
-
-  if (clientConfig.electron != null) {
-    // Run Electron development
-    let serverUrl = url;
-    if (serverUrl == null) {
-      if (typeof clientConfig.server === "number") {
-        serverUrl = `http://localhost:${clientConfig.server}/${packageName}/`;
-      } else {
-        logger.error(
-          `--url option is required. server is set to package name: ${clientConfig.server}`,
-        );
-        process.exitCode = 1;
-        return;
-      }
-    }
-
-    logger.debug("development server URL", { serverUrl });
-
-    logger.start(`Running ${packageName} (electron)...`);
-    try {
-      const electron = await Electron.create(pkgDir, clientConfig.electron, clientConfig.exclude);
-      await electron.run(serverUrl);
-      logger.success("Electron execution completed");
-    } catch (err) {
-      logger.error(`Failed to run Electron: ${err instanceof Error ? err.message : err}`);
-      process.exitCode = 1;
-    }
-  } else if (clientConfig.capacitor != null) {
-    // Run Capacitor device (existing logic)
-    let serverUrl = url;
-    if (serverUrl == null) {
-      if (typeof clientConfig.server === "number") {
-        serverUrl = `http://localhost:${clientConfig.server}/${packageName}/capacitor/`;
-      } else {
-        logger.error(
-          `--url option is required. server is set to package name: ${clientConfig.server}`,
-        );
-        process.exitCode = 1;
-        return;
-      }
-    } else if (!serverUrl.endsWith("/")) {
-      serverUrl = `${serverUrl}/${packageName}/capacitor/`;
-    }
-
-    logger.debug("development server URL", { serverUrl });
-
-    const capPath = path.join(pkgDir, ".capacitor");
-    if (!(await fsx.exists(capPath))) {
-      logger.error(
-        `Capacitor project is not initialized. First run 'pnpm watch ${packageName}'.`,
-      );
-      process.exitCode = 1;
-      return;
-    }
-
-    logger.start(`Running ${packageName} (device)...`);
-    try {
-      const cap = await Capacitor.create(pkgDir, clientConfig.capacitor, clientConfig.exclude);
-      await cap.runOnDevice(serverUrl);
-      logger.success("Device execution completed");
-    } catch (err) {
-      logger.error(`Failed to run device: ${err instanceof Error ? err.message : err}`);
-      process.exitCode = 1;
-    }
-  } else {
-    logger.error(`No electron or capacitor config found: ${packageName}`);
-    process.exitCode = 1;
-  }
-}
-
-//#endregion

package/src/commands/init.ts

@@ -1,113 +0,0 @@
-import path from "path";
-import fs from "fs";
-import crypto from "crypto";
-import readline from "readline";
-import { consola } from "consola";
-import { renderTemplateDir } from "../utils/template";
-import { execa } from "execa";
-import { findPackageRoot } from "../utils/package-utils";
-
-//#region Types
-
-export interface InitOptions {}
-
-//#endregion
-
-//#region Utilities
-
-function isValidScopeName(name: string): boolean {
-  return /^[a-z][a-z0-9-]*$/.test(name);
-}
-
-function prompt(question: string): Promise<string> {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
-//#endregion
-
-//#region Main
-
-/**
- * Initializes a new Simplysm project in the current directory.
- *
- * 1. Check if directory is empty
- * 2. Validate project name (folder name)
- * 3. Prompt for description, port
- * 4. Generate jwtSecret
- * 5. Render Handlebars template
- * 6. Run pnpm install
- */
-export async function runInit(_options: InitOptions): Promise<void> {
-  const cwd = process.cwd();
-  const logger = consola.withTag("sd:cli:init");
-
-  // 1. Check if directory is empty (exclude dotfiles/dotfolders)
-  const entries = fs.readdirSync(cwd).filter((e) => !e.startsWith("."));
-  if (entries.length > 0) {
-    consola.error("Directory is not empty. Please run this from an empty directory.");
-    process.exitCode = 1;
-    return;
-  }
-
-  // 2. Validate project name
-  const projectName = path.basename(cwd);
-  if (!isValidScopeName(projectName)) {
-    consola.error(
-      `Project name "${projectName}" is not valid. Only lowercase letters, numbers, and hyphens are allowed.`,
-    );
-    process.exitCode = 1;
-    return;
-  }
-
-  // 3. Prompt for description
-  const description = await prompt("Project description: ");
-
-  // 4. Prompt for port
-  const portInput = await prompt("Server port (default: 40080): ");
-  const port = portInput !== "" ? Number(portInput) : 40080;
-  if (Number.isNaN(port) || !Number.isInteger(port) || port < 1 || port > 65535) {
-    consola.error("Invalid port number.");
-    process.exitCode = 1;
-    return;
-  }
-
-  // 5. Generate jwtSecret
-  const jwtSecret = `${projectName}-${crypto.randomUUID().slice(0, 8)}`;
-
-  // 6. Render template
-  const pkgRoot = findPackageRoot(import.meta.dirname);
-  const templateDir = path.join(pkgRoot, "templates", "init");
-
-  const context = { projectName, description, port, jwtSecret };
-
-  logger.info("Creating project files...");
-  await renderTemplateDir(templateDir, cwd, context);
-  logger.success("Project files created successfully");
-
-  // 7. Run pnpm install
-  logger.info("Running pnpm install...");
-  await execa("pnpm", ["install"], { cwd });
-  logger.success("pnpm install completed");
-
-  // 8. Completion message
-  consola.box(
-    [
-      "Project created!",
-      "",
-      "Next steps:",
-      "  pnpm dev              Start dev server",
-      "  pnpm build            Production build",
-    ].join("\n"),
-  );
-}
-
-//#endregion

package/src/electron/electron.ts

@@ -1,362 +0,0 @@
-import path from "path";
-import os from "os";
-import fs from "fs";
-import module from "module";
-import { fsx } from "@simplysm/core-node";
-import { consola } from "consola";
-import type { SdElectronConfig } from "../sd-config.types";
-import { execa } from "execa";
-
-/**
- * package.json type
- */
-interface NpmConfig {
-  name: string;
-  version: string;
-  description?: string;
-  dependencies?: Record<string, string>;
-}
-
-/**
- * Electron project management class
- *
- * - Initialize Electron project (create package.json, install dependencies, rebuild native modules)
- * - Build Windows executable (electron-builder)
- * - Run in development mode (load Vite dev server URL)
- */
-export class Electron {
-  private static readonly _logger = consola.withTag("sd:cli:electron");
-
-  private readonly _electronPath: string;
-  private readonly _npmConfig: NpmConfig;
-
-  private constructor(
-    private readonly _pkgPath: string,
-    private readonly _config: SdElectronConfig,
-    npmConfig: NpmConfig,
-    private readonly _exclude: string[],
-  ) {
-    this._npmConfig = npmConfig;
-    this._electronPath = path.resolve(this._pkgPath, ".electron");
-  }
-
-  /**
-   * Create Electron instance (with configuration validation)
-   */
-  static async create(
-    pkgPath: string,
-    config: SdElectronConfig,
-    exclude?: string[],
-  ): Promise<Electron> {
-    Electron._validateConfig(config);
-
-    const npmConfig = await fsx.readJson<NpmConfig>(path.resolve(pkgPath, "package.json"));
-    return new Electron(pkgPath, config, npmConfig, exclude ?? []);
-  }
-
-  /**
-   * Validate configuration
-   */
-  private static _validateConfig(config: SdElectronConfig): void {
-    if (typeof config.appId !== "string" || config.appId.trim() === "") {
-      throw new Error("electron.appId is required.");
-    }
-  }
-
-  /**
-   * Resolve binary path from {pkgPath}/node_modules/.bin/
-   */
-  private _localBin(name: string): string {
-    return path.resolve(this._pkgPath, "node_modules/.bin", name);
-  }
-
-  /**
-   * Execute command (with logging)
-   */
-  private async _exec(
-    cmd: string,
-    args: string[],
-    cwd: string,
-    env?: Record<string, string>,
-  ): Promise<string> {
-    Electron._logger.debug(`executed command: ${cmd} ${args.join(" ")}`);
-    const { stdout: result } = await execa(cmd, args, { cwd, env: { ...process.env, ...env } });
-    Electron._logger.debug(`execution result: ${result}`);
-    return result;
-  }
-
-  //#region Public Methods
-
-  /**
-   * Initialize Electron project
-   *
-   * 1. Create .electron/src/package.json
-   * 2. Run pnpm install
-   * 3. Run electron-rebuild (rebuild native modules)
-   */
-  async initialize(): Promise<void> {
-    const srcPath = path.resolve(this._electronPath, "src");
-
-    // 1. Create package.json
-    await this._setupPackageJson(srcPath);
-
-    // 2. npm install
-    await this._exec("npm", ["install"], srcPath);
-
-    // 3. Rebuild native modules
-    const reinstallDeps = this._config.reinstallDependencies ?? [];
-    if (reinstallDeps.length > 0) {
-      await this._exec(this._localBin("electron-rebuild"), [], srcPath);
-    }
-  }
-
-  /**
-   * Production build
-   *
-   * 1. Bundle electron-main.ts with esbuild
-   * 2. Copy web assets
-   * 3. Create electron-builder configuration
-   * 4. Run electron-builder
-   * 5. Copy build output
-   */
-  async build(outPath: string): Promise<void> {
-    const srcPath = path.resolve(this._electronPath, "src");
-
-    // 1. Bundle electron-main.ts
-    await this._bundleMainProcess(srcPath);
-
-    // 2. Copy web assets (outPath → .electron/src/)
-    await this._copyWebAssets(outPath, srcPath);
-
-    // 3. Create electron-builder configuration and run
-    await this._runElectronBuilder(srcPath);
-
-    // 4. Copy build output
-    await this._copyBuildOutput(outPath);
-  }
-
-  /**
-   * Run in development mode
-   *
-   * 1. Bundle electron-main.ts with esbuild
-   * 2. Create dist/electron/package.json
-   * 3. Run electron .
-   */
-  async run(url?: string): Promise<void> {
-    const electronRunPath = path.resolve(this._pkgPath, "dist/electron");
-
-    // 1. Bundle electron-main.ts
-    await this._bundleMainProcess(electronRunPath);
-
-    // 2. Create package.json
-    await fsx.mkdir(electronRunPath);
-    await fsx.writeJson(
-      path.resolve(electronRunPath, "package.json"),
-      { name: this._npmConfig.name, version: this._npmConfig.version, main: "electron-main.js" },
-      { space: 2 },
-    );
-
-    // 3. Run Electron
-    const runEnv: Record<string, string> = {
-      NODE_ENV: "development",
-      ...this._config.env,
-    };
-
-    if (url != null) {
-      runEnv["ELECTRON_DEV_URL"] = url;
-    }
-
-    await this._exec(this._localBin("electron"), ["."], electronRunPath, runEnv);
-  }
-
-  //#endregion
-
-  //#region Private - Initialization
-
-  /**
-   * Create .electron/src/package.json
-   */
-  private async _setupPackageJson(srcPath: string): Promise<void> {
-    await fsx.mkdir(srcPath);
-
-    const reinstallDeps = this._config.reinstallDependencies ?? [];
-
-    // Extract versions from main package.json that match reinstallDependencies
-    const dependencies: Record<string, string> = {};
-    for (const dep of reinstallDeps) {
-      const version = this._npmConfig.dependencies?.[dep];
-      if (version != null) {
-        dependencies[dep] = version;
-      }
-    }
-
-    // Add exclude packages
-    for (const excludePkg of this._exclude) {
-      if (!(excludePkg in dependencies)) {
-        const version = this._npmConfig.dependencies?.[excludePkg];
-        if (version != null) {
-          dependencies[excludePkg] = version;
-        }
-      }
-    }
-
-    const packageJson: Record<string, unknown> = {
-      name: this._npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
-      version: this._npmConfig.version,
-      description: this._npmConfig.description,
-      main: "electron-main.js",
-      dependencies,
-    };
-
-    if (this._config.postInstallScript != null) {
-      packageJson["scripts"] = { postinstall: this._config.postInstallScript };
-    }
-
-    await fsx.writeJson(path.resolve(srcPath, "package.json"), packageJson, { space: 2 });
-  }
-
-  //#endregion
-
-  //#region Private - Bundling
-
-  /**
-   * Bundle electron-main.ts with esbuild
-   */
-  private async _bundleMainProcess(outDir: string): Promise<void> {
-    const esbuild = await import("esbuild");
-    const entryPoint = path.resolve(this._pkgPath, "src/electron-main.ts");
-
-    if (!(await fsx.exists(entryPoint))) {
-      throw new Error(`electron-main.ts file not found: ${entryPoint}`);
-    }
-
-    const builtinModules = module.builtinModules.flatMap((m) => [m, `node:${m}`]);
-    const reinstallDeps = this._config.reinstallDependencies ?? [];
-
-    await fsx.mkdir(outDir);
-
-    await esbuild.build({
-      entryPoints: [entryPoint],
-      outfile: path.resolve(outDir, "electron-main.js"),
-      platform: "node",
-      target: "node20",
-      format: "cjs",
-      bundle: true,
-      external: ["electron", ...builtinModules, ...reinstallDeps],
-    });
-  }
-
-  //#endregion
-
-  //#region Private - Build
-
-  /**
-   * Copy web assets (build output → .electron/src/)
-   */
-  private async _copyWebAssets(outPath: string, srcPath: string): Promise<void> {
-    const items = await fsx.readdir(outPath);
-    for (const item of items) {
-      // Exclude electron/ subdirectory (prevent self-copying)
-      if (item === "electron") continue;
-
-      const source = path.resolve(outPath, item);
-      const dest = path.resolve(srcPath, item);
-      await fsx.copy(source, dest);
-    }
-  }
-
-  /**
-   * Check if symlink creation is possible (Windows build requirement)
-   */
-  private static _canCreateSymlink(): boolean {
-    const tmpDir = os.tmpdir();
-    const testTarget = path.join(tmpDir, "sd-electron-symlink-test-target.txt");
-    const testLink = path.join(tmpDir, "sd-electron-symlink-test-link.txt");
-
-    try {
-      fs.writeFileSync(testTarget, "test");
-      fs.symlinkSync(testTarget, testLink, "file");
-      const isSymlink = fs.lstatSync(testLink).isSymbolicLink();
-      fs.unlinkSync(testLink);
-      fs.unlinkSync(testTarget);
-      return isSymlink;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Run electron-builder
-   */
-  private async _runElectronBuilder(srcPath: string): Promise<void> {
-    if (!Electron._canCreateSymlink()) {
-      throw new Error(
-        "Symlink creation permission is required to build Electron. Enable Developer mode on Windows.",
-      );
-    }
-
-    const distPath = path.resolve(this._electronPath, "dist");
-
-    const builderConfig: Record<string, unknown> = {
-      appId: this._config.appId,
-      productName: this._npmConfig.description,
-      asar: false,
-      win: {
-        target: this._config.portable ? "portable" : "nsis",
-      },
-      nsis: this._config.nsisOptions ?? {},
-      directories: {
-        app: srcPath,
-        output: distPath,
-      },
-      removePackageScripts: false,
-      npmRebuild: false,
-      forceCodeSigning: false,
-    };
-
-    if (this._config.installerIcon != null) {
-      builderConfig["icon"] = path.resolve(this._pkgPath, this._config.installerIcon);
-    }
-
-    const configFilePath = path.resolve(this._electronPath, "builder-config.json");
-    await fsx.writeJson(configFilePath, builderConfig, { space: 2 });
-
-    await this._exec(
-      this._localBin("electron-builder"),
-      ["--win", "--config", configFilePath],
-      this._pkgPath,
-    );
-  }
-
-  /**
-   * Copy build output (.electron/dist/ → dist/electron/)
-   */
-  private async _copyBuildOutput(outPath: string): Promise<void> {
-    const distPath = path.resolve(this._electronPath, "dist");
-    const electronOutPath = path.resolve(outPath, "electron");
-    await fsx.mkdir(electronOutPath);
-
-    const description = this._npmConfig.description ?? this._npmConfig.name;
-    const version = this._npmConfig.version;
-    const isPortable = this._config.portable === true;
-
-    // electron-builder output filename
-    const builderFileName = `${description} ${isPortable ? "" : "Setup "}${version}.exe`;
-    const sourcePath = path.resolve(distPath, builderFileName);
-
-    if (await fsx.exists(sourcePath)) {
-      // Copy latest file
-      const latestFileName = `${description}${isPortable ? "-portable" : ""}-latest.exe`;
-      await fsx.copy(sourcePath, path.resolve(electronOutPath, latestFileName));
-
-      // Copy per-version file to updates/
-      const updatesPath = path.resolve(electronOutPath, "updates");
-      await fsx.mkdir(updatesPath);
-      await fsx.copy(sourcePath, path.resolve(updatesPath, `${version}.exe`));
-    } else {
-      Electron._logger.warn(`build output not found: ${sourcePath}`);
-    }
-  }
-
-  //#endregion
-}