@simplysm/sd-cli 14.2.14 → 14.2.17

package/src/commands/publish/deployment-phase.ts

@@ -24,11 +24,12 @@ async function publishPackage(
   projectPath: string,
   logger: ConsolaInstance,
   dryRun: boolean,
+  otp: string | undefined,
 ): Promise<void> {
   const pkgName = path.basename(pkgPath);
 
   if (publishConfig.type === "npm") {
-    await publishNpm(pkgPath, pkgName, version, logger, dryRun);
+    await publishNpm(pkgPath, pkgName, version, logger, dryRun, otp);
   } else if (publishConfig.type === "local-directory") {
     const targetPath = replaceEnvVariables(publishConfig.path, version, projectPath);
     await publishToLocal(pkgPath, pkgName, targetPath, logger, dryRun);
@@ -37,6 +38,80 @@ async function publishPackage(
   }
 }
 
+/** 개별 패키지 배포 결과. `error` 가 있으면 실패다. */
+interface PublishResult {
+  name: string;
+  error?: unknown;
+}
+
+/**
+ * 패키지 하나를 배포한다 (백오프 재시도 포함)
+ *
+ * npm 배포는 재시도하지 않는다. 실패 사유가 대개 인증, 권한, 버전 충돌이라 다시 걸어도 같은 결과이고,
+ * 재시도할 때마다 npm 인증 UI 가 다시 떠서 사용자를 붙잡는다. 네트워크가 관건인 나머지 배포만 재시도한다.
+ */
+async function publishWithRetry(
+  pkg: DeploymentPackage,
+  version: string,
+  projectPath: string,
+  logger: ConsolaInstance,
+  dryRun: boolean,
+  otp: string | undefined,
+): Promise<PublishResult> {
+  const maxRetries = pkg.config.type === "npm" ? 1 : 3;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      await publishPackage(pkg.path, pkg.config, version, projectPath, logger, dryRun, otp);
+      if (dryRun) {
+        logger.info(`[DRY-RUN] ${pkg.name}`);
+      } else {
+        logger.debug(pkg.name);
+      }
+      return { name: pkg.name };
+    } catch (err) {
+      if (attempt === maxRetries) {
+        return { name: pkg.name, error: err };
+      }
+      const delay = attempt * 5_000;
+      logger.warn(`${pkg.name} 배포 실패. ${delay / 1000}초 후 재시도 (${attempt + 1}/${maxRetries})`);
+      await wait.time(delay);
+    }
+  }
+  // TypeScript 타입 체커를 위한 폴백 (실제로 도달 불가)
+  return { name: pkg.name, error: new Error("알 수 없는 에러") };
+}
+
+/**
+ * 한 레벨의 패키지를 배포한다.
+ *
+ * npm 배포는 순차로 돈다. npm 이 2FA 인증을 직접 처리하며 터미널을 점유하므로(브라우저 안내,
+ * OTP 프롬프트), 동시에 띄우면 서로 입력을 뺏는다. 나머지 배포는 그대로 병렬로 돈다.
+ */
+async function publishLevel(
+  pkgs: DeploymentPackage[],
+  version: string,
+  projectPath: string,
+  logger: ConsolaInstance,
+  dryRun: boolean,
+  otp: string | undefined,
+): Promise<PublishResult[]> {
+  const run = async (pkg: DeploymentPackage): Promise<PublishResult> =>
+    publishWithRetry(pkg, version, projectPath, logger, dryRun, otp);
+
+  const [npmResults, otherResults] = await Promise.all([
+    (async () => {
+      const results: PublishResult[] = [];
+      for (const pkg of pkgs.filter((p) => p.config.type === "npm")) {
+        results.push(await run(pkg));
+      }
+      return results;
+    })(),
+    Promise.all(pkgs.filter((p) => p.config.type !== "npm").map(run)),
+  ]);
+
+  return [...npmResults, ...otherResults];
+}
+
 /**
  * 의존성 레벨별 순차 배포 (레벨 내 병렬, 재시도 포함)
  */
@@ -46,65 +121,31 @@ export async function runDeployment(
   projectPath: string,
   logger: ConsolaInstance,
   dryRun: boolean,
+  otp: string | undefined,
 ): Promise<void> {
   const levels = await computePublishLevels(publishPackages);
   const publishedPackages: string[] = [];
-  let publishFailed = false;
 
   // 레벨별 순차 실행
   for (let levelIdx = 0; levelIdx < levels.length; levelIdx++) {
-    if (publishFailed) break;
-
     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, projectPath, logger, dryRun);
-          if (dryRun) {
-            logger.info(`[DRY-RUN] ${pkg.name}`);
-          } else {
-            logger.debug(pkg.name);
-          }
-          publishedPackages.push(pkg.name);
-          return { status: "success" as const, name: pkg.name };
-        } catch (err) {
-          if (attempt < maxRetries) {
-            const delay = attempt * 5_000;
-            if (dryRun) {
-              logger.info(`[DRY-RUN] ${pkg.name} (retry ${attempt + 1}/${maxRetries})`);
-            } else {
-              logger.debug(`${pkg.name} (retry ${attempt + 1}/${maxRetries})`);
-            }
-            await wait.time(delay);
-          } else {
-            throw err;
-          }
-        }
-      }
-      // TypeScript 타입 체커를 위한 폴백 (실제로 도달 불가)
-      return { status: "error" as const, name: pkg.name, error: new Error("알 수 없는 에러") };
-    });
-
-    const results = await Promise.allSettled(publishPromises);
-
-    // 레벨 내 실패 확인
-    const rejectedResults = results.filter(
-      (r): r is PromiseRejectedResult => r.status === "rejected",
-    );
-    if (rejectedResults.length > 0) {
-      publishFailed = true;
-      for (const r of rejectedResults) {
-        logger.error(errNs.message(r.reason));
-        logger.debug(`배포 실패 스택:\n${errNs.stack(r.reason)}`);
+    const results = await publishLevel(levelPkgs, version, projectPath, logger, dryRun, otp);
+
+    publishedPackages.push(...results.filter((r) => r.error == null).map((r) => r.name));
+    const failures = results.filter((r) => r.error != null);
+
+    if (failures.length > 0) {
+      for (const f of failures) {
+        logger.error(errNs.message(f.error));
+        logger.debug(`배포 실패 스택:\n${errNs.stack(f.error)}`);
       }
       logger.error(`Level ${levelIdx + 1}/${levels.length}`);
-    } else {
-      logger.success(`Level ${levelIdx + 1}/${levels.length}`);
+      break;
     }
+
+    logger.success(`Level ${levelIdx + 1}/${levels.length}`);
   }
 
   // 실패한 패키지 확인

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

@@ -1,9 +1,78 @@
+import path from "path";
+import os from "os";
 import semver from "semver";
 import type { ConsolaInstance } from "consola";
+import { err as errNs } from "@simplysm/core-common";
+import { fsx } from "@simplysm/core-node";
 import { shellSpawn } from "../../utils/shell-spawn";
 
+/** npm classic OTP 형식 (6자리 숫자) */
+const OTP_PATTERN = /^\d{6}$/;
+
+/** 로그, 에러 메시지에 OTP 코드 대신 남길 문자열 */
+const OTP_MASK = "******";
+
+/**
+ * OTP 코드 형식을 검증한다.
+ *
+ * 셸을 거쳐 `--otp` 인자로 전달되므로, 형식을 벗어난 값은 주입 위험이 있어 거부한다.
+ */
+export function validateOtp(otp: string): string {
+  const trimmed = otp.trim();
+  if (!OTP_PATTERN.test(trimmed)) {
+    throw new Error("OTP 는 6자리 숫자여야 합니다.");
+  }
+  return trimmed;
+}
+
 /**
- * npm 레지스트리에 패키지를 배포한다
+ * 배포에 쓸 dist-tag 를 정한다. `undefined` 면 태그 없이 올려 `latest` 를 갱신한다.
+ *
+ * 레지스트리의 `latest` 보다 낮은 버전을 태그 없이 올리면 npm 이 거부한다. `--tag latest` 로
+ * 밀어붙이면 `latest` 가 끌어내려져 상위 라인 사용자가 깨지므로, `latest-14` 같은 별도 태그를 붙인다.
+ *
+ * 태그 이름에 `v14`, `14.x` 는 쓸 수 없다. npm 은 semver 범위로 해석되는 이름을 거부한다.
+ */
+async function resolveDistTag(
+  npmName: string,
+  version: string,
+  logger: ConsolaInstance,
+): Promise<string | undefined> {
+  // prerelease 는 절대 latest 가 되면 안 되므로 반드시 태그를 붙인다.
+  const prereleaseInfo = semver.prerelease(version);
+  if (prereleaseInfo != null) {
+    // 식별자가 숫자(`14.3.0-1`)이거나 범위로 읽히면 태그 이름으로 쓸 수 없다.
+    const identifier = String(prereleaseInfo[0]);
+    return semver.validRange(identifier) == null
+      ? identifier
+      : `pre-${semver.major(version)}`;
+  }
+
+  let latest: string;
+  try {
+    const { stdout } = await shellSpawn("npm", ["view", `"${npmName}"`, "dist-tags.latest"]);
+    latest = stdout.trim();
+  } catch {
+    // 아직 배포된 적 없거나 레지스트리 조회가 실패한 경우. 태그 없이 올린다.
+    // 조회 실패로 태그를 놓쳐도 npm 이 "latest 보다 낮다"며 거부하므로 조용히 잘못되지 않는다.
+    logger.debug(`[${npmName}] latest 조회 실패. 태그 없이 배포합니다.`);
+    return undefined;
+  }
+
+  if (semver.valid(latest) == null || !semver.lt(version, latest)) return undefined;
+
+  const tag = `latest-${semver.major(version)}`;
+  logger.info(`[${npmName}] latest(${latest})가 더 높아 '${tag}' 태그로 배포합니다.`);
+  return tag;
+}
+
+/**
+ * npm 레지스트리에 패키지를 배포한다.
+ *
+ * `pnpm pack` 으로 tarball 을 만든 뒤 `npm publish` 로 올린다. 두 단계로 나누는 이유:
+ * - `workspace:*` 치환과 `publishConfig` 머지는 pnpm 만 해준다. → pack 을 pnpm 으로 한다.
+ * - 2FA 인증(브라우저 로그인 창, OTP 프롬프트)은 npm 이 처리해준다. → publish 를 npm 으로 하고
+ *   TTY 를 그대로 물려줘(`stdio: "inherit"`) npm 이 사용자와 직접 대화하게 한다.
  */
 export async function publishNpm(
   pkgPath: string,
@@ -11,20 +80,69 @@ export async function publishNpm(
   version: string,
   logger: ConsolaInstance,
   dryRun: boolean,
+  otp: string | undefined,
 ): Promise<void> {
-  const prereleaseInfo = semver.prerelease(version);
-  const args = ["publish", "--access", "public", "--no-git-checks"];
+  const tmpDir = path.join(os.tmpdir(), `sd-cli-pack-${pkgName}-${Date.now().toString(36)}`);
+  await fsx.mkdir(tmpDir);
 
-  if (prereleaseInfo != null && typeof prereleaseInfo[0] === "string") {
-    args.push("--tag", prereleaseInfo[0]);
-  }
+  try {
+    logger.debug(`[${pkgName}] pnpm pack`);
+    await shellSpawn("pnpm", ["pack", "--pack-destination", `"${tmpDir}"`], { cwd: pkgPath });
 
-  if (dryRun) {
-    args.push("--dry-run");
-    logger.info(`[DRY-RUN] [${pkgName}] pnpm ${args.join(" ")}`);
-  } else {
-    logger.debug(`[${pkgName}] pnpm ${args.join(" ")}`);
-  }
+    const tarball = (await fsx.readdir(tmpDir)).find((f) => f.endsWith(".tgz"));
+    if (tarball == null) {
+      throw new Error(`[${pkgName}] pack 결과 tarball 을 찾을 수 없습니다.`);
+    }
 
-  await shellSpawn("pnpm", args, { cwd: pkgPath });
+    const args = ["publish", `"${path.join(tmpDir, tarball)}"`, "--access", "public"];
+
+    const { name: npmName } = await fsx.readJson<{ name: string }>(
+      path.resolve(pkgPath, "package.json"),
+    );
+    const tag = await resolveDistTag(npmName, version, logger);
+    if (tag != null) {
+      args.push("--tag", tag);
+    }
+
+    // 명령줄에 들어가는 값과 마스킹 대상이 어긋나지 않도록 검증본 하나만 쓴다.
+    const otpCode = otp == null ? undefined : validateOtp(otp);
+    if (otpCode != null) {
+      args.push("--otp", otpCode);
+    }
+
+    if (dryRun) {
+      args.push("--dry-run");
+    }
+
+    // OTP 코드가 로그에 남지 않도록 마스킹한다.
+    const maskedArgs = args.map((arg, i) => (args[i - 1] === "--otp" ? OTP_MASK : arg));
+    if (dryRun) {
+      logger.info(`[DRY-RUN] [${pkgName}] npm ${maskedArgs.join(" ")}`);
+    } else {
+      logger.debug(`[${pkgName}] npm ${maskedArgs.join(" ")}`);
+    }
+
+    try {
+      // stdio 를 물려주므로 npm 출력이 화면에 그대로 나온다. 인증이 필요하면 npm 이 직접 안내한다.
+      await shellSpawn("npm", args, { cwd: pkgPath, stdio: "inherit" });
+    } catch (err) {
+      // stdio 를 넘겼으므로 실패 사유는 캡처되지 않고 화면에만 남는다. 어디를 봐야 하는지 알린다.
+      const hint = `\n실패 사유는 위 npm 출력을 확인하세요.`;
+      // 실패 메시지에는 실행된 명령줄이 그대로 담기므로 OTP 코드를 마스킹한다.
+      const mask = (s: string): string =>
+        otpCode == null ? s : s.replaceAll(otpCode, OTP_MASK);
+
+      const wrapped = new Error(mask(errNs.message(err)) + hint);
+      // 원본 스택을 잃지 않도록 마스킹한 스택을 그대로 옮긴다.
+      wrapped.stack = mask(errNs.stack(err));
+      throw wrapped;
+    }
+  } finally {
+    // 정리 실패가 원래 배포 실패를 덮지 않도록 삼킨다.
+    try {
+      await fsx.rm(tmpDir);
+    } catch (err) {
+      logger.debug(`[${pkgName}] 임시 디렉터리 정리 실패: ${errNs.message(err)}`);
+    }
+  }
 }

package/src/commands/publish/publish-command.ts

@@ -13,6 +13,7 @@ import { type PackageJson, upgradeVersion } from "./version-upgrade";
 import { waitWithCountdown } from "./env-utils";
 import { ensureCleanWorkingTree, commitTagAndPush } from "./git-phase";
 import { runDeployment } from "./deployment-phase";
+import { validateOtp } from "./npm-publisher";
 import { runPostPublish } from "./post-publish-phase";
 
 //#region Types
@@ -27,6 +28,8 @@ export interface PublishOptions {
   noBuild: boolean;
   /** 실제 배포 없이 시뮬레이션 */
   dryRun: boolean;
+  /** npm 2FA OTP 코드 (미지정 시 npm 이 배포 중 직접 인증을 처리한다) */
+  otp?: string;
   /** sd.config.ts에 전달할 추가 옵션 */
   options: string[];
 }
@@ -123,7 +126,9 @@ export async function runPublish(options: PublishOptions): Promise<void> {
   //#region Phase 1: Pre-validation
 
   // npm 인증 검증 (npm publish 설정이 있는 경우)
-  if (publishPackages.some((p) => p.config.type === "npm")) {
+  const hasNpmPublish = publishPackages.some((p) => p.config.type === "npm");
+
+  if (hasNpmPublish) {
     logger.debug("npm 인증 검증 중...");
     try {
       const { stdout: whoami } = await shellSpawn("npm", ["whoami"]);
@@ -143,6 +148,19 @@ export async function runPublish(options: PublishOptions): Promise<void> {
     }
   }
 
+  // --otp 값 형식 검증 (--dry-run 이라도 사전 점검 용도로 쓸 수 있게 항상 검증한다)
+  // 값을 주지 않으면 2FA 인증은 npm 이 배포 단계에서 직접 처리한다(브라우저 로그인 창 등).
+  let otpOption: string | undefined;
+  if (options.otp != null) {
+    try {
+      otpOption = validateOtp(options.otp);
+    } catch (err) {
+      logger.error(errNs.message(err));
+      process.exitCode = 1;
+      return;
+    }
+  }
+
   // SSH 키 인증 검증 (비밀번호 없는 SFTP publish 설정이 있는 경우)
   try {
     await ensureSshAuth(publishPackages, logger);
@@ -236,8 +254,25 @@ export async function runPublish(options: PublishOptions): Promise<void> {
 
   //#region Phase 4: Deployment
 
-  await runDeployment(publishPackages, version, cwd, logger, dryRun);
-  if (process.exitCode === 1) return;
+  // 배포 단계에서 멈추면 버전 상향과 git commit/tag/push 는 이미 끝난 상태다.
+  // 다시 `pnpm pub` 을 돌리면 버전이 또 올라가므로, 같은 버전으로 이어서 배포하는 방법을 알린다.
+  const reportResumeHint = (): void => {
+    if (dryRun || noBuild) return;
+    logger.error(
+      `v${version} 커밋, 태그는 이미 생성되었습니다. 같은 버전으로 이어서 배포하려면:\n` +
+        "  pnpm pub:no-build       # 버전 상향, 빌드 없이 배포만 재실행",
+    );
+  };
+
+  if (hasNpmPublish && !dryRun && otpOption == null) {
+    logger.info("npm 이 2FA 인증을 요구하면 화면 안내(브라우저 로그인 등)에 따라 진행하세요.");
+  }
+
+  await runDeployment(publishPackages, version, cwd, logger, dryRun, otpOption);
+  if (process.exitCode === 1) {
+    reportResumeHint();
+    return;
+  }
 
   //#endregion
 

package/src/sd-cli-entry.ts

@@ -245,6 +245,10 @@ export function createCliParser(argv: string[]): Argv {
               describe: "Simulate without actual deployment",
               default: false,
             },
+            "otp": {
+              type: "string",
+              describe: "npm 2FA one-time password (omit to let npm handle auth interactively)",
+            },
             "opt": {
               type: "string",
               array: true,
@@ -259,6 +263,7 @@ export function createCliParser(argv: string[]): Argv {
           targets: args.target,
           noBuild: !args.build,
           dryRun: args.dryRun,
+          otp: args.otp,
           options: args.opt,
         });
       },

package/tests/commands/deployment-phase.acc.spec.ts

@@ -8,6 +8,9 @@ const mocks = {
   fsx: {
     readJson: vi.spyOn(fsx, "readJson"),
     copy: vi.spyOn(fsx, "copy"),
+    mkdir: vi.spyOn(fsx, "mkdir"),
+    readdir: vi.spyOn(fsx, "readdir"),
+    rm: vi.spyOn(fsx, "rm"),
   },
   storageConnect: vi.spyOn(StorageFactory, "connect"),
 };
@@ -32,9 +35,30 @@ function createMockLogger() {
   } as unknown as ReturnType<typeof import("@simplysm/core-common").createLogger>;
 }
 
+/** npm 호출 중 실제 배포(publish)만 골라낸다. dist-tag 조회(`npm view`)와 구분하기 위함 */
+function isNpmPublish(cmd: string, args?: string[]): boolean {
+  return cmd === "npm" && args?.[0] === "publish";
+}
+
+/** 독립 패키지들이 한 레벨에 오도록 의존성 없는 package.json 을 돌려준다 */
+function mockIndependentPackages(): void {
+  mocks.fsx.readJson.mockImplementation(((p: string) => {
+    const name = path.basename(path.dirname(p));
+    return { name: `@simplysm/${name}`, version: "14.0.1", dependencies: {} };
+  }) as never);
+}
+
 describe("runDeployment", () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    process.exitCode = undefined;
+    // npm 배포는 pnpm pack 이 만든 tarball 을 npm publish 로 올린다
+    mocks.fsx.mkdir.mockResolvedValue(undefined);
+    mocks.fsx.rm.mockResolvedValue(undefined);
+    mocks.fsx.readdir.mockResolvedValue(["pkg-14.0.1.tgz"]);
+    // clearAllMocks 는 호출 기록만 지우므로, 구현이 테스트 간에 새지 않도록 매번 초기화한다
+    mocks.execa.mockImplementation((() => ({ stdout: "", stderr: "", exitCode: 0 })) as never);
+    mocks.storageConnect.mockResolvedValue(undefined);
   });
 
   it("deploys packages in dependency level order", async () => {
@@ -47,7 +71,11 @@ describe("runDeployment", () => {
     );
     mocks.fsx.readJson.mockImplementation(((p: string) => {
       if (p.includes("pkg-b")) {
-        return { name: "@simplysm/pkg-b", version: "14.0.1", dependencies: { "@simplysm/pkg-a": "~14.0.0" } };
+        return {
+          name: "@simplysm/pkg-b",
+          version: "14.0.1",
+          dependencies: { "@simplysm/pkg-a": "~14.0.0" },
+        };
       }
       return { name: "@simplysm/pkg-a", version: "14.0.1", dependencies: {} };
     }) as never);
@@ -62,6 +90,7 @@ describe("runDeployment", () => {
       CWD,
       logger,
       false,
+      undefined,
     );
 
     const aIdx = publishOrder.indexOf("pkg-a");
@@ -69,12 +98,77 @@ describe("runDeployment", () => {
     expect(aIdx).toBeLessThan(bIdx);
   });
 
-  it("retries failed publish up to 3 times then sets exitCode", async () => {
+  it("runs npm publishes one at a time so their auth prompts cannot collide", async () => {
+    mockIndependentPackages();
+
+    let active = 0;
+    let maxActive = 0;
+    mocks.execa.mockImplementation(((cmd: string, args?: string[]) => {
+      if (!isNpmPublish(cmd, args)) return { stdout: "", stderr: "", exitCode: 0 };
+      active++;
+      maxActive = Math.max(maxActive, active);
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          active--;
+          resolve({ stdout: "", stderr: "", exitCode: 0 });
+        }, 10);
+      });
+    }) as never);
+
+    const logger = createMockLogger();
+    await runDeployment(
+      [
+        { name: "pkg-a", path: pkgPath("pkg-a"), config: { type: "npm" } },
+        { name: "pkg-b", path: pkgPath("pkg-b"), config: { type: "npm" } },
+        { name: "pkg-c", path: pkgPath("pkg-c"), config: { type: "npm" } },
+      ],
+      "14.0.1",
+      CWD,
+      logger,
+      false,
+      undefined,
+    );
+
+    expect(maxActive).toBe(1);
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it("still runs non-npm publishes in parallel", async () => {
+    mockIndependentPackages();
+
+    let active = 0;
+    let maxActive = 0;
+    mocks.storageConnect.mockImplementation(async () => {
+      active++;
+      maxActive = Math.max(maxActive, active);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      active--;
+    });
+
+    const logger = createMockLogger();
+    await runDeployment(
+      [
+        { name: "pkg-a", path: pkgPath("pkg-a"), config: { type: "ftp", host: "h" } },
+        { name: "pkg-b", path: pkgPath("pkg-b"), config: { type: "ftp", host: "h" } },
+      ],
+      "14.0.1",
+      CWD,
+      logger,
+      false,
+      undefined,
+    );
+
+    expect(maxActive).toBe(2);
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it("does not retry a failed npm publish", async () => {
     let publishAttempts = 0;
-    mocks.execa.mockImplementation(() => {
+    mocks.execa.mockImplementation(((cmd: string, args?: string[]) => {
+      if (!isNpmPublish(cmd, args)) return { stdout: "", stderr: "", exitCode: 0 };
       publishAttempts++;
       throw new Error("publish failed");
-    });
+    }) as never);
     mocks.fsx.readJson.mockResolvedValue({
       name: "@simplysm/pkg-a",
       version: "14.0.1",
@@ -88,22 +182,43 @@ describe("runDeployment", () => {
       CWD,
       logger,
       false,
+      undefined,
+    );
+
+    // 재시도하면 npm 인증 UI 가 다시 뜨고, 인증·권한·버전 충돌은 재시도해도 같은 결과다
+    expect(publishAttempts).toBe(1);
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("still retries a failed storage publish up to 3 times", async () => {
+    mockIndependentPackages();
+    let attempts = 0;
+    mocks.storageConnect.mockImplementation(() => {
+      attempts++;
+      throw new Error("connection reset");
+    });
+
+    const logger = createMockLogger();
+    await runDeployment(
+      [{ name: "pkg-a", path: pkgPath("pkg-a"), config: { type: "ftp", host: "h" } }],
+      "14.0.1",
+      CWD,
+      logger,
+      false,
+      undefined,
     );
 
-    expect(publishAttempts).toBe(3);
+    expect(attempts).toBe(3);
     expect(process.exitCode).toBe(1);
   });
 
   it("reports partially deployed packages on failure", async () => {
-    mocks.fsx.readJson.mockImplementation(((p: string) => {
-      const name = path.basename(path.dirname(p));
-      return { name: `@simplysm/${name}`, version: "14.0.1", dependencies: {} };
-    }) as never);
+    mockIndependentPackages();
 
     // pkg-a succeeds, pkg-b fails
     mocks.execa.mockImplementation(
-      ((_cmd: string, _args?: string[], opts?: { cwd?: string }) => {
-        if (opts?.cwd?.includes("pkg-b")) {
+      ((cmd: string, args?: string[], opts?: { cwd?: string }) => {
+        if (isNpmPublish(cmd, args) && opts?.cwd?.includes("pkg-b")) {
           throw new Error("publish failed");
         }
         return { stdout: "", stderr: "", exitCode: 0 };
@@ -120,6 +235,7 @@ describe("runDeployment", () => {
       CWD,
       logger,
       false,
+      undefined,
     );
 
     expect(process.exitCode).toBe(1);
@@ -130,4 +246,25 @@ describe("runDeployment", () => {
     );
     expect(hasPartialMsg).toBe(true);
   });
+
+  it("passes the OTP through to npm publish", async () => {
+    mockIndependentPackages();
+    const npmArgs: string[][] = [];
+    mocks.execa.mockImplementation(((cmd: string, args?: string[]) => {
+      if (isNpmPublish(cmd, args)) npmArgs.push(args ?? []);
+      return { stdout: "", stderr: "", exitCode: 0 };
+    }) as never);
+
+    const logger = createMockLogger();
+    await runDeployment(
+      [{ name: "pkg-a", path: pkgPath("pkg-a"), config: { type: "npm" } }],
+      "14.0.1",
+      CWD,
+      logger,
+      false,
+      "123456",
+    );
+
+    expect(npmArgs[0][npmArgs[0].indexOf("--otp") + 1]).toBe("123456");
+  });
 });