@simplysm/sd-cli 14.1.9 → 14.1.11

package/src/sd-cli.ts

@@ -44,6 +44,7 @@ if (isDev) {
       const code = err instanceof Error && "code" in err ? (err as NodeJS.ErrnoException).code : undefined;
       if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") {
         logger.warn("replaceDeps 사전 설정 실패:", errNs.message(err));
+        logger.debug(`replaceDeps 사전 설정 실패 스택:\n${errNs.stack(err)}`);
       }
     }
   }
@@ -109,5 +110,6 @@ function configureAffinityAndPriority(pid: number): void {
       "CPU affinity/priority 설정 실패:",
       errNs.message(err),
     );
+    logger.debug(`CPU affinity/priority 설정 실패 스택:\n${errNs.stack(err)}`);
   });
 }

package/src/typecheck/typecheck-non-package.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { pathx } from "@simplysm/core-node";
 import { createLogger } from "@simplysm/core-common";
 import { parseTsconfig } from "../utils/tsconfig";
+import { collectWorkspacePackages } from "../utils/workspace-utils";
 import { serializeDiagnostic, type SerializedDiagnostic } from "./typecheck-serialization";
 
 const logger = createLogger("sd:cli:typecheck-non-pkg");
@@ -27,10 +28,20 @@ export function typecheckNonPackageFiles(cwd: string): NonPackageTypecheckResult
   const parsedConfig = parseTsconfig(cwd);
   const packagesDir = path.join(cwd, "packages");
 
+  // packages/(배포 대상)가 아닌 워크스페이스(tests/·plugins/·향후 추가분)는 각자 엔진 타입체크가
+  // 자기 tsconfig로 담당하므로 루트 sweep에서 제외한다. 루트 tsconfig로 검사하면 그 워크스페이스
+  // 고유 옵션(allowImportingTsExtensions 등)이 무시돼 거짓 에러가 난다. 디렉터리명에 의존하지 않는다.
+  const nonDeployWorkspaceDirs = collectWorkspacePackages(cwd)
+    .filter((ws) => !ws.relPath.startsWith("packages/"))
+    .map((ws) => pathx.posixResolve(ws.absPath) + "/");
+
   const isNonPackageFile = (fileName: string): boolean => {
     const normalized = pathx.posixResolve(fileName);
     const normalizedPkgDir = pathx.posixResolve(packagesDir);
 
+    // packages/ 가 아닌 워크스페이스 파일 → 엔진이 자기 tsconfig로 담당, sweep 제외
+    if (nonDeployWorkspaceDirs.some((dir) => normalized.startsWith(dir))) return false;
+
     // packages/ 디렉토리 외부 파일
     if (!normalized.startsWith(normalizedPkgDir + "/")) return true;
 

package/src/utils/package-utils.ts

@@ -3,6 +3,7 @@ import fs from "fs";
 import { SdError } from "@simplysm/core-common";
 import { fsx, pathx } from "@simplysm/core-node";
 import { createLogger } from "@simplysm/core-common";
+import { collectWorkspacePackages } from "./workspace-utils";
 import type {
   SdPackageConfig,
 } from "../sd-config.types";
@@ -19,26 +20,31 @@ export function findPackageRoot(startDir: string): string {
 }
 
 /**
- * packages/ 및 tests/ 디렉토리에서 모든 워크스페이스 패키지를 탐색한다.
- * 디렉토리명 → 상대 경로의 맵을 반환한다 (예: "orm" → "tests/orm").
+ * package.json#workspaces의 모든 워크스페이스 패키지를 탐색한다.
+ * 디렉토리명 → 상대 경로의 맵을 반환한다 (예: "orm" → "tests/orm", "sd" → "plugins/sd").
+ * packages/·tests/·plugins/ 등 종류를 가리지 않고 포함하며, 배포/검사 대상 구분은 소비자가 relPath로 판단한다.
  */
 export function discoverWorkspacePackages(cwd: string): Map<string, string> {
   logger.debug("워크스페이스 패키지 탐색 시작");
   const map = new Map<string, string>();
-  for (const dir of ["packages", "tests"]) {
-    const baseDir = pathx.posix(path.join(cwd, dir));
-    if (!fs.existsSync(baseDir)) continue;
-    for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      if (!fs.existsSync(pathx.posix(path.join(baseDir, entry.name, "package.json")))) continue;
-      if (map.has(entry.name)) {
-        throw new SdError(
-          `Duplicate workspace package name: ${entry.name} (${map.get(entry.name)} and ${dir}/${entry.name})`,
-        );
-      }
-      map.set(entry.name, `${dir}/${entry.name}`);
+
+  const workspacePackages = (() => {
+    try {
+      return collectWorkspacePackages(cwd);
+    } catch {
+      return [];
+    }
+  })();
+
+  for (const item of workspacePackages) {
+    if (map.has(item.dirName)) {
+      throw new SdError(
+        `Duplicate workspace package name: ${item.dirName} (${map.get(item.dirName)} and ${item.relPath})`,
+      );
     }
+    map.set(item.dirName, item.relPath);
   }
+
   logger.debug(`워크스페이스 패키지 탐색 완료 (${map.size}개)`);
   return map;
 }
@@ -57,27 +63,28 @@ export function buildPathMapFromConfig(
 }
 
 /**
- * workspace에서 발견된 tests/ 패키지를 sd.config.ts 패키지에 병합한다.
- * tests 패키지는 기본적으로 `{ target: "node" }`가 할당된다.
- * 모든 패키지의 pathMap(name → 상대 경로)도 함께 구성한다.
- * tests 패키지명이 sd.config.ts 패키지명과 충돌하면 SdError를 던진다.
+ * workspace에서 발견된 비배포 워크스페이스(packages/ 가 아닌 tests/·plugins/ 등)를 sd.config.ts
+ * 패키지에 병합한다. 이들은 빌드 대상이 아니지만 각자 자기 tsconfig로 타입체크하기 위해
+ * `{ target: "node" }`가 할당된다. 모든 패키지의 pathMap(name → 상대 경로)도 함께 구성한다.
+ * 디렉터리명이 sd.config.ts 패키지명과 충돌하면 SdError를 던진다.
+ * 특정 디렉터리명이 아니라 "packages/ 인가"로만 갈라 새 워크스페이스 종류도 자동 포함된다.
  */
 export function mergeTestsPackagesIntoConfig(
   configPackages: Record<string, SdPackageConfig | undefined>,
   workspacePackages: Map<string, string>,
 ): { merged: Record<string, SdPackageConfig | undefined>; pathMap: Map<string, string> } {
-  logger.debug("tests 패키지 병합 시작");
+  logger.debug("비배포 워크스페이스 병합 시작");
   const pathMap = new Map<string, string>();
   const merged: Record<string, SdPackageConfig | undefined> = { ...configPackages };
 
-  // config 패키지의 기본 경로 설정
+  // config 패키지(배포 대상)의 기본 경로 설정
   for (const name of Object.keys(configPackages)) {
     pathMap.set(name, `packages/${name}`);
   }
 
-  // tests 패키지 추가
+  // packages/(배포 대상)가 아닌 워크스페이스 추가
   for (const [name, relPath] of workspacePackages) {
-    if (!relPath.startsWith("tests/")) continue;
+    if (relPath.startsWith("packages/")) continue;
 
     if (name in configPackages) {
       throw new SdError(
@@ -89,7 +96,7 @@ export function mergeTestsPackagesIntoConfig(
     pathMap.set(name, relPath);
   }
 
-  logger.debug(`tests 패키지 병합 완료 (총 ${Object.keys(merged).length}개)`);
+  logger.debug(`비배포 워크스페이스 병합 완료 (총 ${Object.keys(merged).length}개)`);
   return { merged, pathMap };
 }
 

package/src/utils/workspace-utils.ts

@@ -0,0 +1,117 @@
+import fs from "fs";
+import path from "path";
+import { globSync } from "glob";
+import { pathx } from "@simplysm/core-node";
+
+export interface WorkspacePackageDir {
+  dirName: string;
+  packageName: string;
+  relPath: string;
+  absPath: string;
+}
+
+interface WorkspaceRootPackageJson {
+  workspaces?: unknown;
+}
+
+interface WorkspacePackageJson {
+  name?: unknown;
+}
+
+/**
+ * root package.json의 workspaces 값을 Bun workspace 패턴 배열로 정규화한다.
+ */
+export function parsePackageJsonWorkspaces(workspaces: unknown): string[] {
+  const rawPatterns = Array.isArray(workspaces)
+    ? workspaces
+    : typeof workspaces === "object" && workspaces != null && Array.isArray((workspaces as { packages?: unknown }).packages)
+      ? (workspaces as { packages: unknown[] }).packages
+      : [];
+
+  return rawPatterns
+    .filter((item): item is string => typeof item === "string")
+    .map((item) => item.trim())
+    .filter((item) => item !== "");
+}
+
+export function readWorkspacePatterns(workspaceRoot: string): string[] {
+  const packageJsonPath = path.join(workspaceRoot, "package.json");
+  if (!fs.existsSync(packageJsonPath)) return [];
+
+  const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as WorkspaceRootPackageJson;
+  return parsePackageJsonWorkspaces(pkgJson.workspaces);
+}
+
+export function findWorkspaceRoot(startDir: string): string | undefined {
+  let current = path.resolve(startDir);
+  if (fs.existsSync(current) && fs.statSync(current).isFile()) {
+    current = path.dirname(current);
+  }
+
+  while (true) {
+    if (readWorkspacePatterns(current).length > 0) {
+      return pathx.posix(current);
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) return undefined;
+    current = parent;
+  }
+}
+
+function splitWorkspacePatterns(patterns: string[]): { include: string[]; exclude: string[] } {
+  const include: string[] = [];
+  const exclude: string[] = [];
+
+  for (const pattern of patterns) {
+    if (pattern.startsWith("!")) {
+      const excluded = pattern.slice(1).trim();
+      if (excluded !== "") exclude.push(excluded);
+    } else {
+      include.push(pattern);
+    }
+  }
+
+  return { include, exclude };
+}
+
+/**
+ * Bun workspace root의 package.json#workspaces 기준으로 실제 패키지 디렉터리를 수집한다.
+ */
+export function collectWorkspacePackages(workspaceRoot: string): WorkspacePackageDir[] {
+  const root = pathx.posix(path.resolve(workspaceRoot));
+  const patterns = readWorkspacePatterns(root);
+  const { include, exclude } = splitWorkspacePatterns(patterns);
+  const absDirs = new Set<string>();
+
+  for (const pattern of include) {
+    const matches = globSync(pattern, {
+      cwd: root,
+      absolute: true,
+      nodir: false,
+      ignore: exclude,
+    });
+
+    for (const match of matches) {
+      const absPath = pathx.posix(path.resolve(match));
+      const packageJsonPath = path.join(absPath, "package.json");
+      if (!fs.existsSync(packageJsonPath)) continue;
+      if (!fs.statSync(absPath).isDirectory()) continue;
+      absDirs.add(absPath);
+    }
+  }
+
+  return [...absDirs]
+    .sort((a, b) => a.localeCompare(b))
+    .map((absPath): WorkspacePackageDir => {
+      const relPath = pathx.posix(path.relative(root, absPath));
+      const pkgJson = JSON.parse(fs.readFileSync(path.join(absPath, "package.json"), "utf-8")) as WorkspacePackageJson;
+      const packageName = typeof pkgJson.name === "string" ? pkgJson.name : path.basename(absPath);
+      return {
+        dirName: path.basename(absPath),
+        packageName,
+        relPath,
+        absPath,
+      };
+    });
+}

package/src/workers/client.worker.ts

@@ -57,7 +57,7 @@ export interface ClientWorkerEvents extends Record<string, unknown> {
   buildStart: Record<string, never>;
   build: ClientBuildResult;
   serverReady: { port: number };
-  error: { message: string };
+  error: { message: string; stack?: string };
 }
 
 //#endregion
@@ -207,6 +207,7 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
       errors.push(errNs.message(err));
     }
     logger.debug(`[${info.name}] client worker build 예외: ${errors.join("\n")}`);
+    logger.debug(`[${info.name}] client worker build 예외 스택:\n${errNs.stack(err)}`);
     return { success: false, errors };
   }
 }
@@ -313,8 +314,10 @@ function createDevBuildEndHandler(
       }
     } catch (err) {
       const message = errNs.message(err);
+      const stack = errNs.stack(err);
+      logger.debug(`client dev build end 예외 스택:\n${stack}`);
       if (!isInitialBuild) {
-        sender.send("error", { message });
+        sender.send("error", { message, stack });
       } else {
         isInitialBuild = false;
         initialBuildResolve?.({
@@ -423,7 +426,7 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
         hmrService?.broadcast({ type: "full-reload" });
         sender.send("build", { success: true });
       } catch (err) {
-        sender.send("error", { message: errNs.message(err) });
+        sender.send("error", { message: errNs.message(err), stack: errNs.stack(err) });
       }
     });
 
@@ -437,7 +440,9 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
     return initialResult;
   } catch (err) {
     const message = errNs.message(err);
-    sender.send("error", { message });
+    const stack = errNs.stack(err);
+    logger.debug(`[${info.name}] client worker startWatch 예외 스택:\n${stack}`);
+    sender.send("error", { message, stack });
     return { success: false, errors: [message] };
   }
 }

package/src/workers/library-build.worker.ts

@@ -36,7 +36,7 @@ export interface CombinedBuildEvent {
 export interface LibraryBuildWorkerEvents extends Record<string, unknown> {
   buildStart: Record<string, never>;
   build: CombinedBuildEvent;
-  error: { message: string };
+  error: { message: string; stack?: string };
 }
 
 //#endregion
@@ -135,6 +135,7 @@ async function build(info: LibraryBuildInfo): Promise<LibraryBuildResult> {
   } catch (err) {
     const message = errNs.message(err);
     logger.debug(`[${info.name}] library worker build 예외 발생: ${message}`);
+    logger.debug(`[${info.name}] library worker build 예외 스택:\n${errNs.stack(err)}`);
     return {
       build: { success: false, errors: [message], diagnostics: [] },
     };
@@ -323,11 +324,11 @@ async function startWatch(info: LibraryBuildInfo): Promise<void> {
         const event = buildWatchEvent(info, result, changedScssFiles);
         sender.send("build", event);
       } catch (err) {
-        sender.send("error", { message: errNs.message(err) });
+        sender.send("error", { message: errNs.message(err), stack: errNs.stack(err) });
       }
     });
   } catch (err) {
-    sender.send("error", { message: errNs.message(err) });
+    sender.send("error", { message: errNs.message(err), stack: errNs.stack(err) });
   }
 }
 

package/src/workers/server-build.worker.ts

@@ -92,7 +92,7 @@ export interface ServerCombinedBuildEvent {
 export interface ServerBuildWorkerEvents extends Record<string, unknown> {
   buildStart: Record<string, never>;
   build: ServerCombinedBuildEvent;
-  error: { message: string };
+  error: { message: string; stack?: string };
 }
 
 //#endregion
@@ -169,7 +169,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
       jsResult = await esbuild.build({ ...esbuildOptions, plugins: [createWorkerBundlePlugin(), tscPlugin.plugin] })
         .then(async (result) => {
           if (result.outputFiles) {
-            await writeChangedOutputFiles(result.outputFiles);
+            await writeChangedOutputFiles(result.outputFiles, { rewriteJsExtensions: false });
           }
           const errors = formatEsbuildMessages(result.errors, "error");
           const warnings = formatEsbuildMessages(result.warnings, "warning");
@@ -179,11 +179,14 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
             warnings: warnings.length > 0 ? warnings : undefined,
           };
         })
-        .catch((err) => ({
-          success: false,
-          errors: [errNs.message(err)],
-          warnings: undefined,
-        }));
+        .catch((err) => {
+          logger.debug(`[${info.name}] server esbuild build 예외 스택:\n${errNs.stack(err)}`);
+          return {
+            success: false,
+            errors: [errNs.message(err)],
+            warnings: undefined,
+          };
+        });
 
       tscErrors = tscPlugin.getErrors() ?? [];
       tscDiagnostics = tscPlugin.getDiagnostics();
@@ -231,11 +234,8 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
     };
   } catch (err) {
     const message = errNs.message(err);
-    const stack = err instanceof Error ? err.stack : undefined;
     logger.debug(`[${info.name}] server worker build 예외: ${message}`);
-    if (stack != null) {
-      logger.debug(`[${info.name}] 스택 트레이스:\n${stack}`);
-    }
+    logger.debug(`[${info.name}] 스택 트레이스:\n${errNs.stack(err)}`);
     return {
       build: { success: false, errors: [message], diagnostics: [] },
       mainJsPath,
@@ -358,11 +358,11 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
       initialExternals: cachedExternal,
       onBuildStart: () => sender.send("buildStart", {}),
       onBuild: (result) => sender.send("build", result),
-      onError: (message) => sender.send("error", { message }),
+      onError: (message, stack) => sender.send("error", { message, stack }),
       rebuild: () => rebuildAll(),
     });
   } catch (err) {
-    sender.send("error", { message: errNs.message(err) });
+    sender.send("error", { message: errNs.message(err), stack: errNs.stack(err) });
   }
 }
 

package/src/workers/server-esbuild-context.ts

@@ -1,6 +1,6 @@
 import type ts from "typescript";
 import esbuild from "esbuild";
-import { err as errNs } from "@simplysm/core-common";
+import { createLogger, err as errNs } from "@simplysm/core-common";
 import { formatEsbuildMessages } from "../utils/output-utils";
 import {
   createServerEsbuildOptions,
@@ -12,6 +12,8 @@ import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization"
 import type { LintWithProgramResult } from "../lint/lint-with-program";
 import { createWorkerBundlePlugin } from "../esbuild/esbuild-worker-plugin";
 
+const logger = createLogger("sd:cli:server-esbuild-context");
+
 /**
  * esbuild watch context 생성 옵션
  */
@@ -87,6 +89,7 @@ export async function rebuild(): Promise<{
   try {
     result = await context.rebuild();
   } catch (err) {
+    logger.debug(`server esbuild rebuild 예외 스택:\n${errNs.stack(err)}`);
     const tscErrors = tscPlugin?.getErrors() ?? [];
     const allErrors = [errNs.message(err), ...tscErrors];
     return {
@@ -101,7 +104,7 @@ export async function rebuild(): Promise<{
   }
 
   if (result.outputFiles) {
-    await writeChangedOutputFiles(result.outputFiles);
+    await writeChangedOutputFiles(result.outputFiles, { rewriteJsExtensions: false });
   }
 
   const esbuildErrors = formatEsbuildMessages(result.errors, "error");

package/src/workers/server-runtime.worker.ts

@@ -32,6 +32,7 @@ export interface ServerRuntimeReadyEvent {
  */
 export interface ServerRuntimeErrorEvent {
   message: string;
+  stack?: string;
 }
 
 /**
@@ -73,18 +74,22 @@ async function cleanup(): Promise<void> {
 // 서버 listen() 이후 발생하는 런타임 에러를 잡아 커스텀 "error" 이벤트로 전송
 // (이 핸들러 없이는 워커가 크래시해도 빌드 Promise가 resolve되지 않아 프로세스가 중단될 수 있다)
 process.on("uncaughtException", (err) => {
-  logger.error("서버 런타임 미처리 에러", err);
+  logger.error("서버 런타임 미처리 에러", errNs.message(err));
+  logger.debug(`서버 런타임 미처리 에러 스택:\n${errNs.stack(err)}`);
   sender.send("error", {
     message: errNs.message(err),
+    stack: errNs.stack(err),
   });
   // 이벤트 전송 후 종료할 수 있도록 대기
   setTimeout(() => process.exit(1), 500);
 });
 
 process.on("unhandledRejection", (reason) => {
-  logger.error("서버 런타임 미처리 Promise 거부", reason);
+  logger.error("서버 런타임 미처리 Promise 거부", errNs.message(reason));
+  logger.debug(`서버 런타임 미처리 Promise 거부 스택:\n${errNs.stack(reason)}`);
   sender.send("error", {
     message: errNs.message(reason),
+    stack: errNs.stack(reason),
   });
   // 이벤트 전송 후 종료할 수 있도록 대기
   setTimeout(() => process.exit(1), 500);
@@ -195,9 +200,11 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
 
     sender.send("serverReady", { port: server.options.port });
   } catch (err) {
-    logger.error("서버 런타임 시작 실패", err);
+    logger.error("서버 런타임 시작 실패", errNs.message(err));
+    logger.debug(`서버 런타임 시작 실패 스택:\n${errNs.stack(err)}`);
     sender.send("error", {
       message: errNs.message(err),
+      stack: errNs.stack(err),
     });
   }
 }

package/src/workers/server-watch-manager.ts

@@ -25,7 +25,7 @@ export interface ServerWatchLoopConfig {
   /** 빌드 완료 이벤트 콜백 */
   onBuild: (result: { build: { success: boolean; errors?: string[]; warnings?: string[] }; mainJsPath: string }) => void;
   /** 에러 이벤트 콜백 */
-  onError: (message: string) => void;
+  onError: (message: string, stack?: string) => void;
   /** 리빌드 실행 콜백 */
   rebuild: () => Promise<{ build: { success: boolean; errors?: string[]; warnings?: string[] }; mainJsPath: string }>;
 }
@@ -99,7 +99,7 @@ export async function startServerWatchLoop(config: ServerWatchLoopConfig): Promi
 
       const hasRelevantChange = changes.some((c) => {
         if (metafileAbsPaths.has(c.path)) return true;
-        // pnpm symlink 경로와 esbuild resolved 경로 불일치 대응
+        // package manager symlink 경로와 esbuild resolved 경로 불일치 대응
         try {
           const realPath = pathx.posix(fs.realpathSync(c.path));
           return metafileAbsPaths.has(realPath);
@@ -116,7 +116,7 @@ export async function startServerWatchLoop(config: ServerWatchLoopConfig): Promi
         logger.debug("변경된 파일이 빌드에 포함되지 않아 리빌드 건너뜀");
       }
     } catch (err) {
-      config.onError(errNs.message(err));
+      config.onError(errNs.message(err), errNs.stack(err));
     }
   });