@simplysm/sd-cli 13.0.11 → 13.0.12

package/src/commands/device.ts

@@ -1,5 +1,4 @@
 import path from "path";
-import { Listr } from "listr2";
 import { fsExists } from "@simplysm/core-node";
 import { consola } from "consola";
 import type { SdConfig, SdClientPackageConfig } from "../sd-config.types";
@@ -47,7 +46,7 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
     sdConfig = await loadSdConfig({ cwd, dev: true, opt: options.options });
     logger.debug("sd.config.ts 로드 완료");
   } catch (err) {
-    consola.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);
+    logger.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);
     process.exitCode = 1;
     return;
   }
@@ -55,13 +54,13 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
   // 패키지 설정 확인
   const pkgConfig = sdConfig.packages[packageName];
   if (pkgConfig == null) {
-    consola.error(`패키지를 찾을 수 없습니다: ${packageName}`);
+    logger.error(`패키지를 찾을 수 없습니다: ${packageName}`);
     process.exitCode = 1;
     return;
   }
 
   if (pkgConfig.target !== "client") {
-    consola.error(`client 타겟 패키지만 지원합니다: ${packageName} (현재: ${pkgConfig.target})`);
+    logger.error(`client 타겟 패키지만 지원합니다: ${packageName} (현재: ${pkgConfig.target})`);
     process.exitCode = 1;
     return;
   }
@@ -76,7 +75,7 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
       if (typeof clientConfig.server === "number") {
         serverUrl = `http://localhost:${clientConfig.server}/${packageName}/`;
       } else {
-        consola.error(`--url 옵션이 필요합니다. server가 패키지명으로 설정되어 있습니다: ${clientConfig.server}`);
+        logger.error(`--url 옵션이 필요합니다. server가 패키지명으로 설정되어 있습니다: ${clientConfig.server}`);
         process.exitCode = 1;
         return;
       }
@@ -84,21 +83,13 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
 
     logger.debug("개발 서버 URL", { serverUrl });
 
-    const listr = new Listr([
-      {
-        title: `${packageName} (electron)`,
-        task: async () => {
-          const electron = await Electron.create(pkgDir, clientConfig.electron!);
-          await electron.run(serverUrl);
-        },
-      },
-    ]);
-
+    logger.start(`${packageName} (electron) 실행 중...`);
     try {
-      await listr.run();
-      logger.info("Electron 실행 완료");
+      const electron = await Electron.create(pkgDir, clientConfig.electron);
+      await electron.run(serverUrl);
+      logger.success("Electron 실행 완료");
     } catch (err) {
-      consola.error(`Electron 실행 실패: ${err instanceof Error ? err.message : err}`);
+      logger.error(`Electron 실행 실패: ${err instanceof Error ? err.message : err}`);
       process.exitCode = 1;
     }
   } else if (clientConfig.capacitor != null) {
@@ -108,7 +99,7 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
       if (typeof clientConfig.server === "number") {
         serverUrl = `http://localhost:${clientConfig.server}/${packageName}/capacitor/`;
       } else {
-        consola.error(`--url 옵션이 필요합니다. server가 패키지명으로 설정되어 있습니다: ${clientConfig.server}`);
+        logger.error(`--url 옵션이 필요합니다. server가 패키지명으로 설정되어 있습니다: ${clientConfig.server}`);
         process.exitCode = 1;
         return;
       }
@@ -120,30 +111,22 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
 
     const capPath = path.join(pkgDir, ".capacitor");
     if (!(await fsExists(capPath))) {
-      consola.error(`Capacitor 프로젝트가 초기화되지 않았습니다. 먼저 'pnpm watch ${packageName}'를 실행하세요.`);
+      logger.error(`Capacitor 프로젝트가 초기화되지 않았습니다. 먼저 'pnpm watch ${packageName}'를 실행하세요.`);
       process.exitCode = 1;
       return;
     }
 
-    const listr = new Listr([
-      {
-        title: `${packageName} (device)`,
-        task: async () => {
-          const cap = await Capacitor.create(pkgDir, clientConfig.capacitor!);
-          await cap.runOnDevice(serverUrl);
-        },
-      },
-    ]);
-
+    logger.start(`${packageName} (device) 실행 중...`);
     try {
-      await listr.run();
-      logger.info("디바이스 실행 완료");
+      const cap = await Capacitor.create(pkgDir, clientConfig.capacitor);
+      await cap.runOnDevice(serverUrl);
+      logger.success("디바이스 실행 완료");
     } catch (err) {
-      consola.error(`디바이스 실행 실패: ${err instanceof Error ? err.message : err}`);
+      logger.error(`디바이스 실행 실패: ${err instanceof Error ? err.message : err}`);
       process.exitCode = 1;
     }
   } else {
-    consola.error(`electron 또는 capacitor 설정이 없습니다: ${packageName}`);
+    logger.error(`electron 또는 capacitor 설정이 없습니다: ${packageName}`);
     process.exitCode = 1;
   }
 }

package/src/commands/init.ts

@@ -3,6 +3,7 @@ import fs from "fs";
 import { consola } from "consola";
 import { renderTemplateDir } from "../utils/template";
 import { spawn } from "../utils/spawn";
+import { findPackageRoot } from "../utils/package-utils";
 
 //#region Types
 
@@ -15,19 +16,6 @@ export interface InitOptions {}
 
 //#region Utilities
 
-/**
- * import.meta.dirname에서 상위로 올라가며 package.json을 찾아 패키지 루트를 반환한다.
- */
-function findPackageRoot(startDir: string): string {
-  let dir = startDir;
-  while (!fs.existsSync(path.join(dir, "package.json"))) {
-    const parent = path.dirname(dir);
-    if (parent === dir) throw new Error("package.json을 찾을 수 없습니다.");
-    dir = parent;
-  }
-  return dir;
-}
-
 /**
  * npm 스코프 이름 유효성 검증
  */

package/src/commands/lint.ts

@@ -1,11 +1,10 @@
 import { ESLint } from "eslint";
 import { createJiti } from "jiti";
 import path from "path";
-import { Listr } from "listr2";
 import { fsExists, fsGlob, pathFilterByTargets } from "@simplysm/core-node";
 import "@simplysm/core-common";
 import { SdError } from "@simplysm/core-common";
-import { consola, LogLevels } from "consola";
+import { consola } from "consola";
 import stylelint from "stylelint";
 
 //#region Types
@@ -22,23 +21,6 @@ export interface LintOptions {
   timing: boolean;
 }
 
-/**
- * Listr2 컨텍스트 타입
- */
-interface LintContext {
-  ignorePatterns: string[];
-  /** 파일 수집 태스크 완료 후 초기화됨 */
-  files?: string[];
-  /** 린트 대상 파일이 있을 때만 초기화됨 */
-  eslint?: ESLint;
-  /** 린트 대상 파일이 있을 때만 초기화됨 */
-  results?: ESLint.LintResult[];
-  // Stylelint
-  hasStylelintConfig?: boolean;
-  cssFiles?: string[];
-  stylelintResult?: stylelint.LinterResult;
-}
-
 //#endregion
 
 //#region Utilities
@@ -124,7 +106,7 @@ async function hasStylelintConfig(cwd: string): Promise<boolean> {
  * ESLint를 실행한다.
  *
  * - `eslint.config.ts/js`에서 globalIgnores 패턴을 추출하여 glob 필터링에 적용
- * - listr2를 사용하여 진행 상황 표시
+ * - consola를 사용하여 진행 상황 표시
  * - 캐시 활성화 (`.cache/eslint.cache`에 저장, 설정 변경 시 자동 무효화)
  * - 에러 발생 시 `process.exitCode = 1` 설정
  *
@@ -143,133 +125,90 @@ export async function runLint(options: LintOptions): Promise<void> {
     process.env["TIMING"] = "1";
   }
 
-  const listr = new Listr<LintContext, "default" | "verbose">(
-    [
-      {
-        title: "ESLint 설정 로드",
-        task: async (ctx, task) => {
-          ctx.ignorePatterns = await loadIgnorePatterns(cwd);
-          logger.debug("ignore 패턴 로드 완료", { ignorePatternCount: ctx.ignorePatterns.length });
-          task.title = `ESLint 설정 로드 (${ctx.ignorePatterns.length}개 ignore 패턴)`;
-        },
-      },
-      {
-        title: "린트 대상 파일 수집",
-        task: async (ctx, task) => {
-          let files = await fsGlob("**/*.{ts,tsx,js,jsx}", {
-            cwd,
-            ignore: ctx.ignorePatterns,
-            nodir: true,
-            absolute: true,
-          });
-
-          // targets가 주어지면 해당 경로의 하위 파일만 필터링
-          files = pathFilterByTargets(files, targets, cwd);
-          ctx.files = files;
-          logger.debug("파일 수집 완료", { fileCount: files.length });
-          task.title = `린트 대상 파일 수집 (${files.length}개)`;
-
-          if (files.length === 0) {
-            task.skip("린트할 파일이 없습니다.");
-          }
-        },
-      },
-      {
-        title: "린트 실행",
-        enabled: (ctx) => (ctx.files?.length ?? 0) > 0,
-        task: async (ctx, task) => {
-          const files = ctx.files!;
-          task.title = `린트 실행 중... (${files.length}개 파일)`;
-          ctx.eslint = new ESLint({
-            cwd,
-            fix,
-            cache: true,
-            cacheLocation: path.join(cwd, ".cache", "eslint.cache"),
-          });
-          ctx.results = await ctx.eslint.lintFiles(files);
-        },
-      },
-      {
-        title: "자동 수정 적용",
-        enabled: () => fix,
-        skip: (ctx) => (ctx.files?.length ?? 0) === 0 || ctx.results == null,
-        task: async (ctx) => {
-          if (ctx.results == null) return;
-          await ESLint.outputFixes(ctx.results);
-          logger.debug("자동 수정 적용 완료");
-        },
-      },
-      {
-        title: "Stylelint 설정 확인",
-        task: async (ctx, task) => {
-          ctx.hasStylelintConfig = await hasStylelintConfig(cwd);
-          if (!ctx.hasStylelintConfig) {
-            task.skip("stylelint.config 파일 없음");
-          }
-        },
-      },
-      {
-        title: "CSS 파일 수집",
-        enabled: (ctx) => ctx.hasStylelintConfig === true,
-        task: async (ctx, task) => {
-          let cssFiles = await fsGlob("**/*.css", {
-            cwd,
-            ignore: ctx.ignorePatterns,
-            nodir: true,
-            absolute: true,
-          });
-          cssFiles = pathFilterByTargets(cssFiles, targets, cwd);
-          ctx.cssFiles = cssFiles;
-          task.title = `CSS 파일 수집 (${cssFiles.length}개)`;
-          if (cssFiles.length === 0) {
-            task.skip("린트할 CSS 파일이 없습니다.");
-          }
-        },
-      },
-      {
-        title: "Stylelint 실행",
-        enabled: (ctx) => (ctx.cssFiles?.length ?? 0) > 0,
-        task: async (ctx, task) => {
-          const cssFiles = ctx.cssFiles!;
-          task.title = `Stylelint 실행 중... (${cssFiles.length}개 파일)`;
-
-          // Stylelint 설정 파일 경로 찾기
-          let configFile: string | undefined;
-          for (const f of STYLELINT_CONFIG_FILES) {
-            const configPath = path.join(cwd, f);
-            if (await fsExists(configPath)) {
-              configFile = configPath;
-              break;
-            }
-          }
-
-          const result = await stylelint.lint({
-            files: cssFiles,
-            configFile,
-            fix,
-            cache: true,
-            cacheLocation: path.join(cwd, ".cache", "stylelint.cache"),
-          });
-          ctx.stylelintResult = result;
-        },
-      },
-    ],
-    {
-      renderer: consola.level >= LogLevels.debug ? "verbose" : "default",
-    },
-  );
-
-  const ctx = await listr.run();
+  // ESLint 설정 로드
+  logger.start("ESLint 설정 로드");
+  const ignorePatterns = await loadIgnorePatterns(cwd);
+  logger.debug("ignore 패턴 로드 완료", { ignorePatternCount: ignorePatterns.length });
+  logger.success(`ESLint 설정 로드 (${ignorePatterns.length}개 ignore 패턴)`);
+
+  // 린트 대상 파일 수집
+  logger.start("린트 대상 파일 수집");
+  let files = await fsGlob("**/*.{ts,tsx,js,jsx}", {
+    cwd,
+    ignore: ignorePatterns,
+    nodir: true,
+    absolute: true,
+  });
+  files = pathFilterByTargets(files, targets, cwd);
+  logger.debug("파일 수집 완료", { fileCount: files.length });
+  logger.success(`린트 대상 파일 수집 (${files.length}개)`);
+
+  // 린트 실행
+  let eslint: ESLint | undefined;
+  let eslintResults: ESLint.LintResult[] | undefined;
+  if (files.length > 0) {
+    logger.start(`린트 실행 중... (${files.length}개 파일)`);
+    eslint = new ESLint({
+      cwd,
+      fix,
+      cache: true,
+      cacheLocation: path.join(cwd, ".cache", "eslint.cache"),
+    });
+    eslintResults = await eslint.lintFiles(files);
+    logger.success("린트 실행 완료");
+
+    // 자동 수정 적용
+    if (fix) {
+      logger.debug("자동 수정 적용 중...");
+      await ESLint.outputFixes(eslintResults);
+      logger.debug("자동 수정 적용 완료");
+    }
+  }
+
+  // Stylelint
+  const hasStylelintCfg = await hasStylelintConfig(cwd);
+  let stylelintResult: stylelint.LinterResult | undefined;
+  if (hasStylelintCfg) {
+    logger.start("CSS 파일 수집");
+    let cssFiles = await fsGlob("**/*.css", {
+      cwd,
+      ignore: ignorePatterns,
+      nodir: true,
+      absolute: true,
+    });
+    cssFiles = pathFilterByTargets(cssFiles, targets, cwd);
+    logger.success(`CSS 파일 수집 (${cssFiles.length}개)`);
+
+    if (cssFiles.length > 0) {
+      logger.start(`Stylelint 실행 중... (${cssFiles.length}개 파일)`);
+      let configFile: string | undefined;
+      for (const f of STYLELINT_CONFIG_FILES) {
+        const configPath = path.join(cwd, f);
+        if (await fsExists(configPath)) {
+          configFile = configPath;
+          break;
+        }
+      }
+      stylelintResult = await stylelint.lint({
+        files: cssFiles,
+        configFile,
+        fix,
+        cache: true,
+        cacheLocation: path.join(cwd, ".cache", "stylelint.cache"),
+      });
+      logger.success("Stylelint 실행 완료");
+    }
+  }
 
   // 파일이 없거나 린트가 실행되지 않았으면 조기 종료
-  if ((ctx.files?.length ?? 0) === 0 || ctx.results == null || ctx.eslint == null) {
+  if (files.length === 0 || eslintResults == null || eslint == null) {
     logger.info("린트할 파일 없음");
     return;
   }
 
   // 결과 집계
-  const errorCount = ctx.results.sum((r) => r.errorCount);
-  const warningCount = ctx.results.sum((r) => r.warningCount);
+  const errorCount = eslintResults.sum((r) => r.errorCount);
+  const warningCount = eslintResults.sum((r) => r.warningCount);
 
   if (errorCount > 0) {
     logger.error("린트 에러 발생", { errorCount, warningCount });
@@ -280,8 +219,8 @@ export async function runLint(options: LintOptions): Promise<void> {
   }
 
   // 포맷터 출력
-  const formatter = await ctx.eslint.loadFormatter("stylish");
-  const resultText = await formatter.format(ctx.results);
+  const formatter = await eslint.loadFormatter("stylish");
+  const resultText = await formatter.format(eslintResults);
   if (resultText) {
     process.stdout.write(resultText);
   }
@@ -292,11 +231,11 @@ export async function runLint(options: LintOptions): Promise<void> {
   }
 
   // Stylelint 결과 출력
-  if (ctx.stylelintResult != null && ctx.stylelintResult.results.length > 0) {
-    const stylelintErrorCount = ctx.stylelintResult.results.sum(
+  if (stylelintResult != null && stylelintResult.results.length > 0) {
+    const stylelintErrorCount = stylelintResult.results.sum(
       (r) => r.warnings.filter((w) => w.severity === "error").length,
     );
-    const stylelintWarningCount = ctx.stylelintResult.results.sum(
+    const stylelintWarningCount = stylelintResult.results.sum(
       (r) => r.warnings.filter((w) => w.severity === "warning").length,
     );
 
@@ -313,7 +252,7 @@ export async function runLint(options: LintOptions): Promise<void> {
 
     // Stylelint formatter 출력
     const stylelintFormatter = await stylelint.formatters.string;
-    const stylelintOutput = stylelintFormatter(ctx.stylelintResult.results, ctx.stylelintResult);
+    const stylelintOutput = stylelintFormatter(stylelintResult.results, stylelintResult);
     if (stylelintOutput) {
       process.stdout.write(stylelintOutput);
     }

package/src/commands/publish.ts

@@ -1,7 +1,6 @@
 import path from "path";
 import semver from "semver";
-import { consola, LogLevels } from "consola";
-import { Listr, type ListrTask } from "listr2";
+import { consola } from "consola";
 import { StorageFactory } from "@simplysm/storage";
 import { fsExists, fsRead, fsReadJson, fsWrite, fsGlob, fsCopy } from "@simplysm/core-node";
 import { env, jsonStringify } from "@simplysm/core-common";
@@ -10,6 +9,7 @@ import type { SdConfig, SdPublishConfig } from "../sd-config.types";
 import { loadSdConfig } from "../utils/sd-config";
 import { spawn } from "../utils/spawn";
 import { runBuild } from "./build";
+import { parseWorkspaceGlobs } from "../utils/replace-deps";
 import os from "os";
 import fs from "fs";
 import ssh2 from "ssh2";
@@ -214,10 +214,11 @@ function registerSshPublicKey(
     const conn = new SshClient();
     conn.on("ready", () => {
       // authorized_keys에 공개키 추가
+      const escapedKey = publicKey.replace(/'/g, "'\\''");
       const cmd = [
         "mkdir -p ~/.ssh",
         "chmod 700 ~/.ssh",
-        `echo '${publicKey}' >> ~/.ssh/authorized_keys`,
+        `echo '${escapedKey}' >> ~/.ssh/authorized_keys`,
         "chmod 600 ~/.ssh/authorized_keys",
       ].join(" && ");
 
@@ -481,7 +482,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
     sdConfig = await loadSdConfig({ cwd, dev: false, opt: options.options });
     logger.debug("sd.config.ts 로드 완료");
   } catch (err) {
-    consola.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);
+    logger.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);
     process.exitCode = 1;
     return;
   }
@@ -495,26 +496,12 @@ export async function runPublish(options: PublishOptions): Promise<void> {
   const workspaceGlobs: string[] = [];
   if (await fsExists(workspaceYamlPath)) {
     const yamlContent = await fsRead(workspaceYamlPath);
-    let inPackages = false;
-    for (const line of yamlContent.split("\n")) {
-      if (/^packages:\s*$/.test(line)) {
-        inPackages = true;
-        continue;
-      }
-      if (inPackages) {
-        const match = /^\s+-\s+(.+)$/.exec(line);
-        if (match != null) {
-          workspaceGlobs.push(match[1].trim());
-        } else {
-          break;
-        }
-      }
-    }
+    workspaceGlobs.push(...parseWorkspaceGlobs(yamlContent));
   }
 
   const allPkgPaths = (await Promise.all(workspaceGlobs.map((item) => fsGlob(path.resolve(cwd, item)))))
     .flat()
-    .filter((item) => !item.includes("."));
+    .filter((item) => !path.basename(item).includes("."));
 
   // publish 설정이 있는 패키지 필터링
   const publishPackages: Array<{
@@ -571,7 +558,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
       }
       logger.debug(`npm 로그인 확인: ${whoami.trim()}`);
     } catch {
-      consola.error(
+      logger.error(
         "npm 토큰이 유효하지 않거나 만료되었습니다.\n" +
           "https://www.npmjs.com/settings/~/tokens 에서 Granular Access Token 생성 후:\n" +
           "  npm config set //registry.npmjs.org/:_authToken <토큰>",
@@ -585,7 +572,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
   try {
     await ensureSshAuth(publishPackages, logger);
   } catch (err) {
-    consola.error(`SSH 인증 설정 실패: ${err instanceof Error ? err.message : err}`);
+    logger.error(`SSH 인증 설정 실패: ${err instanceof Error ? err.message : err}`);
     process.exitCode = 1;
     return;
   }
@@ -617,7 +604,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
         logger.info("자동 커밋 완료.");
       }
     } catch (err) {
-      consola.error(err instanceof Error ? err.message : err);
+      logger.error(err instanceof Error ? err.message : err);
       process.exitCode = 1;
       return;
     }
@@ -666,7 +653,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
       if (dryRun) {
         logger.error("[DRY-RUN] 빌드 실패");
       } else {
-        consola.error(
+        logger.error(
           "빌드 실패. 수동 복구가 필요할 수 있습니다:\n" +
             "  버전 변경을 되돌리려면:\n" +
             "    git checkout -- package.json packages/*/package.json packages/sd-cli/templates/",
@@ -699,7 +686,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
           await spawn("git", ["push", "--tags"]);
           logger.debug("Git 작업 완료");
         } catch (err) {
-          consola.error(
+          logger.error(
             `Git 작업 실패: ${err instanceof Error ? err.message : err}\n` +
               "수동 복구가 필요할 수 있습니다:\n" +
               `  git revert HEAD  # 버전 커밋 되돌리기\n` +
@@ -716,59 +703,56 @@ export async function runPublish(options: PublishOptions): Promise<void> {
 
   //#endregion
 
-  //#region Phase 4: 배포 (의존성 레벨별 병렬, Listr)
+  //#region Phase 4: 배포 (의존성 레벨별 순차, 레벨 내 병렬)
 
   const levels = await computePublishLevels(publishPackages);
   const publishedPackages: string[] = [];
   let publishFailed = false;
 
-  const publishListr = new Listr(
-    levels.map(
-      (levelPkgs, levelIdx): ListrTask => ({
-        title: `Level ${levelIdx + 1}/${levels.length}`,
-        skip: () => publishFailed,
-        task: (_, task) =>
-          task.newListr(
-            levelPkgs.map(
-              (pkg): ListrTask => ({
-                title: dryRun ? `[DRY-RUN] ${pkg.name}` : pkg.name,
-                task: async (_ctx, pkgTask) => {
-                  const maxRetries = 3;
-                  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-                    try {
-                      await publishPackage(pkg.path, pkg.config, version, cwd, logger, dryRun);
-                      break;
-                    } catch (err) {
-                      if (attempt < maxRetries) {
-                        const delay = attempt * 5_000;
-                        pkgTask.title = dryRun
-                          ? `[DRY-RUN] ${pkg.name} (재시도 ${attempt + 1}/${maxRetries})`
-                          : `${pkg.name} (재시도 ${attempt + 1}/${maxRetries})`;
-                        await new Promise((resolve) => setTimeout(resolve, delay));
-                      } else {
-                        throw err;
-                      }
-                    }
-                  }
-                  publishedPackages.push(pkg.name);
-                },
-              }),
-            ),
-            { concurrent: true, exitOnError: false },
-          ),
-      }),
-    ),
-    {
-      concurrent: false,
-      exitOnError: false,
-      renderer: consola.level >= LogLevels.debug ? "verbose" : "default",
-    },
-  );
+  // 레벨별 순차 실행
+  for (let levelIdx = 0; levelIdx < levels.length; levelIdx++) {
+    if (publishFailed) break;
 
-  try {
-    await publishListr.run();
-  } catch {
-    // Listr 내부 에러는 아래에서 처리
+    const levelPkgs = levels[levelIdx];
+    logger.start(`Level ${levelIdx + 1}/${levels.length}`);
+
+    // 레벨 내 패키지 병렬 실행 (Promise.allSettled)
+    const publishPromises = levelPkgs.map(async (pkg) => {
+      const maxRetries = 3;
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+          await publishPackage(pkg.path, pkg.config, version, cwd, logger, dryRun);
+          logger.debug(dryRun ? `[DRY-RUN] ${pkg.name}` : pkg.name);
+          publishedPackages.push(pkg.name);
+          return { status: "success" as const, name: pkg.name };
+        } catch (err) {
+          if (attempt < maxRetries) {
+            const delay = attempt * 5_000;
+            logger.debug(
+              dryRun
+                ? `[DRY-RUN] ${pkg.name} (재시도 ${attempt + 1}/${maxRetries})`
+                : `${pkg.name} (재시도 ${attempt + 1}/${maxRetries})`,
+            );
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          } else {
+            throw err;
+          }
+        }
+      }
+      // TypeScript 타입 체커를 위한 fallback (실제로는 도달하지 않음)
+      return { status: "error" as const, name: pkg.name, error: new Error("Unknown error") };
+    });
+
+    const results = await Promise.allSettled(publishPromises);
+
+    // 레벨 내 실패 확인
+    const levelFailed = results.some((r) => r.status === "rejected");
+    if (levelFailed) {
+      publishFailed = true;
+      logger.fail(`Level ${levelIdx + 1}/${levels.length}`);
+    } else {
+      logger.success(`Level ${levelIdx + 1}/${levels.length}`);
+    }
   }
 
   // 실패한 패키지 확인
@@ -776,10 +760,8 @@ export async function runPublish(options: PublishOptions): Promise<void> {
   const failedPkgNames = allPkgNames.filter((n) => !publishedPackages.includes(n));
 
   if (failedPkgNames.length > 0) {
-    publishFailed = true;
-
     if (publishedPackages.length > 0) {
-      consola.error(
+      logger.error(
         "배포 중 오류가 발생했습니다.\n" +
           "이미 배포된 패키지:\n" +
           publishedPackages.map((n) => `  - ${n}`).join("\n") +
@@ -789,7 +771,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
     }
 
     for (const name of failedPkgNames) {
-      consola.error(`[${name}] 배포 실패`);
+      logger.error(`[${name}] 배포 실패`);
     }
     process.exitCode = 1;
     return;