@simplysm/sd-cli 14.0.17 → 14.0.19

package/src/angular/vite-angular-plugin.ts

@@ -1,4 +1,4 @@
-import type { Plugin, EnvironmentModuleNode, HotUpdateOptions, ViteDevServer } from "vite";
+import type { Plugin, ModuleNode, ViteDevServer } from "vite";
 import type { IncomingMessage, ServerResponse } from "http";
 import { JavaScriptTransformer } from "@angular/build/private";
 import { createHash } from "crypto";
@@ -49,6 +49,8 @@ export interface SdAngularPluginOptions {
   postCssPlugins?: unknown[];
   /** Linker 캐시 디렉토리 (기본값: {cwd}/.cache/linker/{sm|nosm}) */
   linkerCacheDir?: string;
+  /** replaceDeps 패키지의 resolved dist 경로 목록 (Linker 캐시 skip + full-reload 트리거) */
+  replaceDepDistPaths?: string[];
 }
 
 /**
@@ -108,6 +110,10 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
   const templateUpdates = new Map<string, string>();
   let hmrLock: Promise<void> = Promise.resolve();
   const scssDependencies = new Map<string, Set<string>>();
+  let devServer: ViteDevServer | undefined;
+
+  /** Rolldown watch 모드에서 변경된 파일 경로를 수집한다. buildStart 재호출 시 캐시 무효화에 사용. */
+  const pendingWatchChanges = new Set<string>();
 
   const enableSourcemap = options.sourcemap ?? options.dev;
 
@@ -134,6 +140,10 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
     name: "sd-angular",
     enforce: "pre",
 
+    watchChange(id: string) {
+      pendingWatchChanges.add(pathx.posix(id));
+    },
+
     config() {
       const linkerCacheDir =
         options.linkerCacheDir ??
@@ -146,37 +156,53 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
           ngHmrMode: options.dev && !options.legacyModule ? undefined : "false",
         },
         optimizeDeps: {
-          rolldownOptions: {
+          esbuildOptions: {
             plugins: [
               {
                 name: "angular-vite-optimize-deps",
-                async load(id: string) {
-                  if (!/\.[cm]?js$/.test(id)) return null;
-
-                  const content = await fsp.readFile(id, "utf-8");
-                  const hash = createHash("sha256").update(content).digest("hex");
-                  const cachePath = path.join(linkerCacheDir, `${hash}.js`);
-
-                  try {
-                    return await fsp.readFile(cachePath, "utf-8");
-                  } catch {
-                    // cache miss
-                  }
-
-                  const result = await prebundleTransformer.transformFile(id);
-                  const resultStr =
-                    typeof result === "string"
-                      ? result
-                      : new TextDecoder().decode(result);
-
-                  try {
-                    await fsp.mkdir(linkerCacheDir, { recursive: true });
-                    await fsp.writeFile(cachePath, resultStr);
-                  } catch {
-                    // cache write failure — non-fatal
-                  }
-
-                  return resultStr;
+                setup(build: { onLoad: Function }) {
+                  build.onLoad(
+                    { filter: /\.[cm]?js$/ },
+                    async (args: { path: string }) => {
+                      if (!/\.[cm]?js$/.test(args.path)) return null;
+
+                      // replaceDeps 파일은 Linker 캐시를 건너뛴다 (항상 fresh 처리)
+                      if (
+                        options.replaceDepDistPaths != null &&
+                        options.replaceDepDistPaths.some((p) =>
+                          pathx.posix(args.path).startsWith(p),
+                        )
+                      ) {
+                        return null;
+                      }
+
+                      const content = await fsp.readFile(args.path, "utf-8");
+                      const hash = createHash("sha256").update(content).digest("hex");
+                      const cachePath = path.join(linkerCacheDir, `${hash}.js`);
+
+                      try {
+                        const cached = await fsp.readFile(cachePath, "utf-8");
+                        return { contents: cached, loader: "js" as const };
+                      } catch {
+                        // cache miss
+                      }
+
+                      const result = await prebundleTransformer.transformFile(args.path);
+                      const resultStr =
+                        typeof result === "string"
+                          ? result
+                          : new TextDecoder().decode(result);
+
+                      try {
+                        await fsp.mkdir(linkerCacheDir, { recursive: true });
+                        await fsp.writeFile(cachePath, resultStr);
+                      } catch {
+                        // cache write failure — non-fatal
+                      }
+
+                      return { contents: resultStr, loader: "js" as const };
+                    },
+                  );
                 },
               },
             ],
@@ -196,6 +222,13 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
       // AngularSourceFileCache 생성 (또는 재사용)
       sourceFileCache ??= new AngularSourceFileCache();
 
+      // Rolldown watch 재빌드: 변경된 파일의 캐시 무효화
+      if (pendingWatchChanges.size > 0) {
+        logger.debug(`watch 변경 파일 ${pendingWatchChanges.size}개 캐시 무효화`);
+        sourceFileCache.invalidate(pendingWatchChanges);
+        pendingWatchChanges.clear();
+      }
+
       // SCSS errors 수집용
       const scssErrors: string[] = [];
 
@@ -229,6 +262,7 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
           noEmit: false,
           declaration: false,
           declarationMap: false,
+          ...(options.dev ? { removeComments: false } : {}),
         }),
       });
 
@@ -281,16 +315,35 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
       });
     },
 
-    async hotUpdate({
+    async handleHotUpdate({
       file,
       modules,
-    }: HotUpdateOptions): Promise<EnvironmentModuleNode[] | void> {
+      server,
+    }: {
+      file: string;
+      modules: ModuleNode[];
+      server: ViteDevServer;
+      timestamp: number;
+      read: () => string | Promise<string>;
+    }): Promise<ModuleNode[] | void> {
       if (compiler == null || !options.dev) return;
       if (
         !file.endsWith(".ts") &&
         !file.endsWith(".html") &&
         !file.endsWith(".scss")
       ) {
+        // replaceDeps .js 파일 변경 시 full-reload 강제
+        if (
+          file.endsWith(".js") &&
+          devServer != null &&
+          options.replaceDepDistPaths != null &&
+          options.replaceDepDistPaths.some((p) =>
+            pathx.posix(file).startsWith(p),
+          )
+        ) {
+          devServer.hot.send({ type: "full-reload" });
+          return [];
+        }
         return;
       }
 
@@ -372,10 +425,9 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
 
         if (file.endsWith(".scss")) {
           // SCSS: moduleGraph에서 영향받은 TS 모듈 조회
-          const moduleGraph = this.environment.moduleGraph;
-          const result: EnvironmentModuleNode[] = [];
+          const result: ModuleNode[] = [];
           for (const p of affectedPaths) {
-            const mods = moduleGraph.getModulesByFile(p);
+            const mods = server.moduleGraph.getModulesByFile(p);
             if (mods) result.push(...mods);
           }
           return result;
@@ -443,6 +495,8 @@ export function sdAngularPlugin(options: SdAngularPluginOptions): Plugin {
     },
 
     configureServer(server: ViteDevServer) {
+      devServer = server;
+
       // component-middleware 등록 (HMR template updates 서빙)
       server.middlewares.use(angularComponentMiddleware(templateUpdates, server.config.base));
 

package/src/capacitor/capacitor.ts

@@ -1,7 +1,6 @@
 import fs from "node:fs";
 import { existsSync } from "node:fs";
 import path from "path";
-import { symlink } from "fs/promises";
 import { createRequire } from "module";
 import { cpx, fsx, pathx } from "@simplysm/core-node";
 import { env } from "@simplysm/core-common";
@@ -247,14 +246,12 @@ export class Capacitor {
    */
   private async _initCap(): Promise<boolean> {
     Capacitor._logger.debug("package.json 설정 시작");
-    const { depChanged, workspacePlugins } = await this._setupNpmConf();
+    const depChanged = await this._setupNpmConf();
     const nodeModulesExists = await fsx.exists(pathx.posixResolve(this._capPath, "node_modules"));
     Capacitor._logger.debug(`depChanged: ${depChanged}, nodeModulesExists: ${nodeModulesExists}`);
 
     if (!depChanged && nodeModulesExists) {
-      // 의존성 미변경이어도 workspace 플러그인 symlink는 항상 갱신
-      Capacitor._logger.debug("의존성 변경 없음, workspace 플러그인 symlink만 갱신");
-      await this._linkWorkspacePlugins(workspacePlugins);
+      Capacitor._logger.debug("의존성 변경 없음");
       return false;
     }
 
@@ -270,11 +267,6 @@ export class Capacitor {
     await this._exec("pnpm", ["approve-builds", "--all"], this._capPath);
     Capacitor._logger.debug("pnpm install 완료");
 
-    // workspace 플러그인 symlink
-    Capacitor._logger.debug("workspace 플러그인 symlink 시작");
-    await this._linkWorkspacePlugins(workspacePlugins);
-    Capacitor._logger.debug("workspace 플러그인 symlink 완료");
-
     // 멱등성: capacitor.config.ts가 없을 때만 cap init 실행
     const configPath = pathx.posixResolve(this._capPath, "capacitor.config.ts");
     if (!(await fsx.exists(configPath))) {
@@ -300,7 +292,7 @@ export class Capacitor {
   /**
    * package.json 설정
    */
-  private async _setupNpmConf(): Promise<{ depChanged: boolean; workspacePlugins: string[] }> {
+  private async _setupNpmConf(): Promise<boolean> {
     const projNpmConfigPath = pathx.posixResolve(this._findWorkspaceRoot(), "package.json");
 
     // 루트 package.json 존재 확인
@@ -358,16 +350,17 @@ export class Capacitor {
       }
     }
 
-    // 새 플러그인 추가 (workspace:* 플러그인은 분리)
-    const workspacePlugins: string[] = [];
+    // 새 플러그인 추가
+    const pkgRequire = createRequire(pathx.posixResolve(this._pkgPath, "package.json"));
     for (const plugin of usePlugins) {
       const version = mainDeps[plugin] ?? "*";
       if (typeof version === "string" && version.startsWith("workspace:")) {
-        // workspace 플러그인은 package.json에 추가하지 않고 symlink로 처리
-        workspacePlugins.push(plugin);
-        // 이전에 추가되어 있었으면 제거
-        delete capNpmConf.dependencies[plugin];
-        Capacitor._logger.debug(`workspace 플러그인 (symlink 예정): ${plugin}`);
+        // workspace 플러그인은 link: 프로토콜로 실제 경로를 지정
+        const pluginPkgJsonPath = pkgRequire.resolve(`${plugin}/package.json`);
+        const pluginDir = path.dirname(pluginPkgJsonPath);
+        const relativePath = path.relative(this._capPath, pluginDir).replace(/\\/g, "/");
+        capNpmConf.dependencies[plugin] = `link:${relativePath}`;
+        Capacitor._logger.debug(`workspace 플러그인 (link): ${plugin} → ${relativePath}`);
       } else if (!(plugin in capNpmConf.dependencies)) {
         capNpmConf.dependencies[plugin] = version;
         Capacitor._logger.debug(`플러그인 추가: ${plugin}@${version}`);
@@ -388,12 +381,11 @@ export class Capacitor {
     await fsx.writeJson(capNpmConfPath, capNpmConf, { space: 2 });
 
     // 의존성 변경 여부 확인
-    const isChanged =
+    return (
       orgCapNpmConf.volta !== capNpmConf.volta ||
       JSON.stringify(orgCapNpmConf.dependencies) !== JSON.stringify(capNpmConf.dependencies) ||
-      JSON.stringify(orgCapNpmConf.devDependencies) !== JSON.stringify(capNpmConf.devDependencies);
-
-    return { depChanged: isChanged, workspacePlugins };
+      JSON.stringify(orgCapNpmConf.devDependencies) !== JSON.stringify(capNpmConf.devDependencies)
+    );
   }
 
   /**
@@ -1087,30 +1079,6 @@ export default config;
    * workspace:* 플러그인을 .capacitor/node_modules/에 symlink로 연결한다.
    * cap sync는 플러그인의 android/ 네이티브 코드만 필요하므로 JS 의존성 resolve 불필요.
    */
-  private async _linkWorkspacePlugins(plugins: string[]): Promise<void> {
-    if (plugins.length === 0) return;
-
-    const require = createRequire(pathx.posixResolve(this._pkgPath, "package.json"));
-
-    for (const plugin of plugins) {
-      const pluginPkgJsonPath = require.resolve(`${plugin}/package.json`);
-      const pluginDir = path.dirname(pluginPkgJsonPath);
-
-      const linkPath = pathx.posixResolve(this._capPath, "node_modules", ...plugin.split("/"));
-
-      // scope 디렉토리 생성 (예: @simplysm/)
-      await fsx.mkdir(path.dirname(linkPath));
-
-      // 기존 symlink가 있으면 삭제
-      if (await fsx.exists(linkPath)) {
-        await fsx.rm(linkPath);
-      }
-
-      await symlink(pluginDir, linkPath, "junction");
-      Capacitor._logger.debug(`workspace 플러그인 symlink: ${plugin} → ${pluginDir}`);
-    }
-  }
-
   /**
    * pnpm-workspace.yaml이 있는 워크스페이스 루트 디렉토리를 찾는다.
    */

package/src/commands/device.ts

@@ -64,8 +64,9 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
     if (typeof clientConfig.server === "number") {
       serverUrl = `http://localhost:${clientConfig.server}/${targetName}/`;
     } else {
-      // server가 패키지명(string)인 경우: .dev-port 파일에서 포트 자동 탐지
-      const portFile = path.join(pkgDir, "dist", ".dev-port");
+      // server가 패키지명(string)인 경우: 서버 패키지의 .dev-port 파일에서 포트 자동 탐지
+      const serverPkgDir = pathx.posixResolve(cwd, "packages", clientConfig.server);
+      const portFile = path.join(serverPkgDir, "dist", ".dev-port");
       let portStr: string;
       try {
         portStr = fs.readFileSync(portFile, "utf-8").trim();

package/src/electron/electron.ts

@@ -125,6 +125,9 @@ export class Electron {
     };
 
     const envBanner = createEnvBanner({ ELECTRON_DEV_URL: url, ...this._config.env });
+    const bannerJs =
+      "import { createRequire } from 'module'; const require = createRequire(import.meta.url);" +
+      envBanner;
 
     Electron._logger.debug("esbuild context 생성 시작");
     const ctx = await esbuild.context({
@@ -132,10 +135,10 @@ export class Electron {
       outfile: pathx.posixResolve(this._srcPath, "electron-main.js"),
       platform: "node",
       target: "node20",
-      format: "cjs",
+      format: "esm",
       bundle: true,
       external: ["electron", ...builtinModules, ...reinstallDeps, ...this._exclude],
-      banner: { js: envBanner },
+      banner: { js: bannerJs },
       plugins: [
         {
           name: "electron-restart",
@@ -264,6 +267,7 @@ export class Electron {
       name: this._npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
       version: this._npmConfig.version,
       description: this._npmConfig.description,
+      type: "module",
       main: "electron-main.js",
       dependencies,
       devDependencies,
@@ -292,6 +296,9 @@ export class Electron {
     const reinstallDeps = this._config.reinstallDependencies ?? [];
 
     const envBanner = createEnvBanner(this._config.env);
+    const bannerJs =
+      "import { createRequire } from 'module'; const require = createRequire(import.meta.url);" +
+      envBanner;
 
     Electron._logger.debug(`esbuild 번들링: ${entryPoint}`);
     await esbuild.build({
@@ -299,10 +306,10 @@ export class Electron {
       outfile: pathx.posixResolve(this._srcPath, "electron-main.js"),
       platform: "node",
       target: "node20",
-      format: "cjs",
+      format: "esm",
       bundle: true,
       external: ["electron", ...builtinModules, ...reinstallDeps, ...this._exclude],
-      banner: { js: envBanner },
+      banner: { js: bannerJs },
     });
   }
 

package/src/orchestrators/DevWatchOrchestrator.ts

@@ -277,6 +277,20 @@ export class DevWatchOrchestrator {
 
   private async _startWatchMode(): Promise<void> {
     this._logger.debug("watch 모드 시작");
+
+    // [DEBUG] angular/dist 삭제 감지용 임시 워처
+    {
+      const debugDistDir = pathx.posixResolve(this._cwd, "packages", "angular", "dist");
+      const debugWatcher = await FsWatcher.watch([debugDistDir]);
+      debugWatcher.onChange({ delay: 100 }, (changes) => {
+        for (const c of changes) {
+          if (c.event === "unlink" || c.event === "unlinkDir") {
+            this._logger.error(`[DEBUG:angular-dist] ${c.event}: ${c.path}\n${new Error().stack}`);
+          }
+        }
+      });
+    }
+
     // Start copySrc watchers for library packages
     for (const pkg of this._libraryPackages) {
       if (pkg.config.copySrc != null && pkg.config.copySrc.length > 0) {

package/src/utils/vite-config.ts

@@ -1,6 +1,9 @@
 import type { InlineConfig, PluginOption } from "vite";
 import path from "path";
+import fs from "fs";
+import tsconfigPaths from "vite-tsconfig-paths";
 import browserslistToEsbuild from "browserslist-to-esbuild";
+import { pathx } from "@simplysm/core-node";
 import { sdAngularPlugin } from "../angular/vite-angular-plugin.js";
 import solidPlugin from "vite-plugin-solid";
 import {
@@ -9,7 +12,8 @@ import {
 } from "./vite-scope-watch-plugin.js";
 import { sdPostCssInlinePlugin } from "../angular/vite-postcss-inline-plugin.js";
 import type { SdPwaConfig } from "../sd-config.types.js";
-import { sdPwaPlugin } from "./vite-pwa-plugin.js";
+import { VitePWA } from "vite-plugin-pwa";
+import { generatePwaIcons } from "./generate-pwa-icons.js";
 
 /** createClientViteConfig 옵션 */
 export interface CreateClientViteConfigOptions {
@@ -68,9 +72,9 @@ export interface CreateClientViteConfigOptions {
  * Angular AOT 플러그인, tsconfigPaths, env define, server/build 기본 설정,
  * browserslist, PostCSS, polyfills, legacyModule (inlineDynamicImports) 등을 통합 구성한다.
  */
-export function createClientViteConfig(
+export async function createClientViteConfig(
   options: CreateClientViteConfigOptions,
-): InlineConfig {
+): Promise<InlineConfig> {
   const name = options.pkgName.replace(/^@[^/]+\//, "");
 
   // browserslist → esbuild target
@@ -98,8 +102,29 @@ export function createClientViteConfig(
     }
   }
 
+  // replaceDeps dist 경로 (symlink → realpath 해결)
+  let replaceDepDistPaths: string[] | undefined;
+  if (options.replaceDeps != null && options.replaceDeps.length > 0) {
+    replaceDepDistPaths = [];
+    for (const dep of options.replaceDeps) {
+      const distDir = path.join(
+        options.pkgDir,
+        "node_modules",
+        ...dep.packageName.split("/"),
+        "dist",
+      );
+      try {
+        replaceDepDistPaths.push(pathx.posix(fs.realpathSync(distDir)));
+      } catch {
+        replaceDepDistPaths.push(pathx.posix(distDir));
+      }
+    }
+  }
+
   // plugins
-  const plugins: PluginOption[] = [];
+  const plugins: PluginOption[] = [
+    tsconfigPaths({ projects: [options.tsconfigPath] }),
+  ];
 
   if (options.framework === "solid") {
     plugins.push(solidPlugin());
@@ -115,6 +140,7 @@ export function createClientViteConfig(
         enableLint: options.enableLint,
         browserslist: normalizedBrowserslist,
         postCssPlugins: options.postCssPlugins,
+        replaceDepDistPaths,
       }),
     );
 
@@ -157,32 +183,70 @@ export function createClientViteConfig(
       ? { postcss: { plugins: options.postCssPlugins as import("postcss").AcceptedPlugin[] } }
       : undefined;
 
-  // optimizeDeps.exclude (사용자 지정 exclude)
+  // optimizeDeps.exclude (사용자 지정 exclude + replaceDeps 패키지)
+  const excludeList = [
+    ...(options.exclude ?? []),
+    ...(options.replaceDeps?.map((dep) => dep.packageName) ?? []),
+  ];
   const optimizeDepsConfig =
-    options.exclude != null && options.exclude.length > 0
-      ? { exclude: options.exclude }
-      : undefined;
+    excludeList.length > 0 ? { exclude: excludeList } : undefined;
 
   const config: InlineConfig = {
     root: options.pkgDir,
     base: options.base ?? `/${name}/`,
-    resolve: { tsconfigPaths: true },
     define: Object.keys(define).length > 0 ? define : undefined,
     plugins,
     server: serverConfig,
     css: cssConfig,
+    esbuild: {
+      target: esbuildTarget,
+    },
     build: {
       target: esbuildTarget,
     },
     optimizeDeps: {
       ...optimizeDepsConfig,
+      esbuildOptions: {
+        target: esbuildTarget as string[],
+      },
     },
   };
 
   // PWA (build 모드 + pwa !== false)
   if (options.mode === "build" && options.pwa !== false) {
+    const pwaConfig = typeof options.pwa === "object" ? options.pwa : {};
+
+    // 아이콘 자동 생성 (커스텀 icons 미설정 시)
+    let iconsConfig: Record<string, unknown> = {};
+    if (pwaConfig.manifest?.icons != null) {
+      iconsConfig = { icons: pwaConfig.manifest.icons };
+    } else {
+      const generatedIcons = await generatePwaIcons(options.pkgDir);
+      if (generatedIcons.length > 0) {
+        iconsConfig = { icons: generatedIcons };
+      }
+    }
+
+    const pwaManifest = {
+      name: pwaConfig.manifest?.name ?? name,
+      short_name: pwaConfig.manifest?.short_name ?? name,
+      display: pwaConfig.manifest?.display ?? "standalone",
+      theme_color: pwaConfig.manifest?.theme_color ?? "#ffffff",
+      background_color: pwaConfig.manifest?.background_color ?? "#ffffff",
+      ...iconsConfig,
+    };
+    const pwaWorkbox = {
+      globPatterns: pwaConfig.workbox?.globPatterns ?? [
+        "**/*.{js,css,html,ico,png,svg,woff2}",
+      ],
+    };
     (config.plugins as PluginOption[]).push(
-      sdPwaPlugin({ pkgDir: options.pkgDir, pkgName: name, pwa: options.pwa }),
+      VitePWA({
+        registerType: "prompt",
+        injectRegister: "script",
+        manifest: pwaManifest,
+        workbox: pwaWorkbox,
+      }),
     );
   }
 
@@ -231,18 +295,24 @@ export function createClientViteConfig(
     }
   }
 
-  // legacyModule: true → 코드 스플리팅 비활성화 + import.meta/import() 치환 (Chrome 61 호환)
+  // legacyModule: true → 코드 스플리팅 비활성화 + esbuild import.meta 변환 + 잔여 import() 제거
   if (options.legacyModule === true) {
+    config.esbuild = {
+      ...config.esbuild,
+      supported: {
+        "import-meta": false,
+      },
+    };
     config.build = {
       ...config.build,
-      rolldownOptions: {
+      rollupOptions: {
         output: {
           inlineDynamicImports: true,
         },
       },
     };
 
-    // Rolldown이 인라인하지 못한 잔여 dynamic import()를 제거한다.
+    // Rollup이 인라인하지 못한 잔여 dynamic import()를 제거한다.
     // inlineDynamicImports가 정적 경로를 모두 인라인한 후에도,
     // @vite-ignore나 런타임 계산 경로의 import()가 남을 수 있다.
     // Chrome 61은 import() 구문을 파싱하지 못하므로 no-op 함수로 치환한다.
@@ -260,20 +330,6 @@ export function createClientViteConfig(
         };
       },
     });
-
-    // import.meta 구문을 치환한다. Chrome 61은 import.meta를 파싱하지 못한다 (Chrome 64+).
-    // Vite/Rolldown이 빌드 시 대부분의 import.meta를 resolve하지만, 잔여분에 대한 안전망이다.
-    (config.plugins as PluginOption[]).push({
-      name: "sd-legacy-strip-import-meta",
-      enforce: "post",
-      renderChunk(code) {
-        if (!code.includes("import.meta")) return null;
-        return {
-          code: code.replace(/\bimport\.meta\b/g, "(void 0)"),
-          map: null,
-        };
-      },
-    });
   }
 
   // build 모드 설정 (프로덕션 빌드 또는 legacyModule dev)

package/src/utils/vite-scope-watch-plugin.ts

@@ -51,7 +51,12 @@ export function sdScopeWatchPlugin(options: SdScopeWatchPluginOptions): Plugin {
           "dist",
         );
         if (fs.existsSync(distDir)) {
-          watchPaths.push(distDir);
+          // symlink → realpath 해결 (Vite 모듈 그래프가 realpath를 키로 사용)
+          try {
+            watchPaths.push(fs.realpathSync(distDir));
+          } catch {
+            watchPaths.push(distDir);
+          }
         }
       }
 

package/src/workers/server-runtime.worker.ts

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "path";
 import { createWorker } from "@simplysm/core-node";
 import { env, err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
@@ -49,10 +51,18 @@ const logger = consola.withTag("sd:cli:server-runtime:worker");
 /** 서버 인스턴스 (정리 대상) */
 let serverInstance: { close: () => Promise<void> } | undefined;
 
+/** .dev-port 기록 경로 (cleanup에서 삭제용) */
+let mainJsDir: string | undefined;
+
 /**
  * 리소스 정리
  */
 async function cleanup(): Promise<void> {
+  if (mainJsDir != null) {
+    try { fs.unlinkSync(path.join(mainJsDir, ".dev-port")); } catch { /* 파일 없으면 무시 */ }
+    mainJsDir = undefined;
+  }
+
   const server = serverInstance;
   serverInstance = undefined;
   if (server != null) {
@@ -172,6 +182,11 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
     await server.listen();
     logger.debug(`서버 리슨 완료 (${Math.round(performance.now() - stepStart)}ms)`);
 
+    // .dev-port 기록 (device 명령어에서 자동 탐지용)
+    mainJsDir = path.dirname(info.mainJsPath);
+    fs.mkdirSync(mainJsDir, { recursive: true });
+    fs.writeFileSync(path.join(mainJsDir, ".dev-port"), String(server.options.port));
+
     logger.debug(
       `런타임 총 시작 시간: ${Math.round(performance.now() - startTime)}ms`,
     );