@simplysm/sd-cli 13.0.93 → 13.0.96

package/src/capacitor/capacitor.ts

@@ -39,6 +39,8 @@ export class Capacitor {
   private static readonly _ANDROID_KEYSTORE_FILE_NAME = "android.keystore";
   private static readonly _LOCK_FILE_NAME = ".capacitor.lock";
   private static readonly _logger = consola.withTag("sd:cli:capacitor");
+  private static readonly _utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+  private static readonly _fallbackDecoder = new TextDecoder("euc-kr");
 
   private readonly _capPath: string;
   private readonly _platforms: string[];
@@ -78,7 +80,7 @@ export class Capacitor {
     if (typeof config.appName !== "string" || config.appName.trim() === "") {
       throw new CapacitorConfigError("capacitor.appName is required.");
     }
-    if (!/^[a-zA-Z0-9 \-]+$/.test(config.appName)) {
+    if (!/^[\p{L}\p{N} \-]+$/u.test(config.appName)) {
       throw new CapacitorConfigError(`capacitor.appName contains invalid characters: ${config.appName}`);
     }
     if (config.platform != null) {
@@ -91,14 +93,47 @@ export class Capacitor {
     }
   }
 
+  /**
+   * Execute a Capacitor CLI command via npx
+   */
+  private async _execCap(args: string[]): Promise<string> {
+    return this._exec("npx", ["cap", ...args], this._capPath);
+  }
+
+  /**
+   * Execute capacitor-assets CLI command via npx
+   */
+  private async _execCapAssets(args: string[]): Promise<string> {
+    return this._exec("npx", ["capacitor-assets", ...args], this._capPath);
+  }
+
   /**
    * Execute command (with logging)
    */
   private async _exec(cmd: string, args: string[], cwd: string): Promise<string> {
     Capacitor._logger.debug(`executed command: ${cmd} ${args.join(" ")}`);
-    const { stdout: result } = await execa(cmd, args, { cwd });
-    Capacitor._logger.debug(`execution result: ${result}`);
-    return result;
+
+    const result = await execa(cmd, args, { cwd, reject: false, encoding: "buffer" });
+    const stdout = Capacitor._decodeOutput(result.stdout);
+
+    if (result.exitCode !== 0) {
+      const stderr = Capacitor._decodeOutput(result.stderr);
+      throw new Error(`${cmd} ${args.join(" ")} failed (exit ${result.exitCode}): ${stderr || stdout}`);
+    }
+
+    Capacitor._logger.debug(`execution result: ${stdout}`);
+    return stdout;
+  }
+
+  /**
+   * Decode command output (UTF-8 first, fallback to EUC-KR for Windows CP949)
+   */
+  private static _decodeOutput(bytes: Uint8Array): string {
+    try {
+      return Capacitor._utf8Decoder.decode(bytes);
+    } catch {
+      return Capacitor._fallbackDecoder.decode(bytes);
+    }
   }
 
   /**
@@ -186,9 +221,9 @@ export class Capacitor {
 
       // 6. Synchronize web assets
       if (changed) {
-        await this._exec("npx", ["cap", "sync"], this._capPath);
+        await this._execCap(["sync"]);
       } else {
-        await this._exec("npx", ["cap", "copy"], this._capPath);
+        await this._execCap(["copy"]);
       }
     } finally {
       await this._releaseLock();
@@ -205,7 +240,7 @@ export class Capacitor {
       const buildType = this._config.debug ? "debug" : "release";
 
       for (const platform of this._platforms) {
-        await this._exec("npx", ["cap", "copy", platform], this._capPath);
+        await this._execCap(["copy", platform]);
 
         if (platform === "android") {
           await this._buildAndroid(outPath, buildType);
@@ -229,10 +264,10 @@ export class Capacitor {
     }
 
     for (const platform of this._platforms) {
-      await this._exec("npx", ["cap", "copy", platform], this._capPath);
+      await this._execCap(["copy", platform]);
 
       try {
-        await this._exec("npx", ["cap", "run", platform], this._capPath);
+        await this._execCap(["run", platform]);
       } catch (err) {
         if (platform === "android") {
           try {
@@ -266,24 +301,22 @@ export class Capacitor {
   //#region Private - Initialization
 
   /**
-   * Basic Capacitor project initialization (package.json, npm install, cap init)
+   * Basic Capacitor project initialization (package.json, pnpm install, cap init)
    */
   private async _initCap(): Promise<boolean> {
     const depChanged = await this._setupNpmConf();
-    if (!depChanged) return false;
+    const nodeModulesExists = await fsx.exists(path.resolve(this._capPath, "node_modules"));
+
+    if (!depChanged && nodeModulesExists) return false;
 
     // pnpm install
-    const installResult = await this._exec("pnpm", ["install"], this._capPath);
-    Capacitor._logger.debug(`pnpm install completed: ${installResult}`);
+    const installResult = await this._exec("npm", ["install"], this._capPath);
+    Capacitor._logger.debug(`npm install completed: ${installResult}`);
 
     // F12: cap init idempotency - execute only when capacitor.config.ts does not exist
     const configPath = path.resolve(this._capPath, "capacitor.config.ts");
     if (!(await fsx.exists(configPath))) {
-      await this._exec(
-        "npx",
-        ["cap", "init", this._config.appName, this._config.appId],
-        this._capPath,
-      );
+      await this._execCap(["init", this._config.appId, this._config.appId]);
     }
 
     // Create default www/index.html
@@ -430,7 +463,7 @@ export default config;
         continue;
       }
 
-      await this._exec("npx", ["cap", "add", platform], this._capPath);
+      await this._execCap(["add", platform]);
     }
   }
 
@@ -475,18 +508,13 @@ export default config;
           })
           .toFile(logoPath);
 
-        await this._exec(
-          "npx",
-          [
-            "@capacitor/assets",
-            "generate",
-            "--iconBackgroundColor",
-            "#ffffff",
-            "--splashBackgroundColor",
-            "#ffffff",
-          ],
-          this._capPath,
-        );
+        await this._execCapAssets([
+          "generate",
+          "--iconBackgroundColor",
+          "#ffffff",
+          "--splashBackgroundColor",
+          "#ffffff",
+        ]);
       } catch (err) {
         Capacitor._logger.warn(
           `icon generation failed: ${err instanceof Error ? err.message : err}. Using default icon.`,

package/src/electron/electron.ts

@@ -58,6 +58,13 @@ export class Electron {
     }
   }
 
+  /**
+   * 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)
    */
@@ -79,7 +86,7 @@ export class Electron {
    * Initialize Electron project
    *
    * 1. Create .electron/src/package.json
-   * 2. Run npm install
+   * 2. Run pnpm install
    * 3. Run electron-rebuild (rebuild native modules)
    */
   async initialize(): Promise<void> {
@@ -94,7 +101,7 @@ export class Electron {
     // 3. Rebuild native modules
     const reinstallDeps = this._config.reinstallDependencies ?? [];
     if (reinstallDeps.length > 0) {
-      await this._exec("npx", ["electron-rebuild"], srcPath);
+      await this._exec(this._localBin("electron-rebuild"), [], srcPath);
     }
   }
 
@@ -128,7 +135,7 @@ export class Electron {
    *
    * 1. Bundle electron-main.ts with esbuild
    * 2. Create dist/electron/package.json
-   * 3. Run npx electron .
+   * 3. Run electron .
    */
   async run(url?: string): Promise<void> {
     const electronRunPath = path.resolve(this._pkgPath, "dist/electron");
@@ -154,7 +161,7 @@ export class Electron {
       runEnv["ELECTRON_DEV_URL"] = url;
     }
 
-    await this._exec("npx", ["electron", "."], electronRunPath, runEnv);
+    await this._exec(this._localBin("electron"), ["."], electronRunPath, runEnv);
   }
 
   //#endregion
@@ -300,8 +307,8 @@ export class Electron {
     await fsx.writeJson(configFilePath, builderConfig, { space: 2 });
 
     await this._exec(
-      "npx",
-      ["electron-builder", "--win", "--config", configFilePath],
+      this._localBin("electron-builder"),
+      ["--win", "--config", configFilePath],
       this._pkgPath,
     );
   }

package/src/orchestrators/DevOrchestrator.ts

@@ -498,7 +498,7 @@ export class DevOrchestrator {
     };
 
     // Register Server Build Worker event handlers
-    for (const { name } of this._serverPackages) {
+    for (const { name, config } of this._serverPackages) {
       const serverBuild = this._serverBuildWorkers.get(name)!;
 
       serverBuild.worker.on("buildStart", () => {
@@ -540,6 +540,7 @@ export class DevOrchestrator {
           serverRuntimePromises,
           resolveServerStep,
           viteClientReadyPromises,
+          { ...this._baseEnv, ...config.env },
         ).catch((err: unknown) => {
           const message = errNs.message(err);
           this._logger.error(`[${name}] Error starting Server Runtime:`, message);
@@ -610,7 +611,9 @@ export class DevOrchestrator {
     serverRuntimePromises: Map<string, { promise: Promise<void>; resolver: () => void }>,
     resolveServerStep: (serverName: string, resultKey: string, result: BuildResult) => void,
     viteClientReadyPromises: Map<string, { promise: Promise<void>; resolver: () => void }>,
+    env?: Record<string, string>,
   ): Promise<void> {
+    const runtimeStartTime = performance.now();
     this._logger.debug(`[${serverName}] _startServerRuntime: ${mainJsPath}`);
     const updatedBuild = this._serverBuildWorkers.get(serverName)!;
     updatedBuild.mainJsPath = mainJsPath;
@@ -619,10 +622,15 @@ export class DevOrchestrator {
     const existingRuntime = this._serverRuntimeWorkers.get(serverName);
     if (existingRuntime != null) {
       this._logger.info(`[${serverName}] Restarting server...`);
+      const terminateStart = performance.now();
       await existingRuntime.terminate();
+      this._logger.debug(
+        `[${serverName}] Previous runtime terminated (${Math.round(performance.now() - terminateStart)}ms)`,
+      );
     }
 
     // Create and start new Server Runtime Worker
+    this._logger.debug(`[${serverName}] Creating runtime worker...`);
     const runtimeWorker = Worker.create<typeof ServerRuntimeWorkerModule>(serverRuntimeWorkerPath);
     this._serverRuntimeWorkers.set(serverName, runtimeWorker);
 
@@ -635,7 +643,11 @@ export class DevOrchestrator {
       `[${serverName}] Waiting for clients: ${String(clientReadyPromises.length)} total`,
     );
     if (clientReadyPromises.length > 0) {
+      const waitStart = performance.now();
       await Promise.all(clientReadyPromises);
+      this._logger.debug(
+        `[${serverName}] Clients ready (${Math.round(performance.now() - waitStart)}ms)`,
+      );
     }
 
     // Collect client ports for this server
@@ -645,6 +657,9 @@ export class DevOrchestrator {
         serverClientPorts[clientName] = this._clientPorts[clientName];
       }
     }
+    this._logger.debug(
+      `[${serverName}] Client ports: ${JSON.stringify(serverClientPorts)}`,
+    );
 
     // Server Runtime event handlers
     runtimeWorker.on("serverReady", (readyData) => {
@@ -672,10 +687,14 @@ export class DevOrchestrator {
     // Start Server Runtime
     // If worker crashes, it terminates without emitting "serverReady"/"error" events,
     // so catch promise rejection to prevent hanging
+    this._logger.debug(
+      `[${serverName}] Starting runtime worker... (setup took ${Math.round(performance.now() - runtimeStartTime)}ms)`,
+    );
     runtimeWorker
       .start({
         mainJsPath,
         clientPorts: serverClientPorts,
+        env,
       })
       .catch((err: unknown) => {
         const message = errNs.message(err);

package/src/sd-cli-entry.ts

@@ -77,7 +77,10 @@ export function createCliParser(argv: string[]): Argv {
       global: true,
     })
     .middleware((args) => {
-      if (args.debug) consola.level = LogLevels.debug;
+      if (args.debug) {
+        consola.level = LogLevels.debug;
+        process.env["SD_DEBUG"] = "true";
+      }
     })
     .command(
       "lint [targets..]",

package/src/utils/esbuild-config.ts

@@ -5,6 +5,9 @@ import { createRequire } from "module";
 import type esbuild from "esbuild";
 import { solidPlugin } from "esbuild-plugin-solid";
 import type { TypecheckEnv } from "./tsconfig";
+import { consola } from "consola";
+
+const logger = consola.withTag("sd:cli:esbuild-config");
 
 /**
  * Write only changed files from esbuild outputFiles to disk
@@ -65,6 +68,8 @@ export interface ServerEsbuildOptions {
   env?: Record<string, string>;
   /** External modules to exclude from bundle */
   external?: string[];
+  /** Dev mode: skip minification for faster builds */
+  dev?: boolean;
 }
 
 /**
@@ -102,7 +107,7 @@ export function createLibraryEsbuildOptions(options: LibraryEsbuildOptions): esb
     bundle: false,
     write: false,
     tsconfigRaw: {
-      compilerOptions: options.compilerOptions as esbuild.TsconfigRaw["compilerOptions"],
+      compilerOptions: toEsbuildTsconfigRaw(options.compilerOptions),
     },
     logLevel: "silent",
     plugins,
@@ -130,7 +135,7 @@ export function createServerEsbuildOptions(options: ServerEsbuildOptions): esbui
     entryPoints: options.entryPoints,
     outdir: path.join(options.pkgDir, "dist"),
     format: "esm",
-    minify: true,
+    minify: options.dev !== true,
     platform: "node",
     target: "node20",
     bundle: true,
@@ -140,12 +145,64 @@ export function createServerEsbuildOptions(options: ServerEsbuildOptions): esbui
     external: options.external,
     define,
     tsconfigRaw: {
-      compilerOptions: options.compilerOptions as esbuild.TsconfigRaw["compilerOptions"],
+      compilerOptions: toEsbuildTsconfigRaw(options.compilerOptions),
     },
     logLevel: "silent",
   };
 }
 
+// TypeScript ScriptTarget enum → esbuild target string
+const TARGET_MAP: Record<number, string> = {
+  0: "es3", 1: "es5", 2: "es2015", 3: "es2016", 4: "es2017",
+  5: "es2018", 6: "es2019", 7: "es2020", 8: "es2021", 9: "es2022",
+  10: "es2023", 11: "es2024", 99: "esnext",
+};
+
+// TypeScript JsxEmit enum → esbuild jsx string
+const JSX_MAP: Record<number, string> = {
+  1: "preserve", 2: "react", 3: "react-native", 4: "react-jsx", 5: "react-jsxdev",
+};
+
+// TypeScript ModuleKind enum → string
+const MODULE_MAP: Record<number, string> = {
+  0: "none", 1: "commonjs", 2: "amd", 3: "umd", 4: "system",
+  5: "es2015", 6: "es2020", 7: "es2022", 99: "esnext",
+  100: "node16", 199: "nodenext",
+};
+
+// TypeScript ModuleResolutionKind enum → string
+const MODULE_RESOLUTION_MAP: Record<number, string> = {
+  1: "node10", 2: "node16", 3: "nodenext", 100: "bundler",
+};
+
+/**
+ * Convert TypeScript's ts.CompilerOptions to esbuild-compatible tsconfigRaw compilerOptions.
+ *
+ * TypeScript uses numeric enum values (e.g., target: 99) while esbuild expects
+ * string values (e.g., "esnext"). This converts known enum fields and passes
+ * everything else through as-is.
+ */
+function toEsbuildTsconfigRaw(
+  compilerOptions: Record<string, unknown>,
+): esbuild.TsconfigRaw["compilerOptions"] {
+  const result = { ...compilerOptions };
+
+  if (typeof result["target"] === "number") {
+    result["target"] = TARGET_MAP[result["target"]] ?? "esnext";
+  }
+  if (typeof result["jsx"] === "number") {
+    result["jsx"] = JSX_MAP[result["jsx"]];
+  }
+  if (typeof result["module"] === "number") {
+    result["module"] = MODULE_MAP[result["module"]];
+  }
+  if (typeof result["moduleResolution"] === "number") {
+    result["moduleResolution"] = MODULE_RESOLUTION_MAP[result["moduleResolution"]];
+  }
+
+  return result as esbuild.TsconfigRaw["compilerOptions"];
+}
+
 /**
  * Extract TypecheckEnv from build target
  *
@@ -183,6 +240,7 @@ function scanDependencyTree(
   try {
     pkgJsonPath = req.resolve(`${pkgName}/package.json`);
   } catch {
+    logger.debug(`[scanDependencyTree] Could not resolve: ${pkgName}`);
     return;
   }
 
@@ -196,7 +254,13 @@ function scanDependencyTree(
   }
 
   // Recursively traverse sub-dependencies
-  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+  const subDeps = Object.keys(pkgJson.dependencies ?? {});
+  if (subDeps.length > 0) {
+    logger.debug(
+      `[scanDependencyTree] ${pkgName}: traversing ${String(subDeps.length)} sub-dependencies`,
+    );
+  }
+  for (const dep of subDeps) {
     scanDependencyTree(dep, depDir, external, visited, collector);
   }
 }
@@ -212,7 +276,12 @@ export function collectUninstalledOptionalPeerDeps(pkgDir: string): string[] {
   const visited = new Set<string>();
 
   const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
-  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+  const deps = Object.keys(pkgJson.dependencies ?? {});
+  logger.debug(
+    `[optionalPeerDeps] Scanning ${String(deps.length)} top-level dependencies...`,
+  );
+
+  for (const dep of deps) {
     scanDependencyTree(dep, pkgDir, external, visited, (_pkgName, depDir, depPkgJson) => {
       const found: string[] = [];
       if (depPkgJson.peerDependenciesMeta != null) {
@@ -232,6 +301,9 @@ export function collectUninstalledOptionalPeerDeps(pkgDir: string): string[] {
     });
   }
 
+  logger.debug(
+    `[optionalPeerDeps] Done: visited ${String(visited.size)} packages, found ${String(external.size)} externals`,
+  );
   return [...external];
 }
 
@@ -250,7 +322,12 @@ export function collectNativeModuleExternals(pkgDir: string): string[] {
   const visited = new Set<string>();
 
   const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
-  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+  const deps = Object.keys(pkgJson.dependencies ?? {});
+  logger.debug(
+    `[nativeModules] Scanning ${String(deps.length)} top-level dependencies...`,
+  );
+
+  for (const dep of deps) {
     scanDependencyTree(dep, pkgDir, external, visited, (pkgName, depDir, _pkgJson) => {
       const found: string[] = [];
       // Detect native modules by checking for binding.gyp
@@ -261,6 +338,9 @@ export function collectNativeModuleExternals(pkgDir: string): string[] {
     });
   }
 
+  logger.debug(
+    `[nativeModules] Done: visited ${String(visited.size)} packages, found ${String(external.size)} externals`,
+  );
   return [...external];
 }
 

package/src/utils/package-utils.ts

@@ -1,7 +1,10 @@
 import path from "path";
 import fs from "fs";
+import { consola } from "consola";
 import type { SdPackageConfig } from "../sd-config.types";
 
+const logger = consola.withTag("sd:cli:package-utils");
+
 /**
  * Walk up from import.meta.dirname to find package.json and return package root
  */
@@ -25,6 +28,8 @@ export function collectDeps(
   cwd: string,
   replaceDepsConfig?: Record<string, string>,
 ): DepsResult {
+  const startTime = performance.now();
+  logger.debug("[collectDeps] Starting dependency collection...");
   const rootPkgJsonPath = path.join(cwd, "package.json");
   const rootPkgJson = JSON.parse(fs.readFileSync(rootPkgJsonPath, "utf-8")) as { name: string };
   const scopeMatch = rootPkgJson.name.match(/^(@[^/]+)\//);
@@ -80,6 +85,9 @@ export function collectDeps(
   }
 
   traverse(pkgDir);
+  logger.debug(
+    `[collectDeps] Done: workspace=${String(workspaceDeps.length)}, replace=${String(replaceDeps.length)} (${Math.round(performance.now() - startTime)}ms)`,
+  );
   return { workspaceDeps, replaceDeps };
 }
 

package/src/utils/replace-deps.ts

@@ -3,6 +3,8 @@ import path from "path";
 import { glob } from "glob";
 import { consola } from "consola";
 import { fsx, pathx, FsWatcher } from "@simplysm/core-node";
+import { exec } from "child_process";
+import { promisify } from "util";
 
 /**
  * Match glob patterns from replaceDeps config with target package list
@@ -258,6 +260,24 @@ export async function setupReplaceDeps(
   }
 
   logger.success(`Replaced ${setupCount} dependencies`);
+
+  // Run postinstall scripts from replaced packages
+  for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
+    const sourcePkgJsonPath = path.join(resolvedSourcePath, "package.json");
+    try {
+      const pkgJson = JSON.parse(await fs.promises.readFile(sourcePkgJsonPath, "utf-8"));
+      const postinstall = pkgJson.scripts?.postinstall as string | undefined;
+      if (postinstall == null) continue;
+
+      logger.start(`Running postinstall for ${targetName}`);
+      await promisify(exec)(postinstall, { cwd: actualTargetPath });
+      logger.success(`postinstall done: ${targetName}`);
+    } catch (err) {
+      logger.error(
+        `postinstall failed (${targetName}): ${err instanceof Error ? err.message : err}`,
+      );
+    }
+  }
 }
 
 /**

package/src/utils/worker-utils.ts

@@ -1,4 +1,17 @@
-import type { ConsolaInstance } from "consola";
+import consola, { type ConsolaInstance, LogLevels } from "consola";
+
+/**
+ * Apply debug log level in worker threads
+ *
+ * Checks the SD_DEBUG environment variable (set by --debug flag in main process)
+ * and applies debug log level to consola in the current worker thread.
+ * Must be called at worker module top level.
+ */
+export function applyDebugLevel(): void {
+  if (process.env["SD_DEBUG"] === "true") {
+    consola.level = LogLevels.debug;
+  }
+}
 
 /**
  * Register cleanup handlers for worker process shutdown signals

package/src/workers/client.worker.ts

@@ -8,7 +8,9 @@ import type { SdClientPackageConfig } from "../sd-config.types";
 import { parseRootTsconfig, getCompilerOptionsForPackage } from "../utils/tsconfig";
 import { createViteConfig } from "../utils/vite-config";
 import { collectDeps } from "../utils/package-utils";
-import { registerCleanupHandlers, createOnceGuard } from "../utils/worker-utils";
+import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
+
+applyDebugLevel();
 
 //#region Types
 

package/src/workers/dts.worker.ts

@@ -11,7 +11,9 @@ import {
   type TypecheckEnv,
 } from "../utils/tsconfig";
 import { serializeDiagnostic, type SerializedDiagnostic } from "../utils/typecheck-serialization";
-import { createOnceGuard, registerCleanupHandlers } from "../utils/worker-utils";
+import { createOnceGuard, registerCleanupHandlers, applyDebugLevel } from "../utils/worker-utils";
+
+applyDebugLevel();
 
 //#region Types
 

package/src/workers/library.worker.ts

@@ -14,7 +14,9 @@ import {
   getTypecheckEnvFromTarget,
   writeChangedOutputFiles,
 } from "../utils/esbuild-config";
-import { registerCleanupHandlers, createOnceGuard } from "../utils/worker-utils";
+import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
+
+applyDebugLevel();
 
 //#region Types