@simplysm/sd-cli 14.2.6 → 14.2.7

package/src/utils/license-extractor.ts

@@ -0,0 +1,224 @@
+import path from "path";
+import { fsx } from "@simplysm/core-node";
+import type esbuild from "esbuild";
+
+/** 빌드 산출물에 기록하는 제3자 라이선스 고지 파일명 */
+export const LICENSE_NOTICE_FILE_NAME = "3rdpartylicenses.txt";
+
+/** 패키지 경계를 나타내는 경로 세그먼트 */
+const NODE_MODULES_SEGMENT = "node_modules";
+
+/** 패키지 루트에서 라이선스 본문을 찾을 때 시도하는 파일명 */
+const LICENSE_FILE_NAMES = ["LICENSE", "LICENSE.txt", "LICENSE.md"];
+
+/** npm 이 정한 커스텀 라이선스 표기 접두사 (`SEE LICENSE IN <파일명>`) */
+const CUSTOM_LICENSE_PREFIX = "SEE LICENSE IN ";
+
+/** 고지 파일의 패키지 항목 구분선 */
+const ENTRY_SEPARATOR = "-".repeat(80);
+
+/** 고지 파일 머리말 */
+const FILE_HEADER = "이 파일은 함께 배포되는 산출물에 포함된 제3자 패키지의 라이선스 고지입니다.";
+
+/**
+ * 라이선스 판정에 사용하는 package.json 필드.
+ *
+ * `license` 오브젝트와 `licenses` 배열은 npm 이 deprecated 로 지정한 표기지만
+ * 실제 배포된 구 패키지에 남아 있어, 라이선스 미상 오판을 막기 위해 함께 인식한다.
+ * (https://docs.npmjs.com/cli/v11/configuring-npm/package-json)
+ */
+interface LicenseManifest {
+  name?: string;
+  version?: string;
+  license?: string | { type?: string };
+  licenses?: { type?: string }[];
+}
+
+/** metafile 입력 경로에서 역추적한 패키지 위치 */
+export interface PackageRef {
+  packageName: string;
+  packageDir: string;
+}
+
+/**
+ * `node_modules` 아래 파일의 절대 경로에서 그 파일이 속한 패키지를 역추적한다.
+ *
+ * 경로를 상위로 거슬러 올라가며 `node_modules` 세그먼트를 찾고, 직전까지 지나온
+ * 세그먼트로 패키지명을 조립한다. `@scope/name` 형태는 두 세그먼트를 한 이름으로 합친다.
+ *
+ * @returns `node_modules` 를 거치지 않는 경로(자체 소스, 워크스페이스 패키지)면 undefined
+ */
+export function resolvePackageRef(absInputPath: string): PackageRef | undefined {
+  let dir = absInputPath;
+  let nameOrScope: string | undefined;
+  let nameOrFile: string | undefined;
+  let found = false;
+
+  while (dir !== path.dirname(dir)) {
+    const segment = path.basename(dir);
+    if (segment === NODE_MODULES_SEGMENT) {
+      found = true;
+      break;
+    }
+    nameOrFile = nameOrScope;
+    nameOrScope = segment;
+    dir = path.dirname(dir);
+  }
+
+  if (!found || nameOrScope == null) return undefined;
+
+  const packageName =
+    nameOrScope.startsWith("@") && nameOrFile != null
+      ? `${nameOrScope}/${nameOrFile}`
+      : nameOrScope;
+
+  return { packageName, packageDir: path.join(dir, packageName) };
+}
+
+/**
+ * package.json 에서 라이선스 식별자를 뽑는다.
+ *
+ * @returns 어떤 표기로도 라이선스를 알 수 없으면 undefined
+ */
+export function resolveLicenseId(manifest: LicenseManifest): string | undefined {
+  if (typeof manifest.license === "string") {
+    const trimmed = manifest.license.trim();
+    if (trimmed !== "") return trimmed;
+  } else if (manifest.license != null) {
+    const type = manifest.license.type?.trim();
+    if (type != null && type !== "") return type;
+  }
+
+  const legacyTypes = (manifest.licenses ?? [])
+    .map((item) => item.type?.trim())
+    .filter((type): type is string => type != null && type !== "");
+  if (legacyTypes.length > 0) return legacyTypes.join(" OR ");
+
+  return undefined;
+}
+
+/**
+ * 패키지 루트에서 라이선스 본문을 읽는다.
+ *
+ * `SEE LICENSE IN <파일명>` 표기면 그 파일을 읽고, 아니면 관용적인 LICENSE 파일명을 차례로 시도한다.
+ *
+ * @returns 라이선스 파일을 동봉하지 않은 패키지면 undefined (식별자만으로 고지가 성립한다)
+ * @throws `SEE LICENSE IN` 이 가리키는 파일을 읽을 수 없을 때
+ */
+async function readLicenseText(
+  packageRef: PackageRef,
+  licenseId: string,
+): Promise<string | undefined> {
+  if (licenseId.toUpperCase().startsWith(CUSTOM_LICENSE_PREFIX)) {
+    const fileName = licenseId.slice(CUSTOM_LICENSE_PREFIX.length).trim();
+    const normalized = path.normalize(fileName);
+    if (path.isAbsolute(normalized) || normalized.startsWith("..")) {
+      throw new Error(
+        `라이선스 파일 경로가 패키지 바깥을 가리킵니다: ${packageRef.packageName} (${licenseId})`,
+      );
+    }
+
+    const customPath = path.join(packageRef.packageDir, normalized);
+    if (!(await fsx.exists(customPath))) {
+      throw new Error(`라이선스 파일을 찾을 수 없습니다: ${packageRef.packageName} (${licenseId})`);
+    }
+    return fsx.read(customPath);
+  }
+
+  for (const candidate of LICENSE_FILE_NAMES) {
+    const licensePath = path.join(packageRef.packageDir, candidate);
+    if (await fsx.exists(licensePath)) {
+      return fsx.read(licensePath);
+    }
+  }
+
+  return undefined;
+}
+
+/** 고지 파일에 기록할 패키지 1건 */
+interface LicenseEntry {
+  name: string;
+  version: string | undefined;
+  licenseId: string;
+  licenseText: string | undefined;
+}
+
+/**
+ * esbuild metafile 을 근거로 번들에 실제 포함된 제3자 패키지의 라이선스 고지문을 만든다.
+ *
+ * 트리셰이킹으로 잘려나가 산출물에 남지 않은 입력(`bytesInOutput` 이 0 이하)은 제외한다.
+ * 같은 패키지의 같은 버전은 한 번만 기록한다.
+ *
+ * @param metafile esbuild 빌드 결과 metafile
+ * @param rootDir metafile 의 상대 입력 경로를 절대 경로로 바꿀 기준 디렉터리 (esbuild 실행 작업 디렉터리)
+ * @throws 라이선스를 알 수 없는 패키지가 하나라도 있을 때
+ */
+export async function extractLicenses(
+  metafile: esbuild.Metafile,
+  rootDir: string,
+): Promise<string> {
+  const seenInputPaths = new Set<string>();
+  const seenPackageIds = new Set<string>();
+  const entries: LicenseEntry[] = [];
+  const unknownPackages: string[] = [];
+
+  for (const output of Object.values(metafile.outputs)) {
+    for (const [inputPath, { bytesInOutput }] of Object.entries(output.inputs)) {
+      if (bytesInOutput <= 0) continue;
+      if (seenInputPaths.has(inputPath)) continue;
+      seenInputPaths.add(inputPath);
+
+      const packageRef = resolvePackageRef(path.resolve(rootDir, inputPath));
+      if (packageRef == null) continue;
+
+      const manifestPath = path.join(packageRef.packageDir, "package.json");
+      if (!(await fsx.exists(manifestPath))) {
+        throw new Error(`패키지 정보를 찾을 수 없습니다: ${manifestPath} (입력: ${inputPath})`);
+      }
+      const manifest = await fsx.readJson<LicenseManifest>(manifestPath);
+
+      const packageId = `${packageRef.packageName}@${manifest.version ?? ""}`;
+      if (seenPackageIds.has(packageId)) continue;
+      seenPackageIds.add(packageId);
+
+      const licenseId = resolveLicenseId(manifest);
+      if (licenseId == null) {
+        unknownPackages.push(packageId);
+        continue;
+      }
+
+      entries.push({
+        name: manifest.name ?? packageRef.packageName,
+        version: manifest.version,
+        licenseId,
+        licenseText: await readLicenseText(packageRef, licenseId),
+      });
+    }
+  }
+
+  if (unknownPackages.length > 0) {
+    throw new Error(
+      `라이선스를 알 수 없는 패키지가 있어 고지 파일을 만들 수 없습니다.\n` +
+        unknownPackages
+          .sort()
+          .map((id) => `  - ${id}`)
+          .join("\n"),
+    );
+  }
+
+  entries.sort(
+    (a, b) => a.name.localeCompare(b.name) || (a.version ?? "").localeCompare(b.version ?? ""),
+  );
+
+  let content = `${FILE_HEADER}\n\n${ENTRY_SEPARATOR}\n`;
+  for (const entry of entries) {
+    content += `Package: ${entry.name}${entry.version != null ? `@${entry.version}` : ""}\n`;
+    content += `License: ${entry.licenseId}\n`;
+    if (entry.licenseText != null) {
+      content += `\n${entry.licenseText.trimEnd()}\n`;
+    }
+    content += `${ENTRY_SEPARATOR}\n`;
+  }
+
+  return content;
+}

package/src/workers/client.worker.ts

@@ -13,6 +13,7 @@ import { createDevHttpServer, type DevHttpServer } from "../dev-server/dev-http-
 import { createHmrService, type HmrService } from "../dev-server/hmr-service";
 import { createHmrPostTransform } from "../dev-server/hmr-client-script";
 import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public";
+import { extractLicenses, LICENSE_NOTICE_FILE_NAME } from "../utils/license-extractor";
 import { buildSsrBundle } from "../esbuild/esbuild-ssr-config";
 import { prerenderRoutes } from "../ssg/prerender";
 import type { SdBrowserSupportConfig, SdPwaConfig } from "../sd-config.types";
@@ -99,8 +100,7 @@ function resolvePackageInfo(info: ClientBuildInfo): {
 async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
   logger.debug(`[${info.name}] client worker build 시작`);
   try {
-    const { pkgName, legacyModule, browserslist, postcssPlugins } =
-      resolvePackageInfo(info);
+    const { pkgName, legacyModule, browserslist, postcssPlugins } = resolvePackageInfo(info);
 
     const outdir = info.outDir ?? path.join(info.pkgDir, "dist");
 
@@ -136,8 +136,7 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
     const basePath = info.base ?? `/${name}/`;
     const indexPath = path.join(info.pkgDir, "src", "index.html");
 
-    const pwaHtmlTransform =
-      info.pwa !== false ? createPwaHtmlTransform() : undefined;
+    const pwaHtmlTransform = info.pwa !== false ? createPwaHtmlTransform() : undefined;
 
     const indexResult = await generateIndexHtml({
       indexPath,
@@ -188,8 +187,12 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
     await ctx.context.dispose();
     // SourceFileCache는 LMDB 기반. context.dispose()에 의해 정리됨.
 
-    // 8. .config.json 기록
+    // 8. .config.json + 제3자 라이선스 고지 기록
     writeConfigJson(outdir, info.configs);
+    fsx.writeSync(
+      path.join(outdir, LICENSE_NOTICE_FILE_NAME),
+      await extractLicenses(result.metafile!, process.cwd()),
+    );
 
     logger.debug(`[${info.name}] client worker build 완료`);
     return {
@@ -224,13 +227,9 @@ function createSourceFileCachePlugin(): esbuild.Plugin {
       pluginBuild.onStart(() => {
         // sourceFileCache 무효화: 변경된 파일의 loadResultCache + TypeScript 소스 캐시 모두 제거
         if (esbuildResult != null) {
-          const { loadResultCache, typeScriptFileCache } =
-            esbuildResult.sourceFileCache;
+          const { loadResultCache, typeScriptFileCache } = esbuildResult.sourceFileCache;
           // JS 파일 (loadResultCache) + TS 파일 (typeScriptFileCache) 모두 감시
-          const watchTargets = [
-            ...loadResultCache.watchFiles,
-            ...typeScriptFileCache.keys(),
-          ];
+          const watchTargets = [...loadResultCache.watchFiles, ...typeScriptFileCache.keys()];
           const changedFiles = mtimeTracker.detectChanges(watchTargets);
           const normalizedChangedFiles = new Set<string>();
           for (const file of changedFiles) {
@@ -296,12 +295,10 @@ function createDevBuildEndHandler(
 
       // build 이벤트 전송
       const success = result.errors.length === 0;
-      const errors = result.errors.length > 0
-        ? formatEsbuildMessages(result.errors, "error")
-        : undefined;
-      const warnings = result.warnings.length > 0
-        ? formatEsbuildMessages(result.warnings, "warning")
-        : undefined;
+      const errors =
+        result.errors.length > 0 ? formatEsbuildMessages(result.errors, "error") : undefined;
+      const warnings =
+        result.warnings.length > 0 ? formatEsbuildMessages(result.warnings, "warning") : undefined;
 
       if (!isInitialBuild) {
         sender.send("build", { success, errors, warnings });
@@ -338,8 +335,7 @@ function createDevBuildEndHandler(
  */
 async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
   guardStartWatch();
-  const { pkgName, legacyModule, browserslist, postcssPlugins } =
-    resolvePackageInfo(info);
+  const { pkgName, legacyModule, browserslist, postcssPlugins } = resolvePackageInfo(info);
 
   logger.debug(
     `[${info.name}] client worker startWatch 시작 (port: ${info.port ?? "auto"}, legacy: ${legacyModule})`,
@@ -492,10 +488,7 @@ async function stopWatch(): Promise<void> {
 }
 
 /** .config.json 생성 */
-function writeConfigJson(
-  distDir: string,
-  configs?: Record<string, unknown>,
-): void {
+function writeConfigJson(distDir: string, configs?: Record<string, unknown>): void {
   fsx.writeJsonSync(path.join(distDir, ".config.json"), configs ?? {}, { space: 2 });
 }
 

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

@@ -7,21 +7,19 @@ import { formatEsbuildMessages } from "../utils/output-utils";
 import type { BuildOutput } from "../engines/types";
 import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 import type { LintWithProgramResult } from "../lint/lint-with-program";
+import { parseTsconfig, getPackageSourceFiles } from "../utils/tsconfig";
+import { createServerEsbuildOptions, writeChangedOutputFiles } from "../esbuild/esbuild-config";
 import {
-  parseTsconfig,
-  getPackageSourceFiles,
-} from "../utils/tsconfig";
-import {
-  createServerEsbuildOptions,
-  writeChangedOutputFiles,
-} from "../esbuild/esbuild-config";
-import { collectAllExternals, generateProductionFiles } from "../deps/server-externals/server-production-files";
+  collectAllExternals,
+  generateProductionFiles,
+} from "../deps/server-externals/server-production-files";
 import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
 import { createTscPlugin } from "../esbuild/esbuild-tsc-plugin";
 import { createWorkerBundlePlugin } from "../esbuild/esbuild-worker-plugin";
 import { setupWorkerLifecycle } from "./shared-worker-lifecycle";
 import { buildWatchPaths } from "./build-watch-paths";
 import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public";
+import { extractLicenses, LICENSE_NOTICE_FILE_NAME } from "../utils/license-extractor";
 import * as esbuildCtx from "./server-esbuild-context";
 import { startServerWatchLoop } from "./server-watch-manager";
 
@@ -72,7 +70,12 @@ export interface ServerWatchInfo {
  * 서버 빌드 결과 (LibraryBuildResult + mainJsPath 형태)
  */
 export interface ServerBuildResult {
-  build: { success: boolean; errors?: string[]; warnings?: string[]; diagnostics: SerializedDiagnostic[] };
+  build: {
+    success: boolean;
+    errors?: string[];
+    warnings?: string[];
+    diagnostics: SerializedDiagnostic[];
+  };
   lint?: LintWithProgramResult;
   mainJsPath: string;
 }
@@ -133,7 +136,9 @@ const { logger, guardStartWatch } = setupWorkerLifecycle("server-build", cleanup
  */
 async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
   const mainJsPath = pathx.posixResolve(info.pkgDir, "dist", "main.js");
-  logger.debug(`[${info.name}] server worker build 시작 (js: ${info.output.js}, dts: ${info.output.dts})`);
+  logger.debug(
+    `[${info.name}] server worker build 시작 (js: ${info.output.js}, dts: ${info.output.dts})`,
+  );
 
   try {
     // tsconfig 파싱
@@ -147,6 +152,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
     let tscErrors: string[];
     let tscDiagnostics: SerializedDiagnostic[];
     let lint: LintWithProgramResult | undefined;
+    let bundleMetafile: esbuild.Metafile | undefined;
 
     if (info.output.js) {
       // js=true: tsc 플러그인 통합 — 단일 esbuild.build() 호출
@@ -166,8 +172,10 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
         external: bundleExternals,
       });
 
-      jsResult = await esbuild.build({ ...esbuildOptions, plugins: [createWorkerBundlePlugin(), tscPlugin.plugin] })
+      jsResult = await esbuild
+        .build({ ...esbuildOptions, plugins: [createWorkerBundlePlugin(), tscPlugin.plugin] })
         .then(async (result) => {
+          bundleMetafile = result.metafile;
           if (result.outputFiles) {
             await writeChangedOutputFiles(result.outputFiles, { rewriteJsExtensions: false });
           }
@@ -217,11 +225,23 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
       await copyPublicFiles(info.pkgDir, false);
 
       generateProductionFiles(info, prodDependencies);
+
+      if (jsResult.success) {
+        if (bundleMetafile == null) {
+          throw new Error("번들 metafile이 없어 제3자 라이선스 고지를 생성할 수 없습니다.");
+        }
+        await fsx.write(
+          path.join(info.pkgDir, "dist", LICENSE_NOTICE_FILE_NAME),
+          await extractLicenses(bundleMetafile, process.cwd()),
+        );
+      }
     }
 
     const allErrors = [...(jsResult.errors ?? []), ...tscErrors];
     const tscSuccess = tscErrors.length === 0;
-    logger.debug(`[${info.name}] server worker build 완료 (js: ${jsResult.success}, tsc: ${tscSuccess})`);
+    logger.debug(
+      `[${info.name}] server worker build 완료 (js: ${jsResult.success}, tsc: ${tscSuccess})`,
+    );
     return {
       build: {
         success: jsResult.success && tscSuccess,

package/tests/utils/license-extractor.spec.ts

@@ -0,0 +1,273 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import type esbuild from "esbuild";
+
+const { extractLicenses, resolvePackageRef, resolveLicenseId } =
+  await import("../../src/utils/license-extractor");
+
+let rootDir: string;
+
+beforeEach(() => {
+  rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-cli-license-"));
+});
+
+afterEach(() => {
+  fs.rmSync(rootDir, { recursive: true, force: true });
+});
+
+/** rootDir 하위에 패키지 디렉터리를 만든다 */
+function writePackage(
+  relDir: string,
+  manifest: object | undefined,
+  files: Record<string, string> = {},
+): void {
+  const dir = path.join(rootDir, relDir);
+  fs.mkdirSync(dir, { recursive: true });
+  if (manifest != null) {
+    fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify(manifest));
+  }
+  for (const [fileName, content] of Object.entries(files)) {
+    fs.writeFileSync(path.join(dir, fileName), content);
+  }
+}
+
+/** 입력 경로별 bytesInOutput 을 담은 단일 출력 metafile 을 만든다 */
+function metafileOf(inputs: Record<string, number>): esbuild.Metafile {
+  return {
+    inputs: {},
+    outputs: {
+      "dist/main.js": {
+        bytes: 0,
+        inputs: Object.fromEntries(
+          Object.entries(inputs).map(([inputPath, bytesInOutput]) => [
+            inputPath,
+            { bytesInOutput },
+          ]),
+        ),
+        imports: [],
+        exports: [],
+      },
+    },
+  };
+}
+
+describe("resolvePackageRef", () => {
+  it("node_modules 아래 파일에서 패키지명을 역추적한다", () => {
+    const ref = resolvePackageRef(path.join(rootDir, "node_modules", "foo", "dist", "index.js"));
+    expect(ref?.packageName).toBe("foo");
+    expect(ref?.packageDir).toBe(path.join(rootDir, "node_modules", "foo"));
+  });
+
+  it("scope 가 있는 패키지는 scope 를 포함한 이름으로 역추적한다", () => {
+    const ref = resolvePackageRef(
+      path.join(rootDir, "node_modules", "@scope", "bar", "src", "index.js"),
+    );
+    expect(ref?.packageName).toBe("@scope/bar");
+    expect(ref?.packageDir).toBe(path.join(rootDir, "node_modules", "@scope", "bar"));
+  });
+
+  it("중첩된 node_modules 에서는 가장 가까운 패키지를 찾는다", () => {
+    const ref = resolvePackageRef(
+      path.join(rootDir, "node_modules", "outer", "node_modules", "inner", "index.js"),
+    );
+    expect(ref?.packageName).toBe("inner");
+  });
+
+  it("node_modules 를 거치지 않는 경로는 패키지가 아니다", () => {
+    expect(
+      resolvePackageRef(path.join(rootDir, "packages", "app", "src", "main.ts")),
+    ).toBeUndefined();
+  });
+});
+
+describe("resolveLicenseId", () => {
+  it("license 문자열을 그대로 사용한다", () => {
+    expect(resolveLicenseId({ license: "MIT" })).toBe("MIT");
+  });
+
+  it("공백뿐인 license 는 미상으로 본다", () => {
+    expect(resolveLicenseId({ license: "   " })).toBeUndefined();
+  });
+
+  it("deprecated license 오브젝트의 type 을 인식한다", () => {
+    expect(resolveLicenseId({ license: { type: "BSD-3-Clause" } })).toBe("BSD-3-Clause");
+  });
+
+  it("deprecated licenses 배열의 type 들을 OR 로 잇는다", () => {
+    expect(resolveLicenseId({ licenses: [{ type: "MIT" }, { type: "Apache-2.0" }] })).toBe(
+      "MIT OR Apache-2.0",
+    );
+  });
+
+  it("어떤 표기도 없으면 미상이다", () => {
+    expect(resolveLicenseId({ name: "foo", version: "1.0.0" })).toBeUndefined();
+  });
+});
+
+describe("extractLicenses", () => {
+  it("LICENSE 파일이 있으면 본문까지 기록한다", async () => {
+    writePackage(
+      "node_modules/foo",
+      { name: "foo", version: "1.2.3", license: "MIT" },
+      { LICENSE: "Copyright (c) 2020 Foo Author" },
+    );
+
+    const content = await extractLicenses(metafileOf({ "node_modules/foo/index.js": 10 }), rootDir);
+
+    expect(content).toContain("Package: foo@1.2.3");
+    expect(content).toContain("License: MIT");
+    expect(content).toContain("Copyright (c) 2020 Foo Author");
+  });
+
+  it("LICENSE 파일이 없으면 라이선스 식별자만 기록한다", async () => {
+    writePackage("node_modules/bar", { name: "bar", version: "0.1.0", license: "ISC" });
+
+    const content = await extractLicenses(metafileOf({ "node_modules/bar/index.js": 10 }), rootDir);
+
+    expect(content).toContain("Package: bar@0.1.0");
+    expect(content).toContain("License: ISC");
+  });
+
+  it("LICENSE.md 등 다른 파일명도 찾는다", async () => {
+    writePackage(
+      "node_modules/baz",
+      { name: "baz", version: "1.0.0", license: "MIT" },
+      { "LICENSE.md": "# License\nMIT text here" },
+    );
+
+    const content = await extractLicenses(metafileOf({ "node_modules/baz/index.js": 10 }), rootDir);
+
+    expect(content).toContain("MIT text here");
+  });
+
+  it("scope 가 있는 패키지도 기록한다", async () => {
+    writePackage("node_modules/@scope/pkg", {
+      name: "@scope/pkg",
+      version: "2.0.0",
+      license: "Apache-2.0",
+    });
+
+    const content = await extractLicenses(
+      metafileOf({ "node_modules/@scope/pkg/index.js": 10 }),
+      rootDir,
+    );
+
+    expect(content).toContain("Package: @scope/pkg@2.0.0");
+  });
+
+  it("같은 패키지의 여러 파일이 포함돼도 한 번만 기록한다", async () => {
+    writePackage("node_modules/foo", { name: "foo", version: "1.0.0", license: "MIT" });
+
+    const content = await extractLicenses(
+      metafileOf({
+        "node_modules/foo/index.js": 10,
+        "node_modules/foo/util.js": 20,
+        "node_modules/foo/deep/inner.js": 30,
+      }),
+      rootDir,
+    );
+
+    expect(content.match(/Package: foo@1\.0\.0/g)).toHaveLength(1);
+  });
+
+  it("산출물에 남지 않은 입력(bytesInOutput 0)은 제외한다", async () => {
+    writePackage("node_modules/used", { name: "used", version: "1.0.0", license: "MIT" });
+    writePackage("node_modules/shaken", { name: "shaken", version: "1.0.0", license: "MIT" });
+
+    const content = await extractLicenses(
+      metafileOf({
+        "node_modules/used/index.js": 10,
+        "node_modules/shaken/index.js": 0,
+      }),
+      rootDir,
+    );
+
+    expect(content).toContain("Package: used@1.0.0");
+    expect(content).not.toContain("Package: shaken@1.0.0");
+  });
+
+  it("node_modules 밖의 자체 소스는 제외한다", async () => {
+    const content = await extractLicenses(metafileOf({ "packages/app/src/main.ts": 100 }), rootDir);
+
+    expect(content).not.toContain("Package:");
+  });
+
+  it("SEE LICENSE IN 표기는 지정한 파일을 읽는다", async () => {
+    writePackage(
+      "node_modules/custom",
+      { name: "custom", version: "1.0.0", license: "SEE LICENSE IN TERMS.txt" },
+      { "TERMS.txt": "사내 전용 라이선스 조건" },
+    );
+
+    const content = await extractLicenses(
+      metafileOf({ "node_modules/custom/index.js": 10 }),
+      rootDir,
+    );
+
+    expect(content).toContain("사내 전용 라이선스 조건");
+  });
+
+  it("SEE LICENSE IN 이 가리키는 파일이 없으면 실패한다", async () => {
+    writePackage("node_modules/custom", {
+      name: "custom",
+      version: "1.0.0",
+      license: "SEE LICENSE IN MISSING.txt",
+    });
+
+    await expect(
+      extractLicenses(metafileOf({ "node_modules/custom/index.js": 10 }), rootDir),
+    ).rejects.toThrow("custom");
+  });
+
+  it("SEE LICENSE IN 이 패키지 바깥을 가리키면 실패한다", async () => {
+    writePackage("node_modules/escape", {
+      name: "escape",
+      version: "1.0.0",
+      license: "SEE LICENSE IN ../../secret.txt",
+    });
+
+    await expect(
+      extractLicenses(metafileOf({ "node_modules/escape/index.js": 10 }), rootDir),
+    ).rejects.toThrow("패키지 바깥");
+  });
+
+  it("라이선스를 알 수 없는 패키지가 있으면 실패하고 그 패키지를 알린다", async () => {
+    writePackage("node_modules/ok", { name: "ok", version: "1.0.0", license: "MIT" });
+    writePackage("node_modules/nolicense", { name: "nolicense", version: "3.1.4" });
+
+    await expect(
+      extractLicenses(
+        metafileOf({
+          "node_modules/ok/index.js": 10,
+          "node_modules/nolicense/index.js": 10,
+        }),
+        rootDir,
+      ),
+    ).rejects.toThrow("nolicense@3.1.4");
+  });
+
+  it("package.json 이 없는 node_modules 경로는 실패한다", async () => {
+    writePackage("node_modules/broken", undefined, { "index.js": "" });
+
+    await expect(
+      extractLicenses(metafileOf({ "node_modules/broken/index.js": 10 }), rootDir),
+    ).rejects.toThrow("패키지 정보를 찾을 수 없습니다");
+  });
+
+  it("패키지를 이름순으로 정렬해 기록한다", async () => {
+    writePackage("node_modules/zeta", { name: "zeta", version: "1.0.0", license: "MIT" });
+    writePackage("node_modules/alpha", { name: "alpha", version: "1.0.0", license: "MIT" });
+
+    const content = await extractLicenses(
+      metafileOf({
+        "node_modules/zeta/index.js": 10,
+        "node_modules/alpha/index.js": 10,
+      }),
+      rootDir,
+    );
+
+    expect(content.indexOf("Package: alpha")).toBeLessThan(content.indexOf("Package: zeta"));
+  });
+});