@simplysm/sd-cli 14.0.97 → 14.0.99

package/src/commands/init/ts-ast.ts

@@ -0,0 +1,48 @@
+import ts from "typescript";
+
+/** sd.config.ts 의 `packages` 객체 리터럴 탐색 */
+export function findPackagesObject(sf: ts.SourceFile): ts.ObjectLiteralExpression | undefined {
+  let found: ts.ObjectLiteralExpression | undefined;
+  const visit = (node: ts.Node): void => {
+    if (found != null) return;
+    if (
+      ts.isPropertyAssignment(node) &&
+      getPropertyName(node.name) === "packages" &&
+      ts.isObjectLiteralExpression(node.initializer)
+    ) {
+      found = node.initializer;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return found;
+}
+
+export function getPropertyName(propName: ts.PropertyName): string | undefined {
+  if (ts.isIdentifier(propName) || ts.isStringLiteral(propName)) return propName.text;
+  return undefined;
+}
+
+export function getProp(
+  obj: ts.ObjectLiteralExpression,
+  key: string,
+): ts.Expression | undefined {
+  for (const p of obj.properties) {
+    if (ts.isPropertyAssignment(p) && getPropertyName(p.name) === key) return p.initializer;
+  }
+  return undefined;
+}
+
+export function getObjectProp(
+  obj: ts.ObjectLiteralExpression,
+  key: string,
+): ts.ObjectLiteralExpression | undefined {
+  const expr = getProp(obj, key);
+  return expr != null && ts.isObjectLiteralExpression(expr) ? expr : undefined;
+}
+
+export function getStringProp(obj: ts.ObjectLiteralExpression, key: string): string | undefined {
+  const expr = getProp(obj, key);
+  return expr != null && ts.isStringLiteral(expr) ? expr.text : undefined;
+}

package/src/commands/init/types.ts

@@ -32,6 +32,8 @@ export interface ClientSpec {
   appStructureName: string;
   needsNgIcons: boolean;
   useSsg: boolean;
+  /** robots.txt 지시문 — SSG(SEO) 클라이언트는 전체 허용, 그 외는 전체 차단 */
+  robotsDirective: string;
 }
 
 export interface NormalizedInput {

package/src/commands/init/validate.ts

@@ -1,5 +1,6 @@
+import path from "path";
 import { fsx } from "@simplysm/core-node";
-import type { InitInput } from "./types";
+import type { ClientInputSpec, InitInput } from "./types";
 
 const KEBAB_CASE_RE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 
@@ -46,3 +47,25 @@ export function validateInput(input: InitInput): void {
     clientNames.add(normalized);
   }
 }
+
+/** init client — 신규 클라이언트가 기존 워크스페이스와 충돌하지 않는지 검증 */
+export async function validateInitClientInput(
+  cwd: string,
+  newClient: ClientInputSpec,
+  existingClients: ClientInputSpec[],
+): Promise<void> {
+  if (!KEBAB_CASE_RE.test(newClient.name)) {
+    throw new Error(`client 이름은 영문 kebab-case 여야 합니다. 입력값: "${newClient.name}"`);
+  }
+
+  const toNormalized = (clientName: string): string =>
+    clientName.startsWith("client-") ? clientName : `client-${clientName}`;
+  const normalized = toNormalized(newClient.name);
+  if (existingClients.some((c) => toNormalized(c.name) === normalized)) {
+    throw new Error(`이미 존재하는 client 입니다: "${normalized}"`);
+  }
+
+  if (await fsx.exists(path.resolve(cwd, "packages", normalized))) {
+    throw new Error(`이미 존재하는 패키지 디렉토리입니다: packages/${normalized}`);
+  }
+}

package/src/esbuild/esbuild-client-config.ts

@@ -175,6 +175,23 @@ export async function createClientEsbuildContext(
     entryNames: isDev ? "[name]" : "[name]-[hash]",
     chunkNames: "[name]-[hash]",
     assetNames: isDev ? "[name]" : "[name]-[hash]",
+    // CSS/SCSS url() 로 참조하는 폰트·이미지 자산을 outdir로 복사하고 url을 출력 경로로 재작성.
+    // esbuild 기본 loader 맵에는 js/ts/css/json/text만 있어, 미설정 시 url(*.woff) 등에서
+    // "No loader is configured" 에러가 발생한다.
+    loader: {
+      ".woff": "file",
+      ".woff2": "file",
+      ".ttf": "file",
+      ".eot": "file",
+      ".otf": "file",
+      ".svg": "file",
+      ".png": "file",
+      ".jpg": "file",
+      ".jpeg": "file",
+      ".gif": "file",
+      ".webp": "file",
+      ".ico": "file",
+    },
     bundle: true,
     splitting: options.legacyModule !== true,
     format: "esm",

package/src/sd-cli-entry.ts

@@ -10,6 +10,7 @@ import { runWatch } from "./commands/watch";
 import { runDev } from "./commands/dev";
 import { runBuild } from "./commands/build";
 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 path from "path";
@@ -333,11 +334,23 @@ export function createCliParser(argv: string[]): Argv {
       },
     )
     .command(
-      "init",
-      "Bootstrap a new SI workspace via interactive prompts",
-      (cmd) => cmd.version(false).hide("help"),
-      async () => {
-        await runInit({ cwd: process.cwd() });
+      "init [kind]",
+      "Bootstrap a new SI workspace via interactive prompts (kind=client: add a client package to an existing workspace)",
+      (cmd) =>
+        cmd
+          .version(false)
+          .hide("help")
+          .positional("kind", {
+            describe: "init 대상 (생략: 새 워크스페이스 부트스트랩)",
+            type: "string",
+            choices: ["client"] as const,
+          }),
+      async (args) => {
+        if (args.kind === "client") {
+          await runInitClient({ cwd: process.cwd() });
+        } else {
+          await runInit({ cwd: process.cwd() });
+        }
       },
     )
     .demandCommand(1, "Please specify a command.")

package/tests/init/patch.spec.ts

@@ -0,0 +1,222 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { normalize } from "../../src/commands/init/normalize";
+import {
+  patchAppStructure,
+  patchDevService,
+  patchRootPackageJson,
+  patchSdConfig,
+  patchVitestConfig,
+} from "../../src/commands/init/patch";
+import { renderTemplate } from "../../src/commands/init/render";
+import type { ClientInputSpec, InitInput, RenderData } from "../../src/commands/init/types";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TPL_ROOT = path.resolve(__dirname, "../../src/commands/init/templates");
+
+function buildData(input: InitInput): RenderData {
+  return { ...normalize(input), jwtSecret: "test-jwt-secret" };
+}
+
+const baseInput: InitInput = {
+  workspaceName: "demo",
+  description: "Demo Workspace",
+  hasServer: true,
+  hasDb: true,
+  dbDialect: "mysql",
+  dbContextName: "main",
+  hasAuth: true,
+  userEntityName: "user",
+  userEntityLabel: "사용자",
+  clients: [{ name: "admin", type: "web", hasRouter: true }],
+  serverPort: 40080,
+};
+
+/** before: 기존 클라이언트만 / after: 신규 클라이언트 포함 — 라운드트립 동등성 기준 데이터 쌍 */
+function buildPair(
+  newClient: ClientInputSpec,
+  inputOverride?: Partial<InitInput>,
+): { before: RenderData; after: RenderData; client: RenderData["clients"][number] } {
+  const input = { ...baseInput, ...inputOverride };
+  const before = buildData(input);
+  const after = buildData({ ...input, clients: [...input.clients, newClient] });
+  const client = after.clients[after.clients.length - 1];
+  return { before, after, client };
+}
+
+describe("patchSdConfig", () => {
+  it("web 클라이언트 추가 — init 동등 결과", async () => {
+    const { before, after, client } = buildPair({ name: "portal", type: "web", hasRouter: true });
+    const tplPath = path.join(TPL_ROOT, "workspace-root/sd.config.ts.hbs");
+    const source = await renderTemplate(tplPath, before);
+    const expected = await renderTemplate(tplPath, after);
+
+    const r = patchSdConfig(source, after, client);
+
+    expect(r.patched).toBe(expected);
+  });
+
+  it("mobile 클라이언트 추가 (appId 포함) — init 동등 결과", async () => {
+    const { before, after, client } = buildPair(
+      { name: "pda", type: "mobile", hasRouter: false },
+      { mobileAppId: "kr.co.demo.app" },
+    );
+    const tplPath = path.join(TPL_ROOT, "workspace-root/sd.config.ts.hbs");
+    const source = await renderTemplate(tplPath, before);
+    const expected = await renderTemplate(tplPath, after);
+
+    const r = patchSdConfig(source, after, client);
+
+    expect(r.patched).toBe(expected);
+  });
+
+  it("SSG 클라이언트 추가 — prerender 포함", async () => {
+    const { before, after, client } = buildPair({
+      name: "www",
+      type: "web",
+      hasRouter: true,
+      useSsg: true,
+    });
+    const tplPath = path.join(TPL_ROOT, "workspace-root/sd.config.ts.hbs");
+    const source = await renderTemplate(tplPath, before);
+    const expected = await renderTemplate(tplPath, after);
+
+    const r = patchSdConfig(source, after, client);
+
+    expect(r.patched).toBe(expected);
+  });
+
+  it("packages 정의를 찾을 수 없으면 패치 실패 + 스니펫 제공", () => {
+    const { after, client } = buildPair({ name: "portal", type: "web", hasRouter: true });
+
+    const r = patchSdConfig("export default {};\n", after, client);
+
+    expect(r.patched).toBeUndefined();
+    expect(r.snippet).toContain('"client-portal"');
+  });
+});
+
+describe("patchVitestConfig", () => {
+  it("클라이언트 project 추가 — init 동등 결과", async () => {
+    const { before, after, client } = buildPair({ name: "portal", type: "web", hasRouter: true });
+    const tplPath = path.join(TPL_ROOT, "workspace-root/vitest.config.ts.hbs");
+    const source = await renderTemplate(tplPath, before);
+    const expected = await renderTemplate(tplPath, after);
+
+    const r = patchVitestConfig(source, client);
+
+    expect(r.patched).toBe(expected);
+  });
+
+  it("projects 배열을 찾을 수 없으면 패치 실패 + 스니펫 제공", () => {
+    const { client } = buildPair({ name: "portal", type: "web", hasRouter: true });
+
+    const r = patchVitestConfig("export default {};\n", client);
+
+    expect(r.patched).toBeUndefined();
+    expect(r.snippet).toContain("client-portal");
+  });
+});
+
+describe("patchRootPackageJson", () => {
+  it("첫 mobile 클라이언트 — run-device 스크립트 추가, init 동등 결과", async () => {
+    const { before, after, client } = buildPair(
+      { name: "pda", type: "mobile", hasRouter: false },
+      { mobileAppId: "kr.co.demo.app" },
+    );
+    const tplPath = path.join(TPL_ROOT, "workspace-root/package.json.hbs");
+    const source = await renderTemplate(tplPath, before);
+    const expected = await renderTemplate(tplPath, after);
+
+    const r = patchRootPackageJson(source, client);
+
+    expect(r.patched).toBe(expected);
+  });
+
+  it("scripts 앵커를 찾을 수 없으면 패치 실패 + 스니펫 제공", () => {
+    const { client } = buildPair(
+      { name: "pda", type: "mobile", hasRouter: false },
+      { mobileAppId: "kr.co.demo.app" },
+    );
+
+    const r = patchRootPackageJson("{}", client);
+
+    expect(r.patched).toBeUndefined();
+    expect(r.snippet).toContain("run-device");
+  });
+});
+
+describe("patchAppStructure", () => {
+  it("라우팅 클라이언트 추가 — export 블록 추가, init 동등 결과", async () => {
+    const { before, after, client } = buildPair({ name: "portal", type: "web", hasRouter: true });
+    const tplPath = path.join(TPL_ROOT, "common/src/app-structure.ts.hbs");
+    const source = await renderTemplate(tplPath, before);
+    const expected = await renderTemplate(tplPath, after);
+
+    const r = patchAppStructure(source, after, client);
+
+    expect(r.patched).toBe(expected);
+  });
+});
+
+describe("patchDevService", () => {
+  const tplPath = path.join(TPL_ROOT, "server/src/services/dev.service.ts.hbs");
+
+  it("1개 → 2개 — import 추가 + 권한 평탄화 인자가 배열 결합으로 교체", async () => {
+    const { before, after, client } = buildPair({ name: "portal", type: "web", hasRouter: true });
+    const source = await renderTemplate(tplPath, before);
+    const expected = await renderTemplate(tplPath, after);
+
+    const r = patchDevService(source, before.appStructureNames, after, client);
+
+    expect(r.patched).toBe(expected);
+  });
+
+  it("2개 → 3개 — 기존 배열 결합에 원소 추가", async () => {
+    const twoClients: InitInput = {
+      ...baseInput,
+      clients: [
+        { name: "admin", type: "web", hasRouter: true },
+        { name: "portal", type: "web", hasRouter: true },
+      ],
+    };
+    const before = buildData(twoClients);
+    const after = buildData({
+      ...twoClients,
+      clients: [...twoClients.clients, { name: "shop", type: "web", hasRouter: true }],
+    });
+    const client = after.clients[after.clients.length - 1];
+    const source = await renderTemplate(tplPath, before);
+    const expected = await renderTemplate(tplPath, after);
+
+    const r = patchDevService(source, before.appStructureNames, after, client);
+
+    expect(r.patched).toBe(expected);
+  });
+
+  it("0개 → 1개 (기본 export 워크스페이스) — import·권한 인자가 신규 단독으로 대체, init 동등 결과", async () => {
+    const serverOnly: InitInput = { ...baseInput, clients: [] };
+    const before = buildData(serverOnly); // appStructureNames = ["appStructureItems"]
+    const after = buildData({
+      ...serverOnly,
+      clients: [{ name: "portal", type: "web", hasRouter: true }],
+    });
+    const client = after.clients[after.clients.length - 1];
+    const source = await renderTemplate(tplPath, before);
+    const expected = await renderTemplate(tplPath, after);
+
+    const r = patchDevService(source, [], after, client, "appStructureItems");
+
+    expect(r.patched).toBe(expected);
+  });
+
+  it("import 앵커를 찾을 수 없으면 패치 실패 + 스니펫 제공", () => {
+    const { before, after, client } = buildPair({ name: "portal", type: "web", hasRouter: true });
+
+    const r = patchDevService("export const x = 1;\n", before.appStructureNames, after, client);
+
+    expect(r.patched).toBeUndefined();
+    expect(r.snippet).toContain(client.appStructureName);
+  });
+});

package/tests/init/recover.spec.ts

@@ -0,0 +1,236 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+import { normalize } from "../../src/commands/init/normalize";
+import { recoverWorkspace } from "../../src/commands/init/recover";
+import { renderTemplate } from "../../src/commands/init/render";
+import type { InitInput, RenderData } from "../../src/commands/init/types";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TPL_ROOT = path.resolve(__dirname, "../../src/commands/init/templates");
+
+function buildData(input: InitInput): RenderData {
+  return { ...normalize(input), jwtSecret: "test-jwt-secret" };
+}
+
+const tmpDirs: string[] = [];
+
+async function createTmpDir(): Promise<string> {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "sd-init-recover-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+afterEach(async () => {
+  for (const dir of tmpDirs.splice(0)) {
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+});
+
+/** init 템플릿 렌더로 recover 가 읽는 파일들만 기존 워크스페이스 형태로 구성 */
+async function buildWorkspace(input: InitInput): Promise<string> {
+  const cwd = await createTmpDir();
+  const data = buildData(input);
+
+  await fs.writeFile(
+    path.join(cwd, "package.json"),
+    await renderTemplate(path.join(TPL_ROOT, "workspace-root/package.json.hbs"), data),
+  );
+  await fs.writeFile(
+    path.join(cwd, "sd.config.ts"),
+    await renderTemplate(path.join(TPL_ROOT, "workspace-root/sd.config.ts.hbs"), data),
+  );
+
+  if (data.hasAuth) {
+    const commonSrc = path.join(cwd, "packages/common/src");
+    await fs.mkdir(commonSrc, { recursive: true });
+    await fs.writeFile(
+      path.join(commonSrc, "app-structure.ts"),
+      await renderTemplate(path.join(TPL_ROOT, "common/src/app-structure.ts.hbs"), data),
+    );
+  }
+
+  if (data.hasDb) {
+    const masterDir = path.join(cwd, "packages/common/src", data.dbFolderName, "tables/master");
+    await fs.mkdir(masterDir, { recursive: true });
+    if (data.hasAuth) {
+      await fs.writeFile(path.join(masterDir, `${data.userEntityKebab}.ts`), "");
+      await fs.writeFile(path.join(masterDir, `${data.userEntityKebab}-config.ts`), "");
+    }
+  }
+
+  if (data.hasClientCommon) {
+    await fs.mkdir(path.join(cwd, "packages/client-common/src"), { recursive: true });
+  }
+
+  for (const client of data.clients) {
+    const srcDir = path.join(cwd, "packages", client.name, "src");
+    await fs.mkdir(srcDir, { recursive: true });
+    if (client.hasRouter) {
+      await fs.writeFile(path.join(srcDir, "routes.ts"), "");
+    }
+  }
+
+  return cwd;
+}
+
+describe("recoverWorkspace", () => {
+  it("server+DB(mysql)+인증(user/사용자)+web/mobile 클라이언트 — 전체 라운드트립", async () => {
+    const cwd = await buildWorkspace({
+      workspaceName: "demo",
+      description: "Demo Workspace",
+      hasServer: true,
+      hasDb: true,
+      dbDialect: "mysql",
+      dbContextName: "main",
+      hasAuth: true,
+      userEntityName: "user",
+      userEntityLabel: "사용자",
+      mobileAppId: "kr.co.demo.app",
+      clients: [
+        { name: "admin", type: "web", hasRouter: true },
+        { name: "pda", type: "mobile", hasRouter: false },
+      ],
+      serverPort: 40080,
+    });
+
+    const r = await recoverWorkspace(cwd);
+
+    expect(r.input.workspaceName).toBe("demo");
+    expect(r.input.description).toBe("Demo Workspace");
+    expect(r.input.hasServer).toBe(true);
+    expect(r.input.hasDb).toBe(true);
+    expect(r.input.dbDialect).toBe("mysql");
+    expect(r.input.dbContextName).toBe("main");
+    expect(r.input.hasAuth).toBe(true);
+    expect(r.input.userEntityName).toBe("user");
+    expect(r.input.userEntityLabel).toBe("사용자");
+    expect(r.input.mobileAppId).toBe("kr.co.demo.app");
+    expect(r.input.serverPort).toBe(40080);
+    expect(r.input.clients).toEqual([
+      { name: "client-admin", type: "web", hasRouter: true, useSsg: false },
+      { name: "client-pda", type: "mobile", hasRouter: false, useSsg: false },
+    ]);
+    expect(r.hasClientCommonPkg).toBe(true);
+    expect(r.appStructureExportNames).toEqual(["adminAppStructureItems"]);
+  });
+
+  it("server=N + web 클라이언트 1개 — client-common 부재", async () => {
+    const cwd = await buildWorkspace({
+      workspaceName: "front-only",
+      description: "Front Only",
+      hasServer: false,
+      hasDb: false,
+      clients: [{ name: "admin", type: "web", hasRouter: true }],
+    });
+
+    const r = await recoverWorkspace(cwd);
+
+    expect(r.input.hasServer).toBe(false);
+    expect(r.input.hasDb).toBe(false);
+    expect(r.input.hasAuth).toBe(false);
+    expect(r.input.clients).toEqual([
+      { name: "client-admin", type: "web", hasRouter: true, useSsg: false },
+    ]);
+    expect(r.hasClientCommonPkg).toBe(false);
+    expect(r.appStructureExportNames).toEqual([]);
+  });
+
+  it("server=Y DB=N — DB 정보 없음", async () => {
+    const cwd = await buildWorkspace({
+      workspaceName: "no-db",
+      description: "No DB",
+      hasServer: true,
+      hasDb: false,
+      clients: [{ name: "admin", type: "web", hasRouter: true }],
+      serverPort: 41000,
+    });
+
+    const r = await recoverWorkspace(cwd);
+
+    expect(r.input.hasServer).toBe(true);
+    expect(r.input.hasDb).toBe(false);
+    expect(r.input.dbDialect).toBeUndefined();
+    expect(r.input.hasAuth).toBe(false);
+    expect(r.input.serverPort).toBe(41000);
+  });
+
+  it("커스텀 사용자 엔티티(employee/직원) + 커스텀 DB context 복원", async () => {
+    const cwd = await buildWorkspace({
+      workspaceName: "custom",
+      description: "Custom",
+      hasServer: true,
+      hasDb: true,
+      dbDialect: "postgresql",
+      dbContextName: "erp",
+      hasAuth: true,
+      userEntityName: "employee",
+      userEntityLabel: "직원",
+      clients: [{ name: "admin", type: "web", hasRouter: true }],
+      serverPort: 40080,
+    });
+
+    const r = await recoverWorkspace(cwd);
+
+    expect(r.input.dbDialect).toBe("postgresql");
+    expect(r.input.dbContextName).toBe("erp");
+    expect(r.input.userEntityName).toBe("employee");
+    expect(r.input.userEntityLabel).toBe("직원");
+  });
+
+  it("SSG 클라이언트 — prerender 로 useSsg 복원", async () => {
+    const cwd = await buildWorkspace({
+      workspaceName: "ssg",
+      description: "SSG",
+      hasServer: true,
+      hasDb: false,
+      clients: [{ name: "www", type: "web", hasRouter: true, useSsg: true }],
+      serverPort: 40080,
+    });
+
+    const r = await recoverWorkspace(cwd);
+
+    expect(r.input.clients).toEqual([
+      { name: "client-www", type: "web", hasRouter: true, useSsg: true },
+    ]);
+  });
+
+  it("클라이언트 0개 init 워크스페이스 — appStructure fallback 식별자 복원", async () => {
+    const cwd = await buildWorkspace({
+      workspaceName: "server-only",
+      description: "Server Only",
+      hasServer: true,
+      hasDb: true,
+      dbDialect: "mysql",
+      dbContextName: "main",
+      hasAuth: true,
+      userEntityName: "user",
+      userEntityLabel: "사용자",
+      clients: [],
+      serverPort: 40080,
+    });
+
+    const r = await recoverWorkspace(cwd);
+
+    expect(r.input.clients).toEqual([]);
+    expect(r.appStructureExportNames).toEqual(["appStructureItems"]);
+  });
+
+  it("sd.config.ts 없음 — 에러", async () => {
+    const cwd = await createTmpDir();
+    await fs.writeFile(
+      path.join(cwd, "package.json"),
+      JSON.stringify({ name: "broken", description: "" }),
+    );
+
+    await expect(recoverWorkspace(cwd)).rejects.toThrow();
+  });
+
+  it("루트 package.json 없음 — 에러", async () => {
+    const cwd = await createTmpDir();
+
+    await expect(recoverWorkspace(cwd)).rejects.toThrow();
+  });
+});

package/tests/init/render.spec.ts

@@ -991,6 +991,25 @@ describe("SSG 클라이언트 스캐폴드", () => {
     expect(out).not.toContain("provideClientHydration");
   });
 
+  it("client/public/robots.txt: SSG ON → 전체 허용", async () => {
+    const out = await renderTemplate(
+      path.join(TPL_ROOT, "client/public/robots.txt.hbs"),
+      ssgCtx(true),
+    );
+    expect(out).toContain("User-agent: *");
+    expect(out).toContain("Allow: /");
+    expect(out).not.toContain("Disallow: /");
+  });
+
+  it("client/public/robots.txt: SSG OFF → 전체 차단", async () => {
+    const out = await renderTemplate(
+      path.join(TPL_ROOT, "client/public/robots.txt.hbs"),
+      ssgCtx(false),
+    );
+    expect(out).toContain("User-agent: *");
+    expect(out).toContain("Disallow: /");
+  });
+
   it("client/main.server.ts: 서버 부트스트랩 default export + 최소 provider", async () => {
     const out = await renderTemplate(path.join(TPL_ROOT, "client/src/main.server.ts.hbs"), ssgCtx(true));
     expect(out).toContain('import { provideServerRendering } from "@angular/platform-server";');

package/src/commands/init/templates/client/public/robots.txt

@@ -1 +0,0 @@
-User-agent: * Disallow: /

package/src/commands/init/templates/workspace-root/.prettierignore

@@ -1 +0,0 @@
-*.hbs