@simplysm/sd-cli 14.0.30 → 14.0.33

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

@@ -0,0 +1,125 @@
+import path from "path";
+import type { consola } from "consola";
+import type { SdPublishConfig } from "../../sd-config.types";
+import { publishNpm } from "./npm-publisher";
+import { publishToStorage } from "./storage-publisher";
+import { publishToLocal } from "./local-publisher";
+import { computePublishLevels } from "./version-upgrade";
+import { replaceEnvVariables } from "./env-utils";
+
+export interface DeploymentPackage {
+  name: string;
+  path: string;
+  config: SdPublishConfig;
+}
+
+/**
+ * 개별 패키지 배포
+ */
+async function publishPackage(
+  pkgPath: string,
+  publishConfig: SdPublishConfig,
+  version: string,
+  projectPath: string,
+  logger: ReturnType<typeof consola.withTag>,
+  dryRun: boolean,
+): Promise<void> {
+  const pkgName = path.basename(pkgPath);
+
+  if (publishConfig.type === "npm") {
+    await publishNpm(pkgPath, pkgName, version, logger, dryRun);
+  } else if (publishConfig.type === "local-directory") {
+    const targetPath = replaceEnvVariables(publishConfig.path, version, projectPath);
+    await publishToLocal(pkgPath, pkgName, targetPath, logger, dryRun);
+  } else {
+    await publishToStorage(pkgPath, pkgName, publishConfig, logger, dryRun);
+  }
+}
+
+/**
+ * 의존성 레벨별 순차 배포 (레벨 내 병렬, 재시도 포함)
+ */
+export async function runDeployment(
+  publishPackages: DeploymentPackage[],
+  version: string,
+  projectPath: string,
+  logger: ReturnType<typeof consola.withTag>,
+  dryRun: boolean,
+): 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);
+          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} (retry ${attempt + 1}/${maxRetries})`
+                : `${pkg.name} (retry ${attempt + 1}/${maxRetries})`,
+            );
+            await new Promise((resolve) => setTimeout(resolve, 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(r.reason instanceof Error ? r.reason.message : r.reason);
+      }
+      logger.fail(`Level ${levelIdx + 1}/${levels.length}`);
+    } else {
+      logger.success(`Level ${levelIdx + 1}/${levels.length}`);
+    }
+  }
+
+  // 실패한 패키지 확인
+  const allPkgNames = publishPackages.map((p) => p.name);
+  const publishedSet = new Set(publishedPackages);
+  const failedPkgNames = allPkgNames.filter((n) => !publishedSet.has(n));
+
+  if (failedPkgNames.length > 0) {
+    if (publishedPackages.length > 0) {
+      logger.error(
+        "배포 중 에러 발생.\n" +
+          "이미 배포된 패키지:\n" +
+          publishedPackages.map((n) => `  - ${n}`).join("\n") +
+          "\n\n수동 복구가 필요할 수 있습니다.\n" +
+          "npm 패키지는 72시간 이내에 `npm unpublish <pkg>@<version>`으로 삭제할 수 있습니다.",
+      );
+    }
+
+    for (const name of failedPkgNames) {
+      logger.error(`[${name}] 배포 실패`);
+    }
+    process.exitCode = 1;
+  }
+}

package/src/commands/publish/env-utils.ts

@@ -0,0 +1,44 @@
+import { env } from "@simplysm/core-common";
+
+/**
+ * 환경변수 치환 (%VAR% 형식)
+ * @throws 치환되지 않은 환경변수가 남아있으면 에러를 던진다
+ */
+export function replaceEnvVariables(str: string, version: string, projectPath: string): string {
+  const result = str.replace(/%([^%]+)%/g, (match, envName: string) => {
+    if (envName === "VER") {
+      return version;
+    }
+    if (envName === "PROJECT") {
+      return projectPath;
+    }
+    return env(envName) ?? match;
+  });
+
+  // 치환되지 않은 환경변수가 남아있으면 에러 발생
+  if (/%[^%]+%/.test(result)) {
+    throw new Error(`환경변수 치환 실패: ${str} → ${result}`);
+  }
+
+  return result;
+}
+
+/**
+ * 카운트다운과 함께 대기
+ */
+export async function waitWithCountdown(message: string, seconds: number): Promise<void> {
+  for (let i = seconds; i > 0; i--) {
+    if (i !== seconds && process.stdout.isTTY) {
+      process.stdout.cursorTo(0);
+    }
+    process.stdout.write(`${message} ${i}`);
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+
+  if (process.stdout.isTTY) {
+    process.stdout.cursorTo(0);
+    process.stdout.clearLine(0);
+  } else {
+    process.stdout.write("\n");
+  }
+}

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

@@ -0,0 +1,99 @@
+import type { consola } from "consola";
+import { cpx } from "@simplysm/core-node";
+
+/**
+ * 미커밋 변경사항을 감지하고 Claude CLI로 자동 커밋을 시도한다.
+ * @throws 자동 커밋 실패 시 Error
+ */
+export async function ensureCleanWorkingTree(
+  hasGit: boolean,
+  logger: ReturnType<typeof consola.withTag>,
+): Promise<void> {
+  if (!hasGit) return;
+
+  logger.debug("git 커밋 상태 확인 중...");
+
+  const { stdout: diff } = await cpx.spawn("git", ["diff", "--name-only"]);
+  const { stdout: stagedDiff } = await cpx.spawn("git", ["diff", "--cached", "--name-only"]);
+
+  if (diff.trim() === "" && stagedDiff.trim() === "") return;
+
+  logger.info("커밋되지 않은 변경사항 감지. claude로 자동 커밋 시도 중...");
+  try {
+    await cpx.spawn(
+      "claude",
+      [
+        "-p",
+        "/sd-commit",
+        "--dangerously-skip-permissions",
+        "--model",
+        "haiku",
+        "--no-session-persistence",
+        "--strict-mcp-config",
+      ],
+      {
+        stdio: "inherit",
+        env: {
+          // eslint-disable-next-line no-restricted-properties -- 자식 프로세스에 env 전달
+          ...process.env,
+          MCP_CONNECTION_NONBLOCKING: "true",
+          CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+          DISABLE_TELEMETRY: "1",
+          CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: "1",
+          CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
+          CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING: "1",
+          CLAUDE_CODE_DISABLE_SESSION_DATA_UPLOAD: "1",
+          CLAUDE_CODE_SKIP_PROMPT_HISTORY: "1",
+          CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1",
+        },
+      },
+    );
+  } catch (e) {
+    throw new Error(
+      "자동 커밋에 실패했습니다. 수동으로 커밋 후 다시 시도해주세요.\n" +
+        (e instanceof Error ? e.message : String(e)),
+    );
+  }
+}
+
+/**
+ * 버전 변경 파일을 git add/commit/tag/push 한다.
+ * @throws git 작업 실패 시 복구 가이드 포함 Error
+ */
+export async function commitTagAndPush(
+  hasGit: boolean,
+  version: string,
+  changedFiles: string[],
+  logger: ReturnType<typeof consola.withTag>,
+  dryRun: boolean,
+): Promise<void> {
+  if (!hasGit) return;
+
+  if (dryRun) {
+    logger.info("[DRY-RUN] Git commit/tag/push 시뮬레이션 중...");
+    logger.info(`[DRY-RUN] git add (${changedFiles.length}개 파일)`);
+    logger.info(`[DRY-RUN] git commit -m "v${version}"`);
+    logger.info(`[DRY-RUN] git tag -a v${version} -m "v${version}"`);
+    logger.info("[DRY-RUN] 리모트에 push 예정 (건너뜀)");
+    logger.info("[DRY-RUN] 태그를 리모트에 push 예정 (건너뜀)");
+    logger.info("[DRY-RUN] Git 작업 시뮬레이션 완료");
+    return;
+  }
+
+  logger.debug("Git commit/tag/push...");
+  try {
+    await cpx.spawn("git", ["add", ...changedFiles]);
+    await cpx.spawn("git", ["commit", "-m", `v${version}`]);
+    await cpx.spawn("git", ["tag", "-a", `v${version}`, "-m", `v${version}`]);
+    await cpx.spawn("git", ["push"]);
+    await cpx.spawn("git", ["push", "--tags"]);
+    logger.debug("Git 작업 완료");
+  } catch (err) {
+    throw new Error(
+      `Git 작업 실패: ${err instanceof Error ? err.message : err}\n` +
+        "수동 복구가 필요할 수 있습니다:\n" +
+        `  git revert HEAD  # 버전 커밋 되돌리기\n` +
+        `  git tag -d v${version}  # 태그 삭제`,
+    );
+  }
+}

package/src/commands/publish/index.ts

@@ -0,0 +1,266 @@
+import path from "path";
+import { consola } from "consola";
+import { cpx, fsx } from "@simplysm/core-node";
+import "@simplysm/core-common";
+import type { SdConfig, SdPublishConfig } from "../../sd-config.types";
+import { loadSdConfig } from "../../utils/sd-config";
+import { validateTargets } from "../../utils/package-utils";
+import { runBuild } from "../build";
+import { parseWorkspaceGlobs } from "../../deps/replace-deps/replace-deps-resolve";
+import fs from "fs";
+import { ensureSshAuth } from "./storage-publisher";
+import { type PackageJson, upgradeVersion } from "./version-upgrade";
+import { waitWithCountdown } from "./env-utils";
+import { ensureCleanWorkingTree, commitTagAndPush } from "./git-phase";
+import { runDeployment } from "./deployment-phase";
+import { runPostPublish } from "./post-publish-phase";
+
+//#region Types
+
+/**
+ * 배포 명령어 옵션
+ */
+export interface PublishOptions {
+  /** 배포 대상 패키지 필터 (빈 배열이면 publish 설정이 있는 모든 패키지 배포) */
+  targets: string[];
+  /** 빌드 없이 배포 (위험) */
+  noBuild: boolean;
+  /** 실제 배포 없이 시뮬레이션 */
+  dryRun: boolean;
+  /** sd.config.ts에 전달할 추가 옵션 */
+  options: string[];
+}
+
+//#endregion
+
+//#region Main
+
+/**
+ * 배포 명령어를 실행한다.
+ *
+ * **배포 순서 (안전 우선):**
+ * 1. 사전 검증 (npm 인증, Git 상태)
+ * 2. 버전 업그레이드 (package.json + 템플릿)
+ * 3. 빌드
+ * 4. Git commit/tag/push (변경된 파일만 명시적으로 스테이징)
+ * 5. 패키지 배포 (npm/로컬 디렉토리/스토리지)
+ * 6. postPublish (실패해도 계속 진행)
+ */
+export async function runPublish(options: PublishOptions): Promise<void> {
+  const { targets, noBuild, dryRun } = options;
+  const cwd = process.cwd();
+  const logger = consola.withTag("sd:cli:publish");
+
+  if (dryRun) {
+    logger.info("[DRY-RUN] 시뮬레이션 모드 - 실제 배포 없음");
+  }
+
+  logger.debug("배포 시작", { targets, noBuild, dryRun });
+
+  // sd.config.ts 로드
+  let sdConfig: SdConfig;
+  try {
+    sdConfig = await loadSdConfig({ cwd, dev: false, opt: options.options });
+    logger.debug("sd.config.ts 로드 완료");
+  } catch (err) {
+    logger.error(`sd.config.ts 로드 실패: ${err instanceof Error ? err.message : err}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // 대상 유효성 검사
+  validateTargets(targets, sdConfig.packages);
+
+  // package.json 로드
+  const projPkgPath = path.resolve(cwd, "package.json");
+  const projPkg = await fsx.readJson<PackageJson>(projPkgPath);
+
+  // pnpm-workspace.yaml에서 워크스페이스 패키지 경로 수집
+  const workspaceYamlPath = path.resolve(cwd, "pnpm-workspace.yaml");
+  const workspaceGlobs: string[] = [];
+  if (await fsx.exists(workspaceYamlPath)) {
+    const yamlContent = await fsx.read(workspaceYamlPath);
+    workspaceGlobs.push(...parseWorkspaceGlobs(yamlContent));
+  }
+
+  const allPkgPaths = (
+    await Promise.all(workspaceGlobs.map((item) => fsx.glob(path.resolve(cwd, item))))
+  )
+    .flat()
+    .filter((item) => fs.existsSync(path.join(item, "package.json")));
+
+  // publish 설정이 있는 패키지 필터링
+  const publishPackages: Array<{
+    name: string;
+    path: string;
+    config: SdPublishConfig;
+  }> = [];
+
+  for (const [name, config] of Object.entries(sdConfig.packages)) {
+    if (config == null) continue;
+    const pkgConfig = config;
+    if (pkgConfig.publish == null) continue;
+
+    // targets가 지정되면 해당 패키지만 포함
+    if (targets.length > 0 && !targets.includes(name)) continue;
+
+    const pkgPath = allPkgPaths.find((p) => path.basename(p) === name);
+    if (pkgPath == null) {
+      logger.warn(`패키지를 찾을 수 없음: ${name}`);
+      continue;
+    }
+
+    publishPackages.push({
+      name,
+      path: pkgPath,
+      config: pkgConfig.publish,
+    });
+  }
+
+  if (publishPackages.length === 0) {
+    process.stdout.write("✔ 배포할 패키지가 없습니다.\n");
+    return;
+  }
+
+  logger.debug(
+    "배포 대상 패키지",
+    publishPackages.map((p) => p.name),
+  );
+
+  // Git 사용 가능 여부 확인
+  const hasGit = await fsx.exists(path.resolve(cwd, ".git"));
+
+  //#region Phase 1: Pre-validation
+
+  // npm 인증 검증 (npm publish 설정이 있는 경우)
+  if (publishPackages.some((p) => p.config.type === "npm")) {
+    logger.debug("npm 인증 검증 중...");
+    try {
+      const { stdout: whoami } = await cpx.spawn("npm", ["whoami"]);
+      if (whoami.trim() === "") {
+        throw new Error("npm 로그인 정보를 찾을 수 없습니다.");
+      }
+      logger.debug(`npm 로그인 확인됨: ${whoami.trim()}`);
+    } catch {
+      logger.error(
+        "npm 인증 실패. 로그인 상태를 확인해주세요.\n" +
+          "  npm whoami              # 현재 로그인 확인\n" +
+          "  npm login               # 로그인\n" +
+          "  npm config set //registry.npmjs.org/:_authToken <token>  # 토큰 직접 설정",
+      );
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  // SSH 키 인증 검증 (비밀번호 없는 SFTP publish 설정이 있는 경우)
+  try {
+    await ensureSshAuth(publishPackages, logger);
+  } catch (err) {
+    logger.error(`SSH 인증 설정 실패: ${err instanceof Error ? err.message : err}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // 커밋되지 않은 변경사항 확인 및 자동 커밋 시도 (noBuild가 아닌 경우)
+  if (!noBuild) {
+    try {
+      await ensureCleanWorkingTree(hasGit, logger);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : err);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  //#endregion
+
+  //#region Phase 2 & 3: Build or noBuild warning
+
+  let version = projPkg.version;
+
+  if (noBuild) {
+    // noBuild 경고
+    logger.warn("빌드 없이 배포하는 것은 매우 위험합니다.");
+    await waitWithCountdown("중단하려면 'CTRL+C'를 누르세요.", 5);
+  } else {
+    // 버전 업그레이드
+    logger.debug("버전 업그레이드 중...");
+    const upgradeResult = await upgradeVersion(cwd, allPkgPaths, dryRun);
+    version = upgradeResult.version;
+    const _changedFiles = upgradeResult.changedFiles;
+    if (dryRun) {
+      logger.info(`[DRY-RUN] 버전 업그레이드: ${projPkg.version} → ${version} (파일 미수정)`);
+    } else {
+      logger.info(`버전 업그레이드: ${projPkg.version} → ${version}`);
+    }
+
+    // 빌드 실행
+    if (dryRun) {
+      logger.info("[DRY-RUN] 빌드 시작 (검증만)...");
+    } else {
+      logger.debug("빌드 시작...");
+    }
+
+    try {
+      await runBuild({
+        targets: publishPackages.map((p) => p.name),
+        options: options.options,
+      });
+
+      // 빌드 실패 확인
+      if (process.exitCode === 1) {
+        throw new Error("빌드 실패");
+      }
+    } catch {
+      if (dryRun) {
+        logger.error("[DRY-RUN] 빌드 실패");
+      } else {
+        logger.error(
+          "빌드 실패. 수동 복구가 필요할 수 있습니다:\n" +
+            "  버전 변경을 되돌리려면:\n" +
+            "    git checkout -- package.json packages/*/package.json packages/sd-cli/templates/",
+        );
+      }
+      process.exitCode = 1;
+      return;
+    }
+
+    //#region Phase 3: Git commit/tag/push
+
+    try {
+      await commitTagAndPush(hasGit, version, _changedFiles, logger, dryRun);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : err);
+      process.exitCode = 1;
+      return;
+    }
+
+    //#endregion
+  }
+
+  //#endregion
+
+  //#region Phase 4: Deployment
+
+  await runDeployment(publishPackages, version, cwd, logger, dryRun);
+  if (process.exitCode === 1) return;
+
+  //#endregion
+
+  //#region Phase 5: postPublish
+
+  if (sdConfig.postPublish != null && sdConfig.postPublish.length > 0) {
+    await runPostPublish(sdConfig.postPublish, version, cwd, logger, dryRun);
+  }
+
+  //#endregion
+
+  if (dryRun) {
+    logger.info(`[DRY-RUN] 시뮬레이션 완료. 실제 배포 버전: v${version}`);
+  } else {
+    logger.info(`모든 배포 완료. (v${version})`);
+  }
+}
+
+//#endregion

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

@@ -0,0 +1,23 @@
+import path from "path";
+import type { consola } from "consola";
+import { fsx } from "@simplysm/core-node";
+
+/**
+ * 로컬 디렉토리에 dist를 복사한다
+ */
+export async function publishToLocal(
+  pkgPath: string,
+  pkgName: string,
+  targetPath: string,
+  logger: ReturnType<typeof consola.withTag>,
+  dryRun: boolean,
+): Promise<void> {
+  const distPath = path.resolve(pkgPath, "dist");
+
+  if (dryRun) {
+    logger.info(`[DRY-RUN] [${pkgName}] 로컬 복사: ${distPath} → ${targetPath}`);
+  } else {
+    logger.debug(`[${pkgName}] 로컬 복사: ${distPath} → ${targetPath}`);
+    await fsx.copy(distPath, targetPath);
+  }
+}

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

@@ -0,0 +1,30 @@
+import semver from "semver";
+import type { consola } from "consola";
+import { cpx } from "@simplysm/core-node";
+
+/**
+ * npm 레지스트리에 패키지를 배포한다
+ */
+export async function publishNpm(
+  pkgPath: string,
+  pkgName: string,
+  version: string,
+  logger: ReturnType<typeof consola.withTag>,
+  dryRun: boolean,
+): Promise<void> {
+  const prereleaseInfo = semver.prerelease(version);
+  const args = ["publish", "--access", "public", "--no-git-checks"];
+
+  if (prereleaseInfo !== null && typeof prereleaseInfo[0] === "string") {
+    args.push("--tag", prereleaseInfo[0]);
+  }
+
+  if (dryRun) {
+    args.push("--dry-run");
+    logger.info(`[DRY-RUN] [${pkgName}] pnpm ${args.join(" ")}`);
+  } else {
+    logger.debug(`[${pkgName}] pnpm ${args.join(" ")}`);
+  }
+
+  await cpx.spawn("pnpm", args, { cwd: pkgPath });
+}

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

@@ -0,0 +1,43 @@
+import type { consola } from "consola";
+import type { SdPostPublishScriptConfig } from "../../sd-config.types";
+import { cpx } from "@simplysm/core-node";
+import { replaceEnvVariables } from "./env-utils";
+
+/**
+ * postPublish 스크립트를 순차 실행한다.
+ * 개별 스크립트 실패 시 경고만 출력하고 계속 진행한다.
+ */
+export async function runPostPublish(
+  scripts: SdPostPublishScriptConfig[],
+  version: string,
+  projectPath: string,
+  logger: ReturnType<typeof consola.withTag>,
+  dryRun: boolean,
+): Promise<void> {
+  if (scripts.length === 0) return;
+
+  if (dryRun) {
+    logger.info("[DRY-RUN] postPublish 스크립트 시뮬레이션 중...");
+  } else {
+    logger.debug("postPublish 스크립트 실행 중...");
+  }
+
+  for (const script of scripts) {
+    try {
+      const cmd = replaceEnvVariables(script.cmd, version, projectPath);
+      const args = script.args.map((arg) => replaceEnvVariables(arg, version, projectPath));
+
+      if (dryRun) {
+        logger.info(`[DRY-RUN] 실행 예정: ${cmd} ${args.join(" ")}`);
+      } else {
+        logger.debug(`실행 중: ${cmd} ${args.join(" ")}`);
+        await cpx.spawn(cmd, args, { cwd: projectPath });
+      }
+    } catch (err) {
+      // postPublish 실패 시 경고만 출력 (배포 롤백 불가)
+      logger.warn(
+        `postPublish 스크립트 실패 (계속 진행): ${err instanceof Error ? err.message : err}`,
+      );
+    }
+  }
+}