@simplysm/sd-cli 13.0.100 → 14.0.1

package/tests/utils/esbuild-config.spec.ts

@@ -0,0 +1,186 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "path";
+
+vi.mock("fs/promises", () => ({
+  default: {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+  },
+}));
+
+vi.mock("consola", () => ({
+  consola: {
+    withTag: vi.fn(() => ({
+      debug: vi.fn(),
+    })),
+  },
+}));
+
+const { createServerEsbuildOptions, writeChangedOutputFiles } =
+  await import("../../src/utils/esbuild-config");
+
+const { default: mockFs } = await import("fs/promises");
+
+describe("createServerEsbuildOptions", () => {
+  const baseOptions = {
+    pkgDir: "/pkg",
+    entryPoints: ["/pkg/src/index.ts"],
+  };
+
+  it("produces ESM bundle with platform=node and target=node20", () => {
+    const result = createServerEsbuildOptions(baseOptions);
+    expect(result.format).toBe("esm");
+    expect(result.bundle).toBe(true);
+    expect(result.platform).toBe("node");
+    expect(result.target).toBe("node20");
+  });
+
+  it("minifies by default (production build)", () => {
+    const result = createServerEsbuildOptions(baseOptions);
+    expect(result.minify).toBe(true);
+  });
+
+  it("skips minification when dev=true (watch mode)", () => {
+    const result = createServerEsbuildOptions({ ...baseOptions, dev: true });
+    expect(result.minify).toBe(false);
+  });
+
+  it("includes createRequire shim banner for CJS compatibility", () => {
+    const result = createServerEsbuildOptions(baseOptions);
+    expect(result.banner).toBeDefined();
+    expect((result.banner as Record<string, string>)["js"]).toContain("createRequire");
+    expect((result.banner as Record<string, string>)["js"]).toContain("import.meta.url");
+  });
+
+  it("substitutes env vars via define (process.env.KEY → constant)", () => {
+    const result = createServerEsbuildOptions({
+      ...baseOptions,
+      env: { API_URL: "https://api.example.com", NODE_ENV: "production" },
+    });
+    expect(result.define).toEqual({
+      "process.env.API_URL": '"https://api.example.com"',
+      "process.env.NODE_ENV": '"production"',
+    });
+  });
+
+  it("produces empty define when env is not provided", () => {
+    const result = createServerEsbuildOptions(baseOptions);
+    expect(result.define).toEqual({});
+  });
+
+  it("passes external modules to esbuild", () => {
+    const result = createServerEsbuildOptions({
+      ...baseOptions,
+      external: ["bcrypt", "sharp"],
+    });
+    expect(result.external).toEqual(["bcrypt", "sharp"]);
+  });
+
+  it("sets outdir to pkgDir/dist", () => {
+    const result = createServerEsbuildOptions(baseOptions);
+    expect(result.outdir).toBe(path.join("/pkg", "dist"));
+  });
+
+  it("sets tsconfig to pkgDir/tsconfig.json", () => {
+    const result = createServerEsbuildOptions(baseOptions);
+    expect(result.tsconfig).toBe(path.join("/pkg", "tsconfig.json"));
+  });
+});
+
+describe("writeChangedOutputFiles", () => {
+  beforeEach(() => {
+    vi.mocked(mockFs.readFile).mockReset();
+    vi.mocked(mockFs.writeFile).mockReset();
+    vi.mocked(mockFs.mkdir).mockReset();
+    vi.mocked(mockFs.mkdir).mockResolvedValue(undefined as any);
+    vi.mocked(mockFs.writeFile).mockResolvedValue();
+  });
+
+  it("adds .js extension to relative import paths in .js files", async () => {
+    vi.mocked(mockFs.readFile).mockRejectedValue(new Error("not found"));
+
+    await writeChangedOutputFiles([
+      {
+        path: "/pkg/dist/foo.js",
+        text: 'import { bar } from "./bar";\nexport { baz } from "../utils/baz";',
+      },
+    ] as any);
+
+    expect(mockFs.writeFile).toHaveBeenCalledWith(
+      "/pkg/dist/foo.js",
+      'import { bar } from "./bar.js";\nexport { baz } from "../utils/baz.js";',
+    );
+  });
+
+  it("preserves imports that already have extensions", async () => {
+    vi.mocked(mockFs.readFile).mockRejectedValue(new Error("not found"));
+
+    await writeChangedOutputFiles([
+      {
+        path: "/pkg/dist/foo.js",
+        text: 'import data from "./data.json";\nimport styles from "./styles.css";\nimport mod from "./native.node";',
+      },
+    ] as any);
+
+    expect(mockFs.writeFile).toHaveBeenCalledWith(
+      "/pkg/dist/foo.js",
+      'import data from "./data.json";\nimport styles from "./styles.css";\nimport mod from "./native.node";',
+    );
+  });
+
+  it("skips writing when transformed content matches existing file", async () => {
+    vi.mocked(mockFs.readFile).mockResolvedValue('import { bar } from "./bar.js";' as any);
+
+    const hasChanges = await writeChangedOutputFiles([
+      {
+        path: "/pkg/dist/foo.js",
+        text: 'import { bar } from "./bar";',
+      },
+    ] as any);
+
+    expect(mockFs.writeFile).not.toHaveBeenCalled();
+    expect(hasChanges).toBe(false);
+  });
+
+  it("writes file and returns true when content changed", async () => {
+    vi.mocked(mockFs.readFile).mockResolvedValue('import { old } from "./old.js";' as any);
+
+    const hasChanges = await writeChangedOutputFiles([
+      {
+        path: "/pkg/dist/foo.js",
+        text: 'import { bar } from "./bar";',
+      },
+    ] as any);
+
+    expect(mockFs.writeFile).toHaveBeenCalled();
+    expect(hasChanges).toBe(true);
+  });
+
+  it("writes new file when existing file does not exist", async () => {
+    vi.mocked(mockFs.readFile).mockRejectedValue(new Error("ENOENT"));
+
+    const hasChanges = await writeChangedOutputFiles([
+      {
+        path: "/pkg/dist/foo.js",
+        text: 'const x = 1;',
+      },
+    ] as any);
+
+    expect(mockFs.mkdir).toHaveBeenCalledWith(path.dirname("/pkg/dist/foo.js"), { recursive: true });
+    expect(mockFs.writeFile).toHaveBeenCalledWith("/pkg/dist/foo.js", "const x = 1;");
+    expect(hasChanges).toBe(true);
+  });
+
+  it("does not transform non-.js files", async () => {
+    vi.mocked(mockFs.readFile).mockRejectedValue(new Error("not found"));
+
+    const mapContent = '{"version":3,"sources":["./bar"]}';
+    await writeChangedOutputFiles([
+      { path: "/pkg/dist/foo.js.map", text: mapContent },
+    ] as any);
+
+    expect(mockFs.writeFile).toHaveBeenCalledWith("/pkg/dist/foo.js.map", mapContent);
+  });
+});
+

package/tests/utils/external-modules.spec.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "path";
+
+// Mock fs (readFileSync, existsSync)
+const mockReadFileSync = vi.fn();
+const mockExistsSync = vi.fn();
+
+vi.mock("fs", () => ({
+  readFileSync: (...args: any[]) => mockReadFileSync(...args),
+  existsSync: (...args: any[]) => mockExistsSync(...args),
+}));
+
+// Mock createRequire to control module resolution
+const mockResolve = vi.fn();
+vi.mock("module", () => ({
+  createRequire: vi.fn(() => ({
+    resolve: mockResolve,
+  })),
+}));
+
+vi.mock("consola", () => ({
+  consola: {
+    withTag: vi.fn(() => ({
+      debug: vi.fn(),
+    })),
+  },
+}));
+
+const { collectUninstalledOptionalPeerDeps, collectNativeModuleExternals } =
+  await import("../../src/utils/esbuild-config");
+
+describe("collectUninstalledOptionalPeerDeps", () => {
+  beforeEach(() => {
+    mockReadFileSync.mockReset();
+    mockResolve.mockReset();
+  });
+
+  it("detects uninstalled optional peer dependencies", () => {
+    // Root package.json with one dependency
+    mockReadFileSync.mockImplementation((filePath: string) => {
+      if (filePath === path.join("/pkg", "package.json")) {
+        return JSON.stringify({ dependencies: { "some-lib": "^1.0.0" } });
+      }
+      // some-lib's package.json with optional peer dep
+      return JSON.stringify({
+        peerDependencies: { "optional-peer": "^2.0.0" },
+        peerDependenciesMeta: { "optional-peer": { optional: true } },
+      });
+    });
+
+    // Resolving some-lib/package.json succeeds
+    mockResolve.mockImplementation((name: string) => {
+      if (name === "some-lib/package.json") {
+        return "/node_modules/some-lib/package.json";
+      }
+      // optional-peer cannot be resolved (not installed)
+      throw new Error("MODULE_NOT_FOUND");
+    });
+
+    const result = collectUninstalledOptionalPeerDeps("/pkg");
+    expect(result).toContain("optional-peer");
+  });
+
+  it("does not include installed optional peer dependencies", () => {
+    mockReadFileSync.mockImplementation((filePath: string) => {
+      if (filePath === path.join("/pkg", "package.json")) {
+        return JSON.stringify({ dependencies: { "some-lib": "^1.0.0" } });
+      }
+      return JSON.stringify({
+        peerDependencies: { "installed-peer": "^2.0.0" },
+        peerDependenciesMeta: { "installed-peer": { optional: true } },
+      });
+    });
+
+    mockResolve.mockImplementation((name: string) => {
+      if (name === "some-lib/package.json") {
+        return "/node_modules/some-lib/package.json";
+      }
+      // installed-peer resolves successfully
+      if (name === "installed-peer") {
+        return "/node_modules/installed-peer/index.js";
+      }
+      throw new Error("MODULE_NOT_FOUND");
+    });
+
+    const result = collectUninstalledOptionalPeerDeps("/pkg");
+    expect(result).not.toContain("installed-peer");
+  });
+
+  it("returns empty array when no optional peer deps exist", () => {
+    mockReadFileSync.mockImplementation((filePath: string) => {
+      if (filePath === path.join("/pkg", "package.json")) {
+        return JSON.stringify({ dependencies: { "some-lib": "^1.0.0" } });
+      }
+      return JSON.stringify({ dependencies: {} });
+    });
+
+    mockResolve.mockImplementation((name: string) => {
+      if (name === "some-lib/package.json") {
+        return "/node_modules/some-lib/package.json";
+      }
+      throw new Error("MODULE_NOT_FOUND");
+    });
+
+    const result = collectUninstalledOptionalPeerDeps("/pkg");
+    expect(result).toEqual([]);
+  });
+});
+
+describe("collectNativeModuleExternals", () => {
+  beforeEach(() => {
+    mockReadFileSync.mockReset();
+    mockExistsSync.mockReset();
+    mockResolve.mockReset();
+  });
+
+  it("detects native modules with binding.gyp", () => {
+    mockReadFileSync.mockImplementation((filePath: string) => {
+      if (filePath === path.join("/pkg", "package.json")) {
+        return JSON.stringify({ dependencies: { bcrypt: "^5.0.0" } });
+      }
+      return JSON.stringify({ dependencies: {} });
+    });
+
+    mockResolve.mockImplementation((name: string) => {
+      if (name === "bcrypt/package.json") {
+        return "/node_modules/bcrypt/package.json";
+      }
+      throw new Error("MODULE_NOT_FOUND");
+    });
+
+    mockExistsSync.mockImplementation((filePath: string) => {
+      return filePath === path.join("/node_modules/bcrypt", "binding.gyp");
+    });
+
+    const result = collectNativeModuleExternals("/pkg");
+    expect(result).toContain("bcrypt");
+  });
+
+  it("does not include non-native modules", () => {
+    mockReadFileSync.mockImplementation((filePath: string) => {
+      if (filePath === path.join("/pkg", "package.json")) {
+        return JSON.stringify({ dependencies: { lodash: "^4.0.0" } });
+      }
+      return JSON.stringify({ dependencies: {} });
+    });
+
+    mockResolve.mockImplementation((name: string) => {
+      if (name === "lodash/package.json") {
+        return "/node_modules/lodash/package.json";
+      }
+      throw new Error("MODULE_NOT_FOUND");
+    });
+
+    mockExistsSync.mockReturnValue(false);
+
+    const result = collectNativeModuleExternals("/pkg");
+    expect(result).not.toContain("lodash");
+    expect(result).toEqual([]);
+  });
+});

package/tests/utils/ngtsc-scss-refactor.spec.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { resolve, join } from "node:path";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../../..");
+const angularPkgDir = resolve(workspaceRoot, "packages/angular");
+
+// Scenario 1: loadPaths 헬퍼가 동일한 경로를 반환한다
+describe("buildScssLoadPaths", () => {
+  it("returns [pkgDir/scss, cwd/node_modules] for given NgtscBuildInfo", async () => {
+    const { buildScssLoadPaths } = await import("../../src/utils/ngtsc-build-core");
+
+    const info = {
+      name: "angular",
+      cwd: workspaceRoot,
+      pkgDir: angularPkgDir,
+      output: { js: true, dts: false },
+    };
+
+    const result = buildScssLoadPaths(info);
+
+    expect(result).toEqual([
+      join(angularPkgDir, "scss"),
+      join(workspaceRoot, "node_modules"),
+    ]);
+  });
+
+  // Unit: different cwd produces different node_modules path
+  it("uses cwd from info to construct node_modules path", async () => {
+    const { buildScssLoadPaths } = await import("../../src/utils/ngtsc-build-core");
+
+    const customCwd = "/custom/workspace";
+    const customPkgDir = "/custom/workspace/packages/my-pkg";
+
+    const result = buildScssLoadPaths({
+      name: "test",
+      cwd: customCwd,
+      pkgDir: customPkgDir,
+      output: { js: true, dts: false },
+    });
+
+    expect(result).toEqual([
+      join(customPkgDir, "scss"),
+      join(customCwd, "node_modules"),
+    ]);
+  });
+});
+
+// Scenario 2: createNgtscProgramWithHost와 compileGlobalScss가 동일한 loadPaths를 사용한다
+// This is verified by the fact that both call buildScssLoadPaths(info) — tested via
+// running a real build and confirming success (the inline SCSS and global SCSS both resolve).
+describe("runNgtscBuild loadPaths consistency", () => {
+  it("uses the same loadPaths for transformResource and compileGlobalScss", async () => {
+    const { runNgtscBuild } = await import("../../src/utils/ngtsc-build-core");
+
+    const result = await runNgtscBuild({
+      name: "angular",
+      cwd: workspaceRoot,
+      pkgDir: angularPkgDir,
+      output: { js: true, dts: false },
+    });
+
+    // If loadPaths were inconsistent, SCSS compilation would fail
+    expect(result.dts.success).toBe(true);
+    expect(result.dts.errors).toBeUndefined();
+  }, 60_000);
+});

package/tests/utils/output-path-rewriter.spec.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect } from "vitest";
+import path from "path";
+import { createOutputPathRewriter, adjustMapSources, addJsExtensionToImports } from "../../src/utils/output-path-rewriter";
+
+// Use path.resolve to get platform-correct absolute paths
+const pkgDir = path.resolve("/workspace/packages/my-pkg");
+const distDir = path.resolve(pkgDir, "dist");
+
+describe("createOutputPathRewriter", () => {
+  const rewrite = createOutputPathRewriter(pkgDir);
+
+  it("rewrites own nested .d.ts to flat structure", () => {
+    const nestedPath = path.resolve(distDir, "my-pkg", "src", "index.d.ts");
+    const result = rewrite(nestedPath, "declare const x: number;");
+
+    expect(result).not.toBeNull();
+    expect(result![0]).toBe(path.join(distDir, "index.d.ts"));
+    expect(result![1]).toBe("declare const x: number;");
+  });
+
+  it("rewrites own nested subdirectory .d.ts to flat structure", () => {
+    const nestedPath = path.resolve(distDir, "my-pkg", "src", "utils", "helper.d.ts");
+    const result = rewrite(nestedPath, "declare const y: string;");
+
+    expect(result).not.toBeNull();
+    expect(result![0]).toBe(path.join(distDir, "utils", "helper.d.ts"));
+  });
+
+  it("returns null for other packages' nested .d.ts", () => {
+    const otherPkgPath = path.resolve(distDir, "other-pkg", "src", "index.d.ts");
+    const result = rewrite(otherPkgPath, "");
+
+    expect(result).toBeNull();
+  });
+
+  it("passes through already flat .d.ts as-is", () => {
+    const flatPath = path.resolve(distDir, "index.d.ts");
+    const result = rewrite(flatPath, "declare const z: boolean;");
+
+    expect(result).not.toBeNull();
+    expect(result![0]).toBe(flatPath);
+    expect(result![1]).toBe("declare const z: boolean;");
+  });
+
+  it("returns null for files outside dist/", () => {
+    const outsidePath = path.resolve(pkgDir, "src", "index.ts");
+    const result = rewrite(outsidePath, "");
+
+    expect(result).toBeNull();
+  });
+
+  it("adjusts .d.ts.map sources when rewriting nested to flat", () => {
+    const nestedPath = path.resolve(distDir, "my-pkg", "src", "index.d.ts.map");
+    const mapContent = JSON.stringify({ version: 3, sources: ["../../../../src/index.ts"] });
+    const result = rewrite(nestedPath, mapContent);
+
+    expect(result).not.toBeNull();
+    expect(result![0]).toBe(path.join(distDir, "index.d.ts.map"));
+    // Sources path should be adjusted for the new location
+    const parsedMap = JSON.parse(result![1]) as { sources: string[] };
+    expect(parsedMap.sources).toBeDefined();
+    expect(parsedMap.sources.length).toBe(1);
+  });
+});
+
+describe("adjustMapSources", () => {
+  it("returns content as-is when directories are the same", () => {
+    const content = JSON.stringify({ version: 3, sources: ["./foo.ts"] });
+    const result = adjustMapSources(content, "/a/b", "/a/b");
+    expect(result).toBe(content);
+  });
+
+  it("adjusts sources relative paths when directory changes", () => {
+    const original = path.resolve("/workspace/packages/my-pkg/dist/my-pkg/src");
+    const target = path.resolve("/workspace/packages/my-pkg/dist");
+    const content = JSON.stringify({
+      version: 3,
+      sources: [path.join("..", "..", "..", "src", "index.ts")],
+    });
+
+    const result = adjustMapSources(content, original, target);
+    const parsed = JSON.parse(result) as { sources: string[] };
+
+    // The absolute source should be the same, just the relative path changes
+    const absoluteFromOriginal = path.resolve(original, "..", "..", "..", "src", "index.ts");
+    const expectedRelative = path.relative(target, absoluteFromOriginal);
+    expect(parsed.sources[0]).toBe(expectedRelative);
+  });
+
+  it("returns content as-is for invalid JSON", () => {
+    const result = adjustMapSources("not json", "/a", "/b");
+    expect(result).toBe("not json");
+  });
+
+  it("handles content without sources array", () => {
+    const content = JSON.stringify({ version: 3 });
+    const result = adjustMapSources(content, "/a", "/b");
+    expect(JSON.parse(result)).toEqual({ version: 3 });
+  });
+});
+
+// Acceptance: Scenario "확장자 없는 상대 import에 .js 추가"
+// Acceptance: Scenario "이미 확장자가 있는 import는 변경하지 않는다"
+// Acceptance: Scenario "bare specifier는 변경하지 않는다"
+// Acceptance: Scenario "dynamic import에도 .js 추가"
+describe("addJsExtensionToImports", () => {
+  it("adds .js to extensionless relative import", () => {
+    const input = 'import { foo } from "./utils";';
+    expect(addJsExtensionToImports(input)).toBe('import { foo } from "./utils.js";');
+  });
+
+  it("adds .js to parent directory relative import", () => {
+    const input = 'import { bar } from "../types";';
+    expect(addJsExtensionToImports(input)).toBe('import { bar } from "../types.js";');
+  });
+
+  it("adds .js to dynamic import", () => {
+    const input = 'const m = import("./lazy");';
+    expect(addJsExtensionToImports(input)).toBe('const m = import("./lazy.js");');
+  });
+
+  it("does not modify import already ending with .js", () => {
+    const input = 'import { x } from "./already.js";';
+    expect(addJsExtensionToImports(input)).toBe(input);
+  });
+
+  it("does not modify import ending with .json", () => {
+    const input = 'import data from "./data.json";';
+    expect(addJsExtensionToImports(input)).toBe(input);
+  });
+
+  it("does not modify import ending with .css", () => {
+    const input = 'import "./styles.css";';
+    expect(addJsExtensionToImports(input)).toBe(input);
+  });
+
+  it("does not modify bare specifier", () => {
+    const input = 'import { z } from "lodash-es";';
+    expect(addJsExtensionToImports(input)).toBe(input);
+  });
+
+  it("does not modify scoped package specifier", () => {
+    const input = 'import { a } from "@simplysm/core-common";';
+    expect(addJsExtensionToImports(input)).toBe(input);
+  });
+
+  it("handles multiple imports in same text", () => {
+    const input = [
+      'import { a } from "./foo";',
+      'import { b } from "lodash";',
+      'import { c } from "../bar";',
+    ].join("\n");
+    const expected = [
+      'import { a } from "./foo.js";',
+      'import { b } from "lodash";',
+      'import { c } from "../bar.js";',
+    ].join("\n");
+    expect(addJsExtensionToImports(input)).toBe(expected);
+  });
+
+  it("handles re-export from relative path", () => {
+    const input = 'export { x } from "./module";';
+    expect(addJsExtensionToImports(input)).toBe('export { x } from "./module.js";');
+  });
+});

package/tests/utils/output-utils.spec.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { formatBuildMessages, printErrors, printServers } from "../../src/utils/output-utils";
+import type { BuildResult } from "../../src/infra/ResultCollector";
+
+vi.mock("consola", () => ({
+  consola: {
+    error: vi.fn(),
+    info: vi.fn(),
+  },
+}));
+
+ 
+const { consola } = await import("consola");
+
+describe("formatBuildMessages", () => {
+  it("formats name, label, and messages into indented lines", () => {
+    const result = formatBuildMessages("core", "node", ["error in file.ts"]);
+    expect(result).toBe("core (node)\n  → error in file.ts");
+  });
+
+  it("splits multiline messages into separate indented lines", () => {
+    const result = formatBuildMessages("core", "node", ["line1\nline2"]);
+    expect(result).toContain("→ line1");
+    expect(result).toContain("→ line2");
+  });
+
+  it("handles multiple messages", () => {
+    const result = formatBuildMessages("core", "dts", ["err1", "err2"]);
+    expect(result).toContain("core (dts)");
+    expect(result).toContain("→ err1");
+    expect(result).toContain("→ err2");
+  });
+});
+
+describe("printErrors", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("prints error results with message", () => {
+    const results = new Map<string, BuildResult>([
+      ["core:build", { name: "core", target: "node", type: "build", status: "error", message: "failed" }],
+    ]);
+    printErrors(results);
+    expect(consola.error).toHaveBeenCalledOnce();
+  });
+
+  it("prints error results without message", () => {
+    const results = new Map<string, BuildResult>([
+      ["core:build", { name: "core", target: "node", type: "build", status: "error" }],
+    ]);
+    printErrors(results);
+    expect(consola.error).toHaveBeenCalledOnce();
+  });
+
+  it("uses 'dts' as label for dts type errors", () => {
+    const results = new Map<string, BuildResult>([
+      ["core:dts", { name: "core", target: "node", type: "dts", status: "error", message: "type error" }],
+    ]);
+    printErrors(results);
+    const callArg = vi.mocked(consola.error).mock.calls[0][0] as string;
+    expect(callArg).toContain("dts");
+  });
+
+  it("skips non-error results", () => {
+    const results = new Map<string, BuildResult>([
+      ["core:build", { name: "core", target: "node", type: "build", status: "success" }],
+    ]);
+    printErrors(results);
+    expect(consola.error).not.toHaveBeenCalled();
+  });
+});
+
+describe("printServers", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+  });
+
+  it("prints server URL with port", () => {
+    const results = new Map<string, BuildResult>([
+      ["app:server", { name: "app", target: "server", type: "server", status: "running", port: 3000 }],
+    ]);
+    printServers(results);
+    expect(consola.info).toHaveBeenCalledWith(expect.stringContaining("http://localhost:3000/"));
+  });
+
+  it("prints client URLs when server has connected clients", () => {
+    const results = new Map<string, BuildResult>([
+      ["app:server", { name: "app", target: "server", type: "server", status: "running", port: 3000 }],
+    ]);
+    const clientsMap = new Map([["app", ["client-a"]]]);
+    printServers(results, clientsMap);
+    expect(consola.info).toHaveBeenCalledWith(expect.stringContaining("http://localhost:3000/client-a/"));
+  });
+
+  it("does not print when no running servers", () => {
+    const results = new Map<string, BuildResult>([
+      ["core:build", { name: "core", target: "node", type: "build", status: "success" }],
+    ]);
+    printServers(results);
+    expect(consola.info).not.toHaveBeenCalled();
+  });
+});