@simplysm/sd-cli 14.1.9 → 14.1.11

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

@@ -6,9 +6,8 @@ import type { SdConfig, SdPublishConfig } from "../../sd-config.types";
 import { loadSdConfig } from "../../utils/sd-config";
 import { validateTargets } from "../../utils/package-utils";
 import { shellSpawn } from "../../utils/shell-spawn";
+import { collectWorkspacePackages } from "../../utils/workspace-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";
@@ -65,6 +64,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
     logger.debug("sd.config.ts 로드 완료");
   } catch (err) {
     logger.error(`sd.config.ts 로드 실패: ${errNs.message(err)}`);
+    logger.debug(`sd.config.ts 로드 실패 스택:\n${errNs.stack(err)}`);
     process.exitCode = 1;
     return;
   }
@@ -76,19 +76,8 @@ export async function runPublish(options: PublishOptions): Promise<void> {
   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")));
+  // package.json#workspaces에서 워크스페이스 패키지 경로 수집
+  const allPkgPaths = collectWorkspacePackages(cwd).map((item) => item.absPath);
 
   // publish 설정이 있는 패키지 필터링
   const publishPackages: Array<{
@@ -159,6 +148,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
     await ensureSshAuth(publishPackages, logger);
   } catch (err) {
     logger.error(`SSH 인증 설정 실패: ${errNs.message(err)}`);
+    logger.debug(`SSH 인증 설정 실패 스택:\n${errNs.stack(err)}`);
     process.exitCode = 1;
     return;
   }
@@ -169,6 +159,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
       await ensureCleanWorkingTree(hasGit, logger);
     } catch (err) {
       logger.error(errNs.message(err));
+      logger.debug(`작업 트리 확인 실패 스택:\n${errNs.stack(err)}`);
       process.exitCode = 1;
       return;
     }
@@ -233,6 +224,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
       await commitTagAndPush(hasGit, version, _changedFiles, logger, dryRun);
     } catch (err) {
       logger.error(errNs.message(err));
+      logger.debug(`Git 배포 단계 실패 스택:\n${errNs.stack(err)}`);
       process.exitCode = 1;
       return;
     }

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

@@ -15,6 +15,46 @@ export interface PackageJson {
   optionalDependencies?: Record<string, string>;
 }
 
+/**
+ * bun.lock의 workspaces 섹션에 스냅샷된 각 워크스페이스 패키지 version을 새 버전으로 맞춘다.
+ *
+ * bun publish/pack은 `workspace:*` 의존성을 치환할 때 대상 패키지의 package.json이 아니라
+ * bun.lock의 `workspaces.<dir>.version`을 읽는다 (bun 1.2.8+, oven-sh/bun#20477). 또한 version만
+ * bump하면 `bun install`이 lock의 워크스페이스 version을 갱신하지 않으므로 (oven-sh/bun#18906),
+ * package.json만 올리면 lock이 뒤처져 이전 버전으로 치환된다. 이를 막기 위해 lock을 직접 맞춘다.
+ *
+ * `"version"` 키는 workspaces 섹션에만 나타나므로(packages 섹션의 의존성은 `"name@ver"` 배열 형태),
+ * workspaces 객체 범위 안의 `"version"` 값만 새 버전으로 치환한다. 값이 아닌 위치 기준이라
+ * lock이 몇 버전 뒤처져 있든 정확히 맞춰진다.
+ */
+function syncBunLockWorkspaceVersions(content: string, newVersion: string): string {
+  const wsKeyIdx = content.indexOf('"workspaces":');
+  if (wsKeyIdx === -1) return content;
+
+  const braceStart = content.indexOf("{", wsKeyIdx);
+  if (braceStart === -1) return content;
+
+  // balanced brace로 workspaces 객체의 끝을 찾는다 (값 문자열에 중괄호가 없어 안전).
+  let depth = 0;
+  let braceEnd = -1;
+  for (let i = braceStart; i < content.length; i++) {
+    const ch = content[i];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        braceEnd = i;
+        break;
+      }
+    }
+  }
+  if (braceEnd === -1) return content;
+
+  const section = content.slice(braceStart, braceEnd + 1);
+  const newSection = section.replace(/("version"\s*:\s*)"[^"]*"/g, `$1"${newVersion}"`);
+  return content.slice(0, braceStart) + newSection + content.slice(braceEnd + 1);
+}
+
 /**
  * 프로젝트 및 패키지 버전 업그레이드
  * @param dryRun true이면 파일을 수정하지 않고 새 버전만 계산
@@ -58,6 +98,17 @@ export async function upgradeVersion(
   );
   changedFiles.push(...pkgChangedFiles);
 
+  // bun.lock의 워크스페이스 version 동기화 (bun publish가 lock을 읽어 workspace:* 를 치환하므로)
+  const bunLockPath = path.resolve(cwd, "bun.lock");
+  if (await fsx.exists(bunLockPath)) {
+    const lockContent = await fsx.read(bunLockPath);
+    const newLockContent = syncBunLockWorkspaceVersions(lockContent, newVersion);
+    if (newLockContent !== lockContent) {
+      await fsx.write(bunLockPath, newLockContent);
+      changedFiles.push(bunLockPath);
+    }
+  }
+
   // 템플릿 파일의 @simplysm 패키지 버전 동기화
   const templateFiles = await fsx.glob(path.resolve(cwd, "packages/sd-cli/templates/**/*.hbs"));
   const versionRegex = /("@simplysm\/[^"]+"\s*:\s*)"~[^"]+"/g;

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

@@ -11,15 +11,15 @@ export interface DepsResult {
 }
 
 /**
- * 워크스페이스 디렉토리(packages/, tests/) 스캔 기반으로 packages/ 패키지의 name → 상대 디렉토리 맵을 구성한다.
- * tests/ 패키지는 제외된다.
+ * package.json#workspaces 기반으로 packages/(배포 대상) 패키지의 name → 상대 디렉토리 맵을 구성한다.
+ * packages/ 가 아닌 워크스페이스(tests/·plugins/ 등)는 제외된다.
  * 예: "@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) {
-    if (relDir.startsWith("tests/")) continue;
+    if (!relDir.startsWith("packages/")) continue;
     const pkgJsonPath = pathx.posix(path.join(cwd, relDir, "package.json"));
     if (!fsx.existsSync(pkgJsonPath)) continue;
     const pkgJson = fsx.readJsonSync<{ name: string }>(pkgJsonPath);
@@ -36,7 +36,7 @@ export function collectDeps(
   const startTime = performance.now();
   logger.debug("의존성 수집 시작");
 
-  // 워크스페이스 디렉토리 스캔으로 packages/ 패키지 맵 구성 (tests/ 제외)
+  // 워크스페이스 설정으로 packages/ 패키지 맵 구성 (tests/ 제외)
   const workspacePkgMap = buildWorkspacePkgMap(cwd);
 
   const replaceDepsPatterns: Array<{ regex: RegExp }> = [];

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

@@ -3,6 +3,7 @@ import path from "path";
 import { glob } from "glob";
 import type { ConsolaInstance } from "consola";
 import { fsx, pathx } from "@simplysm/core-node";
+import { collectWorkspacePackages } from "../../utils/workspace-utils";
 
 /**
  * replaceDeps 설정의 glob 패턴을 대상 패키지 목록과 매칭하여
@@ -44,45 +45,6 @@ export function resolveReplaceDepEntries(
   return results;
 }
 
-/**
- * pnpm-workspace.yaml 내용을 파싱하여 워크스페이스 패키지 glob 배열을 반환한다.
- * 별도 YAML 라이브러리 없이 간단한 줄 파싱으로 처리한다.
- *
- * @param content - pnpm-workspace.yaml 파일 내용
- * @returns glob 패턴 배열 (예: ["packages/*", "tools/*"])
- */
-export function parseWorkspaceGlobs(content: string): string[] {
-  const lines = content.split("\n");
-  const globs: string[] = [];
-  let inPackages = false;
-
-  for (const line of lines) {
-    const trimmed = line.trim();
-
-    if (trimmed === "packages:") {
-      inPackages = true;
-      continue;
-    }
-
-    // packages 섹션의 목록 항목
-    if (inPackages && trimmed.startsWith("- ")) {
-      const value = trimmed
-        .slice(2)
-        .trim()
-        .replace(/^["']|["']$/g, "");
-      globs.push(value);
-      continue;
-    }
-
-    // 다른 섹션이 시작되면 종료
-    if (inPackages && trimmed !== "" && !trimmed.startsWith("#")) {
-      break;
-    }
-  }
-
-  return globs;
-}
-
 /**
  * replaceDeps 복사/교체 항목
  */
@@ -97,26 +59,21 @@ export interface ReplaceDepEntry {
 /**
  * 프로젝트 루트 및 워크스페이스 패키지 경로를 수집한다.
  *
- * pnpm-workspace.yaml을 파싱하여 워크스페이스 패키지의 절대 경로를 수집한다.
- * 파일이 없거나 파싱 실패 시 루트 경로만 반환한다.
+ * package.json#workspaces를 기준으로 워크스페이스 패키지의 절대 경로를 수집한다.
+ * 설정이 없거나 파싱 실패 시 루트 경로만 반환한다.
  *
  * @param projectRoot - 프로젝트 루트 경로
  * @returns [루트, ...워크스페이스 패키지 경로] 배열
  */
-export async function collectSearchRoots(projectRoot: string): Promise<string[]> {
-  const searchRoots = [projectRoot];
+export function collectSearchRoots(projectRoot: string): string[] {
+  const root = pathx.posix(projectRoot);
+  const searchRoots: string[] = [root];
 
-  const workspaceYamlPath = pathx.posix(path.join(projectRoot, "pnpm-workspace.yaml"));
   try {
-    const yamlContent = await fsx.read(workspaceYamlPath);
-    const workspaceGlobs = parseWorkspaceGlobs(yamlContent);
-
-    for (const pattern of workspaceGlobs) {
-      const dirs = await fsx.glob(pattern, { cwd: projectRoot });
-      searchRoots.push(...dirs);
-    }
+    const workspacePackages = collectWorkspacePackages(root);
+    searchRoots.push(...workspacePackages.map((item) => item.absPath));
   } catch {
-    // pnpm-workspace.yaml이 존재하지 않으면 루트만 처리
+    // workspace 설정이 없거나 파싱할 수 없으면 루트만 처리
   }
 
   return searchRoots;
@@ -125,7 +82,7 @@ export async function collectSearchRoots(projectRoot: string): Promise<string[]>
 /**
  * replaceDeps 설정에서 모든 교체 대상 항목을 해결한다.
  *
- * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
+ * 1. package.json#workspaces 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
  * 3. 패턴 매칭 + 소스 경로 존재 확인 + symlink 해결
  *
@@ -144,7 +101,7 @@ export async function resolveAllReplaceDepEntries(
   const searchedDirs = new Set<string>();
 
   // 초기 탐색 대상: 프로젝트 루트 + workspace 패키지들의 node_modules
-  const searchRoots = await collectSearchRoots(projectRoot);
+  const searchRoots = collectSearchRoots(projectRoot);
   const pendingDirs: string[] = searchRoots.map((root) =>
     pathx.posix(path.join(root, "node_modules")),
   );
@@ -188,7 +145,7 @@ export async function resolveAllReplaceDepEntries(
         continue;
       }
 
-      // targetPath가 symlink이면 실제 .pnpm 저장소 경로로 해결
+      // targetPath가 symlink이면 실제 패키지 저장소 경로로 해결
       let actualTargetPath = targetPath;
       try {
         const stat = await fs.promises.lstat(targetPath);
@@ -199,7 +156,7 @@ export async function resolveAllReplaceDepEntries(
         // targetPath가 존재하지 않으면 그대로 사용
       }
 
-      // 동일 actualTargetPath가 이미 등록된 경우 건너뜀 (pnpm 중복 방지)
+      // 동일 actualTargetPath가 이미 등록된 경우 건너뜀
       if (seenTargetPaths.has(actualTargetPath)) continue;
       seenTargetPaths.add(actualTargetPath);
 

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

@@ -32,7 +32,7 @@ async function isFileContentSame(pathA: string, pathB: string): Promise<boolean>
 }
 
 /**
- * pnpm hard link를 끊으면서 파일/디렉토리를 복사한다.
+ * package manager hard link를 끊으면서 파일/디렉토리를 복사한다.
  * 대상 파일을 먼저 unlink하여 글로벌 store의 hard link를 끊고 새 파일을 생성한다.
  * 다른 프로젝트의 node_modules에 영향을 주지 않기 위함이다.
  */
@@ -160,7 +160,7 @@ export interface WatchReplaceDepResult {
 /**
  * replaceDeps 설정에 따라 node_modules의 패키지를 소스 디렉토리로 교체한다.
  *
- * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
+ * 1. package.json#workspaces 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
  * 3. 소스 package.json의 files 필드 + npm 기본 파일만 대상 경로에 복사 (package.json 제외)
  *
@@ -207,7 +207,7 @@ export async function setupReplaceDeps(
 /**
  * replaceDeps 설정에 따라 소스 디렉토리를 감시하고 변경사항을 대상 경로에 복사한다.
  *
- * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
+ * 1. package.json#workspaces 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
  * 3. FsWatcher로 files 항목 경로만 감시 (300ms 딜레이)
  * 4. 변경사항을 대상 경로에 복사

package/src/deps/server-externals/server-production-files.ts

@@ -29,30 +29,43 @@ export function collectAllExternals(
   };
 }
 
+interface BunLockFile {
+  packages?: Record<string, unknown>;
+}
+
+function parsePackageReferenceVersion(reference: string): string | undefined {
+  const normalized = reference.split("(")[0];
+  const match = /^(.+?)@(\d[^@]*)$/.exec(normalized);
+  return match?.[2];
+}
+
+function parsePackageKeyName(key: string): string {
+  const match = /^(.+?)@(\d.+)$/.exec(key);
+  return match?.[1] ?? key;
+}
+
 /**
- * pnpm-lock.yaml의 packages 섹션을 파싱하여 name→version 맵을 생성한다.
- * 키 형태: "name@version" · "@scope/name@version" · "name@version(peer@ver)..."
+ * bun.lock의 packages 섹션을 파싱하여 name→version 맵을 생성한다.
+ * 키 형태는 일반 패키지명 또는 alias이고, 실제 버전은 package entry의 resolution에서 확인한다.
  */
 export function parseLockfileVersions(cwd: string): Map<string, string> {
-  const lockfilePath = path.join(cwd, "pnpm-lock.yaml");
+  const lockfilePath = path.join(cwd, "bun.lock");
   if (!fsx.existsSync(lockfilePath)) {
-    throw new Error(`pnpm-lock.yaml not found in ${cwd}. Run "pnpm install" first.`);
+    throw new Error(`bun.lock not found in ${cwd}. Run "bun install" first.`);
   }
 
   const content = fsx.readSync(lockfilePath);
-  const parsed = YAML.parse(content) as { packages?: Record<string, unknown> };
+  const parsed = YAML.parse(content) as BunLockFile;
   const map = new Map<string, string>();
 
-  for (const key of Object.keys(parsed.packages ?? {})) {
-    // 첫 번째 @숫자 기준으로 name / version 분리 (scope 패키지의 선두 @ 보존)
-    const m = /^(.+?)@(\d.+)$/.exec(key);
-    if (m == null) continue;
-    const name = m[1];
-    // peerDep suffix "(peer@ver)..." 제거
-    const parenIdx = m[2].indexOf("(");
-    const version = parenIdx === -1 ? m[2] : m[2].substring(0, parenIdx);
-    if (!map.has(name)) {
-      map.set(name, version);
+  for (const [key, entry] of Object.entries(parsed.packages ?? {})) {
+    if (!Array.isArray(entry) || typeof entry[0] !== "string") continue;
+    const version = parsePackageReferenceVersion(entry[0]);
+    if (version == null) continue;
+
+    const keyName = parsePackageKeyName(key);
+    if (!map.has(keyName)) {
+      map.set(keyName, version);
     }
   }
 
@@ -60,7 +73,7 @@ export function parseLockfileVersions(cwd: string): Map<string, string> {
 }
 
 /**
- * pnpm-lock.yaml에서 주어진 모든 패키지의 잠긴 버전을 확인한다.
+ * bun.lock에서 주어진 모든 패키지의 잠긴 버전을 확인한다.
  * lockfile에서 패키지를 찾을 수 없으면 에러를 던진다.
  */
 export function resolveLockedVersions(cwd: string, pkgNames: string[]): Record<string, string> {
@@ -70,8 +83,8 @@ export function resolveLockedVersions(cwd: string, pkgNames: string[]): Record<s
     const version = versionMap.get(name);
     if (version == null) {
       throw new Error(
-        `External dependency "${name}" not found in pnpm-lock.yaml. ` +
-          `Run "pnpm install" and try again.`,
+        `External dependency "${name}" not found in bun.lock. ` +
+          `Run "bun install" and try again.`,
       );
     }
     result[name] = version;

package/src/electron/electron.ts

@@ -68,20 +68,14 @@ export class Electron {
     await this._setupNpmConf();
     Electron._logger.debug("package.json 설정 완료");
 
-    // pnpm-workspace.yaml 생성 (상위 workspace 탐색 차단)
-    const workspaceYamlPath = pathx.posixResolve(this._srcPath, "pnpm-workspace.yaml");
-    if (!(await fsx.exists(workspaceYamlPath))) {
-      await fsx.write(workspaceYamlPath, "");
-    }
-
-    Electron._logger.debug("pnpm install 시작");
-    await this._exec("pnpm", ["install", "--config.dangerously-allow-all-builds=true"], this._srcPath);
-    Electron._logger.debug("pnpm install 완료");
+    Electron._logger.debug("bun install 시작");
+    await this._exec("bun", ["install"], this._srcPath);
+    Electron._logger.debug("bun install 완료");
 
     const reinstallDeps = this._config.reinstallDependencies ?? [];
     if (reinstallDeps.length > 0) {
       Electron._logger.debug(`electron-rebuild 시작 (${reinstallDeps.join(", ")})`);
-      await this._exec("pnpm", ["exec", "electron-rebuild"], this._srcPath);
+      await this._exec("bun", ["run", "electron-rebuild"], this._srcPath);
       Electron._logger.debug("electron-rebuild 완료");
     }
     Electron._logger.success("initialize 완료");
@@ -102,7 +96,7 @@ export class Electron {
 
     const spawnElectron = () => {
       Electron._logger.debug("Electron 프로세스 시작");
-      currentElectron = shellSpawn("pnpm", ["exec", "electron", "."], {
+      currentElectron = shellSpawn("bun", ["run", "electron", "."], {
         cwd: this._srcPath,
         stdio: "inherit",
         reject: false,
@@ -385,8 +379,8 @@ export class Electron {
 
     Electron._logger.debug(`electron-builder 설정: ${configFilePath}`);
     await this._exec(
-      "pnpm",
-      ["exec", "electron-builder", "--win", "--config", configFilePath],
+      "bun",
+      ["run", "electron-builder", "--win", "--config", configFilePath],
       this._srcPath,
     );
   }

package/src/engines/BaseEngine.ts

@@ -21,7 +21,7 @@ export interface CommonBuildWorkerEvents extends Record<string, unknown> {
     build: { success: boolean; errors?: string[]; warnings?: string[] };
     lint?: LintWithProgramResult;
   };
-  error: { message: string };
+  error: { message: string; stack?: string };
 }
 
 /**
@@ -180,7 +180,8 @@ export abstract class BaseEngine<
     });
 
     this._callStartWatch(output).catch((err: unknown) => {
-      logger.debug(`[${this._pkg.name}] startWatch 실패:`, errNs.message(err));
+      logger.debug(`[${this._pkg.name}] startWatch 실패: ${errNs.message(err)}`);
+      logger.debug(`[${this._pkg.name}] startWatch 실패 스택:\n${errNs.stack(err)}`);
       this._resultCollector?.add({
         name: this._pkg.name,
         target: this._getTarget(),

package/src/esbuild/esbuild-config.ts

@@ -7,18 +7,27 @@ import { addJsExtensionToImports } from "../utils/output-path-rewriter";
 
 const logger = createLogger("sd:cli:esbuild-config");
 
+export interface WriteChangedOutputFilesOptions {
+  /** .js 파일의 확장자 없는 상대 import/export 경로에 .js를 붙일지 여부 */
+  rewriteJsExtensions?: boolean;
+}
+
 /**
  * esbuild outputFiles에서 변경된 파일만 디스크에 쓴다.
  *
- * - .js 파일: 비교 전 ESM 상대 import 경로에 .js 확장자를 추가한다
+ * - .js 파일: 기본적으로 비교 전 ESM 상대 import 경로에 .js 확장자를 추가한다
  * - 기타 파일(.js.map 등): 원본 내용을 그대로 비교한다
  * - 기존 파일과 내용이 동일하면 타임스탬프 보존을 위해 쓰기를 스킵한다
  */
-export async function writeChangedOutputFiles(outputFiles: esbuild.OutputFile[]): Promise<void> {
+export async function writeChangedOutputFiles(
+  outputFiles: esbuild.OutputFile[],
+  options?: WriteChangedOutputFilesOptions,
+): Promise<void> {
+  const rewriteJsExtensions = options?.rewriteJsExtensions ?? true;
   logger.debug(`변경된 출력 파일 쓰기 시작 (${outputFiles.length}개)`);
   await Promise.all(
     outputFiles.map(async (file) => {
-      const finalText = file.path.endsWith(".js")
+      const finalText = file.path.endsWith(".js") && rewriteJsExtensions
         ? addJsExtensionToImports(file.text)
         : file.text;
 

package/src/esbuild/esbuild-tsc-plugin.ts

@@ -1,12 +1,14 @@
 import type esbuild from "esbuild";
 import type ts from "typescript";
-import { err as errNs } from "@simplysm/core-common";
+import { createLogger, err as errNs } from "@simplysm/core-common";
 import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
 import type { ISdTsCompilerResult } from "../ts-compiler/sd-ts-compiler-result";
 import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 import type { LintWithProgramResult } from "../lint/lint-with-program";
 import type { TypecheckEnv } from "../utils/tsconfig";
 
+const logger = createLogger("sd:cli:esbuild-tsc-plugin");
+
 export interface TscPluginOptions {
   pkgDir: string;
   cwd: string;
@@ -69,6 +71,7 @@ export function createTscPlugin(options: TscPluginOptions): TscPluginResult {
           lastErrors = result.errors;
           lastLintResult = result.lint;
         } catch (err) {
+          logger.debug(`tsc plugin 예외 스택:\n${errNs.stack(err)}`);
           lastProgram = undefined;
           lastAffectedFiles = undefined;
           lastDiagnostics = [];

package/src/orchestrators/BaseOrchestrator.ts

@@ -57,6 +57,7 @@ export abstract class BaseOrchestrator {
       this._logger.debug("sd.config.ts 로드 완료");
     } catch (err) {
       this._logger.error(`sd.config.ts 로드 실패: ${errNs.message(err)}`);
+      this._logger.debug(`sd.config.ts 로드 실패 스택:\n${errNs.stack(err)}`);
       process.exitCode = 1;
       throw err;
     }

package/src/orchestrators/BuildOrchestrator.ts

@@ -152,6 +152,7 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
       this._logger.debug("sd.config.ts 로드 완료");
     } catch (err) {
       this._logger.error(`sd.config.ts 로드 실패: ${errNs.message(err)}`);
+      this._logger.debug(`sd.config.ts 로드 실패 스택:\n${errNs.stack(err)}`);
       process.exitCode = 1;
       throw err;
     }
@@ -238,13 +239,10 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
     for (const settledResult of buildResults) {
       if (settledResult.status === "rejected") {
         const err = settledResult.reason;
-        const stack = err instanceof Error ? err.stack : undefined;
         this._logger.error("빌드 중 예기치 않은 에러", {
-          error: String(err),
+          error: errNs.message(err),
         });
-        if (stack != null) {
-          this._logger.debug(`빌드 예외 스택:\n${stack}`);
-        }
+        this._logger.debug(`빌드 예외 스택:\n${errNs.stack(err)}`);
         hasUntrackedError.value = true;
       }
     }

package/src/orchestrators/DevOrchestrator.ts

@@ -246,6 +246,7 @@ export class DevOrchestrator extends BaseOrchestrator implements OrchestratorLif
             onServerReady: () => this._schedulePrintServers(),
           }).catch((err: unknown) => {
             this._logger.error(`[${name}] 서버 런타임 시작 실패:`, errNs.message(err));
+            this._logger.debug(`[${name}] 서버 런타임 시작 실패 스택:\n${errNs.stack(err)}`);
             this._resultCollector.add({
               name,
               target: "server",

package/src/orchestrators/ServerRuntimeManager.ts

@@ -52,6 +52,9 @@ export class ServerRuntimeManager {
     });
 
     runtimeWorker.on("error", (errorData) => {
+      if (errorData.stack != null) {
+        this._logger.debug(`[${params.serverName}] 서버 런타임 에러 스택:\n${errorData.stack}`);
+      }
       params.resultCollector.add({
         name: params.serverName,
         target: "server",
@@ -65,6 +68,7 @@ export class ServerRuntimeManager {
       .start({ mainJsPath: params.mainJsPath, clientPorts: params.clientPorts, env: params.env })
       .catch((err: unknown) => {
         this._logger.error(`[${params.serverName}] 서버 런타임 워커 비정상 종료:`, errNs.message(err));
+        this._logger.debug(`[${params.serverName}] 서버 런타임 워커 비정상 종료 스택:\n${errNs.stack(err)}`);
         params.resultCollector.add({
           name: params.serverName,
           target: "server",

package/src/orchestrators/TypecheckOrchestrator.ts

@@ -51,12 +51,13 @@ export interface TypecheckResult {
 
 //#region Utilities
 
-const TARGET_PATH_PATTERN = /^(?:packages|tests)\/([^/]+)/;
+const TARGET_PATH_PATTERN = /^[^/]+\/([^/]+)/;
 
 /**
- * 대상 경로에서 패키지명을 추출한다.
+ * 대상 경로에서 패키지명을 추출한다. 워크스페이스 종류(packages/·tests/·plugins/ 등)를 가리지 않는다.
  * "packages/core-common" → "core-common"
  * "tests/orm" → "orm"
+ * "plugins/sd" → "sd"
  */
 function extractTargetPackageNames(targets: string[]): Set<string> {
   const names = new Set<string>();
@@ -229,11 +230,8 @@ export class TypecheckOrchestrator implements OrchestratorLifecycle<TypecheckRes
         return result;
       } catch (err) {
         const message = errNs.message(err);
-        const stack = err instanceof Error ? err.stack : undefined;
         this._logger.error(`[${label}] 엔진 작업 실패: ${message}`);
-        if (stack != null) {
-          this._logger.debug(`[${label}] 스택 트레이스:\n${stack}`);
-        }
+        this._logger.debug(`[${label}] 스택 트레이스:\n${errNs.stack(err)}`);
         return {
           build: {
             success: false,

package/src/runtime/engine-watch-events.ts

@@ -1,6 +1,9 @@
+import { createLogger } from "@simplysm/core-common";
 import type { BuildResult, ResultCollector } from "../runtime/ResultCollector";
 import type { RebuildManager } from "./rebuild-manager";
 
+const logger = createLogger("sd:cli:watch-events");
+
 /**
  * worker.on()으로 이벤트를 구독할 수 있는 최소 인터페이스
  */
@@ -84,7 +87,10 @@ export function setupWatchEvents(
   });
 
   worker.on("error", (data: unknown) => {
-    const event = data as { message: string };
+    const event = data as { message: string; stack?: string };
+    if (event.stack != null) {
+      logger.debug(`[${name}] 워커 에러 스택:\n${event.stack}`);
+    }
 
     const buildResult: BuildResult = {
       name,

package/src/runtime/worker-events.ts

@@ -8,6 +8,7 @@ export interface BuildEventData {
 /** 워커 에러 이벤트 데이터 */
 export interface ErrorEventData {
   message: string;
+  stack?: string;
 }
 
 /** 워커 서버 준비 완료 이벤트 데이터 */

package/src/sd-cli-entry.ts

@@ -12,7 +12,6 @@ import { runInit } from "./commands/init/init";
 import { runInitClient } from "./commands/init/init-client";
 import { runPublish } from "./commands/publish/publish-command";
 import { runReplaceDeps } from "./commands/replace-deps";
-import { runReinstall } from "./commands/reinstall";
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
@@ -286,14 +285,6 @@ export function createCliParser(argv: string[]): Argv {
         });
       },
     )
-    .command(
-      "reinstall",
-      "Clean reinstall: delete node_modules/lock/dist/.cache then reinstall with build approval",
-      (cmd) => cmd.version(false).hide("help"),
-      async () => {
-        await runReinstall();
-      },
-    )
     .command(
       "init [kind]",
       "Bootstrap a new SI workspace via interactive prompts (kind=client: add a client package to an existing workspace)",