@simplysm/sd-cli 14.0.29 → 14.0.32

package/src/commands/publish/storage-publisher.ts

@@ -0,0 +1,208 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+import ssh2 from "ssh2";
+import { password as passwordPrompt } from "@inquirer/prompts";
+import { StorageFactory } from "@simplysm/storage";
+import { env } from "@simplysm/core-common";
+import type { consola } from "consola";
+import type { SdPublishConfig, SdStoragePublishConfig } from "../../sd-config.types";
+
+const { Client: SshClient, utils } = ssh2;
+
+/**
+ * 스토리지(FTP/FTPS/SFTP) 서버에 dist 디렉토리를 업로드한다
+ */
+export async function publishToStorage(
+  pkgPath: string,
+  pkgName: string,
+  config: SdStoragePublishConfig,
+  logger: ReturnType<typeof consola.withTag>,
+  dryRun: boolean,
+): Promise<void> {
+  const distPath = path.resolve(pkgPath, "dist");
+  const remotePath = config.path ?? "/";
+
+  if (dryRun) {
+    logger.info(`[DRY-RUN] [${pkgName}] ${config.type} 업로드: ${distPath} → ${remotePath}`);
+  } else {
+    logger.debug(`[${pkgName}] ${config.type} 업로드: ${distPath} → ${remotePath}`);
+    await StorageFactory.connect(
+      config.type,
+      {
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+      },
+      async (storage) => {
+        await storage.uploadDir(distPath, remotePath);
+      },
+    );
+  }
+}
+
+/**
+ * SSH 키 인증을 사전 검증하고 설정한다
+ *
+ * 비밀번호 없는 SFTP 서버의 경우:
+ * 1. SSH 키 파일이 없으면 생성
+ * 2. 키 인증을 테스트하고, 실패하면 비밀번호로 공개키를 등록
+ */
+export async function ensureSshAuth(
+  publishPackages: Array<{ name: string; config: SdPublishConfig }>,
+  logger: ReturnType<typeof consola.withTag>,
+): Promise<void> {
+  // 비밀번호 없는 SFTP 서버 수집 (user@host 기준 중복 제거)
+  const sshTargets = new Map<string, { host: string; port?: number; user: string }>();
+  for (const pkg of publishPackages) {
+    if (pkg.config.type === "npm") continue;
+    if (pkg.config.type !== "sftp") continue;
+    if (pkg.config.password != null) continue;
+    if (pkg.config.user == null) {
+      throw new Error(`[${pkg.name}] SFTP 설정에 user가 누락되었습니다.`);
+    }
+    const key = `${pkg.config.user}@${pkg.config.host}`;
+    sshTargets.set(key, {
+      host: pkg.config.host,
+      port: pkg.config.port,
+      user: pkg.config.user,
+    });
+  }
+
+  if (sshTargets.size === 0) return;
+
+  // SSH 키 파일 확인/생성
+  const sshDir = path.join(os.homedir(), ".ssh");
+  const keyPath = path.join(sshDir, "id_ed25519");
+  const pubKeyPath = path.join(sshDir, "id_ed25519.pub");
+
+  if (!fs.existsSync(keyPath)) {
+    logger.info("SSH 키를 찾을 수 없습니다. 생성 중...");
+
+    if (!fs.existsSync(sshDir)) {
+      fs.mkdirSync(sshDir, { mode: 0o700 });
+    }
+
+    const keyPair = utils.generateKeyPairSync("ed25519");
+    fs.writeFileSync(keyPath, keyPair.private, { mode: 0o600 });
+    fs.writeFileSync(pubKeyPath, keyPair.public + "\n", { mode: 0o644 });
+
+    logger.info(`SSH 키 생성 완료: ${keyPath}`);
+  }
+
+  const privateKeyData = fs.readFileSync(keyPath);
+  const publicKey = fs.readFileSync(pubKeyPath, "utf-8").trim();
+
+  // 개인키 파싱 시도 (암호화 또는 형식 오류 시 Error 반환)
+  const parsed = utils.parseKey(privateKeyData);
+  const isKeyEncrypted = parsed instanceof Error;
+  const sshAgent = env("SSH_AUTH_SOCK");
+
+  // 각 서버에 대해 키 인증 검증
+  for (const [label, target] of sshTargets) {
+    const canAuth = await testSshKeyAuth(target, {
+      privateKey: isKeyEncrypted ? undefined : privateKeyData,
+      agent: sshAgent,
+    });
+    if (canAuth) {
+      logger.debug(`SSH 키 인증 확인됨: ${label}`);
+      continue;
+    }
+
+    // 키 인증 실패 → 비밀번호로 공개키 등록
+    logger.info(`${label}: SSH 키가 서버에 등록되어 있지 않습니다.`);
+    const pass = await passwordPrompt({
+      message: `${label} 비밀번호 (공개키 등록용):`,
+    });
+
+    await registerSshPublicKey(target, pass, publicKey);
+    logger.info(`SSH 공개키 등록 완료: ${label}`);
+  }
+}
+
+/**
+ * SSH 키 인증 테스트 (연결 후 즉시 종료)
+ */
+function testSshKeyAuth(
+  target: { host: string; port?: number; user: string },
+  auth: { privateKey?: Buffer; agent?: string },
+): Promise<boolean> {
+  if (auth.privateKey == null && auth.agent == null) {
+    return Promise.resolve(false);
+  }
+
+  return new Promise((resolve) => {
+    const conn = new SshClient();
+    conn.on("ready", () => {
+      conn.end();
+      resolve(true);
+    });
+    conn.on("error", () => {
+      resolve(false);
+    });
+    conn.connect({
+      host: target.host,
+      port: target.port ?? 22,
+      username: target.user,
+      ...(auth.privateKey != null ? { privateKey: auth.privateKey } : {}),
+      ...(auth.agent != null ? { agent: auth.agent } : {}),
+      readyTimeout: 10_000,
+    });
+  });
+}
+
+/**
+ * 비밀번호로 서버에 연결하여 SSH 공개키를 등록한다
+ */
+function registerSshPublicKey(
+  target: { host: string; port?: number; user: string },
+  pass: string,
+  publicKey: string,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const conn = new SshClient();
+    conn.on("ready", () => {
+      // authorized_keys에 공개키 추가
+      const escapedKey = publicKey.replace(/'/g, "'\\''");
+      const cmd = [
+        "mkdir -p ~/.ssh",
+        "chmod 700 ~/.ssh",
+        `echo '${escapedKey}' >> ~/.ssh/authorized_keys`,
+        "chmod 600 ~/.ssh/authorized_keys",
+      ].join(" && ");
+
+      conn.exec(cmd, (err, stream) => {
+        if (err) {
+          conn.end();
+          reject(new Error(`SSH 명령 실행 실패: ${err.message}`));
+          return;
+        }
+
+        let stderr = "";
+        stream.on("data", () => {}); // stdout 소비 (소비하지 않으면 스트림이 닫히지 않음)
+        stream.stderr.on("data", (data: Uint8Array) => {
+          stderr += data.toString();
+        });
+        stream.on("exit", (code: number | null) => {
+          conn.end();
+          if (code !== 0) {
+            reject(new Error(`SSH 공개키 등록 실패 (종료 코드: ${code}): ${stderr}`));
+          } else {
+            resolve();
+          }
+        });
+      });
+    });
+    conn.on("error", (err) => {
+      reject(new Error(`SSH 연결 실패 (${target.host}): ${err.message}`));
+    });
+    conn.connect({
+      host: target.host,
+      port: target.port ?? 22,
+      username: target.user,
+      password: pass,
+      readyTimeout: 10_000,
+    });
+  });
+}

package/src/commands/publish/version-upgrade.ts

@@ -0,0 +1,132 @@
+import path from "path";
+import semver from "semver";
+import { fsx } from "@simplysm/core-node";
+import { json } from "@simplysm/core-common";
+
+/**
+ * package.json 타입 (필수 필드만)
+ */
+export interface PackageJson {
+  name: string;
+  version: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+}
+
+/**
+ * 프로젝트 및 패키지 버전 업그레이드
+ * @param dryRun true이면 파일을 수정하지 않고 새 버전만 계산
+ */
+export async function upgradeVersion(
+  cwd: string,
+  allPkgPaths: string[],
+  dryRun: boolean,
+): Promise<{ version: string; changedFiles: string[] }> {
+  const changedFiles: string[] = [];
+  const projPkgPath = path.resolve(cwd, "package.json");
+  const projPkg = await fsx.readJson<PackageJson>(projPkgPath);
+
+  const currentVersion = projPkg.version;
+  const prereleaseInfo = semver.prerelease(currentVersion);
+
+  // 프리릴리스 여부에 따라 증가 전략 결정
+  const newVersion =
+    prereleaseInfo !== null
+      ? semver.inc(currentVersion, "prerelease")!
+      : semver.inc(currentVersion, "patch")!;
+
+  if (dryRun) {
+    // dry-run: 파일을 수정하지 않고 새 버전만 반환
+    return { version: newVersion, changedFiles: [] };
+  }
+
+  projPkg.version = newVersion;
+  await fsx.write(projPkgPath, json.stringify(projPkg, { space: 2 }) + "\n");
+  changedFiles.push(projPkgPath);
+
+  // 각 패키지의 package.json에 버전 설정
+  for (const pkgPath of allPkgPaths) {
+    const pkgJsonPath = path.resolve(pkgPath, "package.json");
+    const pkgJson = await fsx.readJson<PackageJson>(pkgJsonPath);
+    pkgJson.version = newVersion;
+    await fsx.write(pkgJsonPath, json.stringify(pkgJson, { space: 2 }) + "\n");
+    changedFiles.push(pkgJsonPath);
+  }
+
+  // 템플릿 파일의 @simplysm 패키지 버전 동기화
+  const templateFiles = await fsx.glob(path.resolve(cwd, "packages/sd-cli/templates/**/*.hbs"));
+  const versionRegex = /("@simplysm\/[^"]+"\s*:\s*)"~[^"]+"/g;
+
+  for (const templatePath of templateFiles) {
+    const content = await fsx.read(templatePath);
+    const newContent = content.replace(versionRegex, `$1"~${newVersion}"`);
+
+    if (content !== newContent) {
+      await fsx.write(templatePath, newContent);
+      changedFiles.push(templatePath);
+    }
+  }
+
+  return { version: newVersion, changedFiles };
+}
+
+/**
+ * 배포할 패키지의 의존성 레벨을 계산한다.
+ * 의존성이 없는 패키지 → Level 0, Level 0에만 의존하는 패키지 → Level 1, ...
+ */
+export async function computePublishLevels<T extends { name: string; path: string }>(
+  publishPkgs: T[],
+): Promise<T[][]> {
+  const pkgNames = new Set(publishPkgs.map((p) => p.name));
+
+  // 각 패키지의 워크스페이스 의존성 수집
+  const depsMap = new Map<string, Set<string>>();
+  for (const pkg of publishPkgs) {
+    const pkgJson = await fsx.readJson<PackageJson>(path.resolve(pkg.path, "package.json"));
+    const allDeps = {
+      ...pkgJson.dependencies,
+      ...pkgJson.peerDependencies,
+      ...pkgJson.optionalDependencies,
+    };
+
+    const workspaceDeps = new Set<string>();
+    for (const depName of Object.keys(allDeps)) {
+      const shortName = depName.replace(/^@simplysm\//, "");
+      if (shortName !== depName && pkgNames.has(shortName)) {
+        workspaceDeps.add(shortName);
+      }
+    }
+    depsMap.set(pkg.name, workspaceDeps);
+  }
+
+  // 위상 정렬로 레벨 분류
+  const levels: T[][] = [];
+  const assigned = new Set<string>();
+  const remaining = new Map(publishPkgs.map((p) => [p.name, p]));
+
+  while (remaining.size > 0) {
+    const level: T[] = [];
+    for (const [name, pkg] of remaining) {
+      const deps = depsMap.get(name)!;
+      if ([...deps].every((d) => assigned.has(d))) {
+        level.push(pkg);
+      }
+    }
+
+    if (level.length === 0) {
+      // 순환 의존성 — 나머지 패키지를 마지막 레벨에 배치
+      levels.push([...remaining.values()]);
+      break;
+    }
+
+    for (const pkg of level) {
+      assigned.add(pkg.name);
+      remaining.delete(pkg.name);
+    }
+    levels.push(level);
+  }
+
+  return levels;
+}

package/src/commands/replace-deps.ts

@@ -1,6 +1,6 @@
 import { consola } from "consola";
 import { loadSdConfig } from "../utils/sd-config";
-import { setupReplaceDeps } from "../utils/replace-deps";
+import { setupReplaceDeps } from "../deps/replace-deps/replace-deps";
 
 /**
  * replace-deps 명령어 옵션

package/src/commands/watch.ts

@@ -1,14 +1,13 @@
 import {
-  DevWatchOrchestrator,
-  type DevWatchOrchestratorOptions,
-} from "../orchestrators/DevWatchOrchestrator";
+  WatchOrchestrator,
+  type WatchOrchestratorOptions,
+} from "../orchestrators/WatchOrchestrator";
 
 /**
- * DevWatchOrchestrator를 통해 모든 패키지를 watch 모드로 빌드한다.
+ * WatchOrchestrator를 통해 모든 패키지를 watch 모드로 빌드한다.
  *
  * - `sd.config.ts`를 로드하여 패키지별 빌드 대상 정보를 확인한다
  * - `node`/`browser`/`neutral` target: esbuild watch 모드 빌드 + .d.ts 생성
- * - `server` target: esbuild watch 모드 빌드 (런타임 없음)
  * - `scripts` target (watch 설정 있을 때): 파일 변경 시 hook 실행
  * - 파일 변경 시 자동 재빌드
  * - SIGINT/SIGTERM 시그널로 종료
@@ -16,8 +15,8 @@ import {
  * @param options - watch 실행 옵션 (targets, options)
  * @returns 종료 시그널 수신 시 resolve
  */
-export async function runWatch(options: Omit<DevWatchOrchestratorOptions, "mode">): Promise<void> {
-  const orchestrator = new DevWatchOrchestrator({ mode: "watch", ...options });
+export async function runWatch(options: WatchOrchestratorOptions): Promise<void> {
+  const orchestrator = new WatchOrchestrator(options);
 
   try {
     await orchestrator.initialize();

package/src/deps/replace-deps/collect-deps.ts

@@ -0,0 +1,92 @@
+import path from "path";
+import fs from "fs";
+import { consola } from "consola";
+import { pathx } from "@simplysm/core-node";
+import { discoverWorkspacePackages } from "../../utils/package-utils";
+
+const logger = consola.withTag("sd:cli:collect-deps");
+
+export interface DepsResult {
+  workspaceDeps: string[];
+  replaceDeps: string[];
+}
+
+/**
+ * pnpm-workspace.yaml 기반으로 workspace 패키지의 name → 상대 디렉토리 맵을 구성한다.
+ * 예: "@simplysm/core-node" → "packages/core-node"
+ */
+function buildWorkspacePkgMap(cwd: string): Map<string, string> {
+  const map = new Map<string, string>();
+  const wsPkgs = discoverWorkspacePackages(cwd);
+  for (const [, relDir] of wsPkgs) {
+    const pkgJsonPath = pathx.posix(path.join(cwd, relDir, "package.json"));
+    if (!fs.existsSync(pkgJsonPath)) continue;
+    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8")) as { name: string };
+    map.set(pkgJson.name, relDir);
+  }
+  return map;
+}
+
+export function collectDeps(
+  pkgDir: string,
+  cwd: string,
+  replaceDepsConfig?: Record<string, string>,
+): DepsResult {
+  const startTime = performance.now();
+  logger.debug("의존성 수집 시작");
+
+  // pnpm-workspace.yaml에서 workspace 패키지 디렉토리 패턴을 읽어 실제 패키지 맵 구성
+  const workspacePkgMap = buildWorkspacePkgMap(cwd);
+
+  const replaceDepsPatterns: Array<{ regex: RegExp }> = [];
+  if (replaceDepsConfig != null) {
+    for (const pattern of Object.keys(replaceDepsConfig)) {
+      const regexStr = pattern.replace(/[.+]/g, (ch) => `\\${ch}`).replace(/\*/g, "[^/]+");
+      replaceDepsPatterns.push({ regex: new RegExp(`^${regexStr}$`) });
+    }
+  }
+
+  const workspaceDeps: string[] = [];
+  const replaceDeps: string[] = [];
+  const visited = new Set<string>();
+
+  function traverse(dir: string): void {
+    const pkgJsonPath = pathx.posix(path.join(dir, "package.json"));
+    if (!fs.existsSync(pkgJsonPath)) return;
+
+    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8")) as {
+      dependencies?: Record<string, string>;
+    };
+    const deps = Object.keys(pkgJson.dependencies ?? {});
+
+    for (const dep of deps) {
+      if (visited.has(dep)) continue;
+      visited.add(dep);
+
+      // 워크스페이스 패키지 확인
+      const wsDir = workspacePkgMap.get(dep);
+      if (wsDir != null) {
+        workspaceDeps.push(path.basename(wsDir));
+        traverse(pathx.posix(path.join(cwd, wsDir)));
+        continue;
+      }
+
+      // replaceDeps 패턴 확인
+      const matched = replaceDepsPatterns.find((p) => p.regex.test(dep));
+      if (matched != null) {
+        replaceDeps.push(dep);
+        const depNodeModulesDir = pathx.posix(path.join(cwd, "node_modules", ...dep.split("/")));
+        if (fs.existsSync(pathx.posix(path.join(depNodeModulesDir, "package.json")))) {
+          traverse(depNodeModulesDir);
+        }
+        continue;
+      }
+    }
+  }
+
+  traverse(pkgDir);
+  logger.debug(
+    `의존성 수집 완료: workspace=${String(workspaceDeps.length)}, replace=${String(replaceDeps.length)} (${Math.round(performance.now() - startTime)}ms)`,
+  );
+  return { workspaceDeps, replaceDeps };
+}

package/src/{utils/replace-deps.ts → deps/replace-deps/replace-deps-resolve.ts}

@@ -1,10 +1,8 @@
 import fs from "fs";
 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";
+import type { consola } from "consola";
+import { pathx } from "@simplysm/core-node";
 
 /**
  * replaceDeps 설정의 glob 패턴을 대상 패키지 목록과 매칭하여
@@ -85,23 +83,6 @@ export function parseWorkspaceGlobs(content: string): string[] {
   return globs;
 }
 
-/**
- * 복사 시 제외할 이름 목록
- */
-const EXCLUDED_NAMES = new Set(["node_modules", "package.json", ".cache", "tests"]);
-
-/**
- * replaceDeps 복사용 필터 함수
- * node_modules, package.json, .cache, tests를 제외한다.
- *
- * @param itemPath - 복사할 항목의 절대 경로
- * @returns 복사 대상이면 true, 제외 대상이면 false
- */
-function replaceDepsCopyFilter(itemPath: string): boolean {
-  const basename = path.basename(itemPath);
-  return !EXCLUDED_NAMES.has(basename);
-}
-
 /**
  * replaceDeps 복사/교체 항목
  */
@@ -113,14 +94,6 @@ export interface ReplaceDepEntry {
   actualTargetPath: string;
 }
 
-/**
- * watchReplaceDeps의 반환 타입
- */
-export interface WatchReplaceDepResult {
-  entries: ReplaceDepEntry[];
-  dispose: () => void;
-}
-
 /**
  * 프로젝트 루트 및 워크스페이스 패키지 경로를 수집한다.
  *
@@ -161,7 +134,7 @@ async function collectSearchRoots(projectRoot: string): Promise<string[]> {
  * @param logger - consola 로거
  * @returns 해결된 교체 대상 항목 배열
  */
-async function resolveAllReplaceDepEntries(
+export async function resolveAllReplaceDepEntries(
   projectRoot: string,
   replaceDeps: Record<string, string>,
   logger: ReturnType<typeof consola.withTag>,
@@ -193,7 +166,7 @@ async function resolveAllReplaceDepEntries(
     const targetNames: string[] = [];
     for (const pattern of Object.keys(replaceDeps)) {
       const matches = await glob(pattern, { cwd: nodeModulesDir });
-      targetNames.push(...matches);
+      targetNames.push(...matches.map((m) => m.replaceAll("\\", "/")));
     }
 
     logger.debug(`[replace-deps] 탐색: ${nodeModulesDir} → ${targetNames.length}개 매칭 (${targetNames.join(", ")})`);
@@ -248,160 +221,3 @@ async function resolveAllReplaceDepEntries(
 
   return entries;
 }
-
-/**
- * replaceDeps 설정에 따라 node_modules의 패키지를 소스 디렉토리로 교체한다.
- *
- * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
- * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
- * 3. 기존 symlink/디렉토리 제거 → 소스 경로 복사 (node_modules, package.json, .cache, tests 제외)
- *
- * @param projectRoot - 프로젝트 루트 경로
- * @param replaceDeps - sd.config.ts의 replaceDeps 설정
- */
-export async function setupReplaceDeps(
-  projectRoot: string,
-  replaceDeps: Record<string, string>,
-): Promise<void> {
-  const logger = consola.withTag("sd:cli:replace-deps");
-  let setupCount = 0;
-
-  logger.start("replace-deps 설정 중...");
-
-  const entries = await resolveAllReplaceDepEntries(projectRoot, replaceDeps, logger);
-
-  for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
-    try {
-      // 소스 파일을 actualTargetPath에 덮어쓰기 복사 (기존 디렉토리 유지, symlink 보존)
-      await fsx.copy(resolvedSourcePath, actualTargetPath, replaceDepsCopyFilter);
-
-      setupCount += 1;
-    } catch (err) {
-      logger.error(`[${targetName}] 복사 실패: ${err instanceof Error ? err.message : err}`);
-    }
-  }
-
-  logger.success(`replace-deps 설정 완료 (${setupCount}개 의존성 교체)`);
-
-  // 교체된 패키지의 postinstall 스크립트 실행
-  for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
-    const sourcePkgJsonPath = pathx.posix(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.warn(`[${targetName}] postinstall 스크립트 실행: ${postinstall}`);
-      logger.start(`[${targetName}] postinstall 실행 중...`);
-      await promisify(exec)(postinstall, { cwd: actualTargetPath });
-      logger.success(`[${targetName}] postinstall 실행 완료`);
-    } catch (err) {
-      logger.error(
-        `[${targetName}] postinstall 실패: ${err instanceof Error ? err.message : err}`,
-      );
-    }
-  }
-}
-
-/**
- * replaceDeps 설정에 따라 소스 디렉토리를 감시하고 변경사항을 대상 경로에 복사한다.
- *
- * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
- * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
- * 3. FsWatcher로 소스 디렉토리 감시 (300ms 딜레이)
- * 4. 변경사항을 대상 경로에 복사 (node_modules, package.json, .cache, tests 제외)
- *
- * @param projectRoot - 프로젝트 루트 경로
- * @param replaceDeps - sd.config.ts의 replaceDeps 설정
- * @returns entries 및 dispose 함수
- */
-export async function watchReplaceDeps(
-  projectRoot: string,
-  replaceDeps: Record<string, string>,
-): Promise<WatchReplaceDepResult> {
-  const logger = consola.withTag("sd:cli:replace-deps:watch");
-
-  const entries = await resolveAllReplaceDepEntries(projectRoot, replaceDeps, logger);
-
-  // 소스 디렉토리 감시자 설정
-  const watchers: FsWatcher[] = [];
-  const watchedSources = new Set<string>();
-
-  logger.start(`replace-deps 워치 시작 중... (${entries.length}개 대상)`);
-
-  for (const entry of entries) {
-    if (watchedSources.has(entry.resolvedSourcePath)) continue;
-    watchedSources.add(entry.resolvedSourcePath);
-
-    const excludedPaths = [...EXCLUDED_NAMES].map((name) =>
-      pathx.posix(path.join(entry.resolvedSourcePath, name)),
-    );
-
-    const watcher = await FsWatcher.watch([entry.resolvedSourcePath], {
-      followSymlinks: false,
-      ignored: [...EXCLUDED_NAMES].map((name) => `**/${name}`),
-    });
-    watcher.onChange({ delay: 300 }, async (changeInfos) => {
-      for (const { path: changedPath } of changeInfos) {
-        // 제외 항목 필터: basename 매칭 또는 제외 디렉토리 내 경로
-        if (
-          EXCLUDED_NAMES.has(path.basename(changedPath)) ||
-          excludedPaths.some((ep) => pathx.isChildPath(changedPath, ep))
-        ) {
-          continue;
-        }
-
-        // 이 소스 경로를 사용하는 모든 항목에 대해 복사
-        for (const e of entries) {
-          if (e.resolvedSourcePath !== entry.resolvedSourcePath) continue;
-
-          // 소스로부터의 상대 경로 계산
-          const relativePath = pathx.posix(path.relative(e.resolvedSourcePath, changedPath));
-          const destPath = pathx.posix(path.join(e.actualTargetPath, relativePath));
-
-          try {
-            // 소스 존재 여부 확인
-            let sourceExists = false;
-            try {
-              await fs.promises.access(changedPath);
-              sourceExists = true;
-            } catch {
-              // 소스가 삭제됨
-            }
-
-            if (sourceExists) {
-              // 소스가 디렉토리인지 파일인지 확인
-              const stat = await fs.promises.stat(changedPath);
-              if (stat.isDirectory()) {
-                await fsx.mkdir(destPath);
-              } else {
-                await fsx.mkdir(pathx.posix(path.dirname(destPath)));
-                await fsx.copy(changedPath, destPath, replaceDepsCopyFilter);
-              }
-            } else {
-              // 소스가 삭제됨 → 대상도 삭제
-              await fsx.rm(destPath);
-            }
-          } catch (err) {
-            logger.error(
-              `[${e.targetName}] 복사 실패 (${relativePath}): ${err instanceof Error ? err.message : err}`,
-            );
-          }
-        }
-      }
-    });
-
-    watchers.push(watcher);
-  }
-
-  logger.success("replace-deps 워치 준비 완료");
-
-  return {
-    entries,
-    dispose: () => {
-      for (const watcher of watchers) {
-        void watcher.close();
-      }
-    },
-  };
-}