@gaonjs/cli 0.32.0 → 0.34.0

package/dist/commands/build.d.ts

@@ -0,0 +1,11 @@
+export interface BuildCommandOptions {
+    readonly cwd?: string;
+    readonly json?: boolean;
+}
+export interface BuildCommandResult {
+    readonly ok: boolean;
+    readonly apps: string[];
+    readonly error?: string;
+}
+/** `gaon build` 진입점. .gaon 재생성 + 전 앱 vite build. */
+export declare function runBuildCommand(opts?: BuildCommandOptions): Promise<number>;

package/dist/commands/build.js

@@ -0,0 +1,49 @@
+// @gaonjs/cli · `gaon build` — 멀티 앱 프론트 프로덕션 빌드 (결정 146 · 12차 W2)
+//
+// `gaon gen`(.gaon 재생성) 뒤 apps/* 를 순회해 앱마다 root=apps/<앱>·outDir=dist/<앱>·
+// base=/<앱>/ 로 vite build 한다. 예전 스캐폴드 build 스크립트(`gaon gen && vite build`)는
+// apps/web 하나만 빌드해 둘째 앱(admin)의 dist 가 안 생기거나 base 없이 404 였다 —
+// gaon g app 으로 늘린 앱이 별도 손배선 없이 빌드 파이프라인에 자동 편입되게 한다.
+import { regenerateProjectGaon } from './gen.js';
+import { buildAllApps, listFrontendApps } from '../dev/build.js';
+/** `gaon build` 진입점. .gaon 재생성 + 전 앱 vite build. */
+export async function runBuildCommand(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const json = opts.json ?? false;
+    const log = (line) => {
+        if (!json)
+            process.stdout.write(line + '\n');
+    };
+    try {
+        // 1) .gaon 재생성 — build 산출이 routes.manifest 값 import 를 타므로 fresh 여야 한다(규칙 3).
+        await regenerateProjectGaon(cwd);
+        // 2) 프론트 앱이 없으면(API 전용) 조용히 통과.
+        const apps = await listFrontendApps(cwd);
+        if (apps.length === 0) {
+            const result = { ok: true, apps: [] };
+            if (json)
+                process.stdout.write(JSON.stringify({ command: 'build', ...result }) + '\n');
+            else
+                log('빌드할 프론트 앱(apps/<앱>/index.html)이 없습니다 — 건너뜁니다.');
+            return 0;
+        }
+        // 3) 앱별 빌드.
+        log(`gaon build — ${apps.length}개 앱: ${apps.join(', ')}`);
+        await buildAllApps(cwd, { onLog: json ? undefined : (l) => process.stdout.write(l + '\n') });
+        const result = { ok: true, apps };
+        if (json)
+            process.stdout.write(JSON.stringify({ command: 'build', ...result }) + '\n');
+        else
+            log(`✓ 빌드 완료 — ${apps.map((a) => `dist/${a}`).join(' · ')}`);
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const result = { ok: false, apps: [], error: msg };
+        if (json)
+            process.stdout.write(JSON.stringify({ command: 'build', ...result }) + '\n');
+        else
+            process.stderr.write(`✗ gaon build 실패: ${msg}\n`);
+        return 1;
+    }
+}

package/dist/commands/check.d.ts

@@ -4,7 +4,16 @@ export interface CheckCommandOptions {
     readonly json?: boolean;
     /** 지정 시 그 검사 하나만 실행. 나머지는 스킵. */
     readonly only?: CheckStep;
-    /** true 면 doctor 도 포함. 기본 false. */
+    /**
+     * 결정 157: doctor 는 이제 **기본 포함**이다(CI 가 check 하나만 돌려도 규칙 5 등
+     * doctor 규칙 위반을 잡는다). `noDoctor:true`(CLI `--no-doctor`)로 순수 typecheck/
+     * vue-tsc/build 만 돌린다.
+     */
+    readonly noDoctor?: boolean;
+    /**
+     * @deprecated 결정 157: doctor 가 기본이 돼 의미 없음(무시). `--include-doctor` 는
+     * 하위 호환 no-op — doctor 를 빼려면 `noDoctor`/`--no-doctor` 를 쓴다.
+     */
     readonly includeDoctor?: boolean;
 }
 export type CheckStepStatus = 'passed' | 'failed' | 'skipped';

package/dist/commands/check.js

@@ -7,16 +7,16 @@
  * (`node_modules/.bin/tsc --noEmit` · `node_modules/.bin/vue-tsc --noEmit`
  * · `pnpm -r build` → `npm run build`).
  *
- * The One Way — 하나의 명령이 3(선택 4) 검사를 순서대로 돌린다:
+ * The One Way — 하나의 명령이 4 검사를 순서대로 돌린다(결정 157 · doctor 기본 포함):
  *   1) typecheck (pnpm typecheck 또는 tsc --noEmit)
  *   2) vue-tsc   (pnpm vue-tsc 또는 vue-tsc --noEmit)
  *   3) build     (pnpm build)
- *   (4) doctor   (--include-doctor 시 · 코어 재사용)
+ *   4) doctor    (기본 포함 · 규칙 5 등 doctor 규칙 · --no-doctor 로 뺌 · 코어 재사용)
  *
  * 옵션 최소:
  *   --json                     자동화 · 각 검사의 passed/failed/skipped
  *   --only <name>              단일 검사만
- *   --include-doctor           check 안에서 doctor 도 · 기본 off
+ *   --no-doctor                doctor 를 빼고 typecheck/vue-tsc/build 만 (결정 157)
  *
  * exit code: 검사가 하나라도 실패하면 1, 그 외 0. 미리 검사할 대상이
  * 하나도 없으면(예: 스크립트도 없고 바이너리도 없음) 스킵으로 리포트 —
@@ -33,6 +33,8 @@ import { generateRoutesDts } from '@gaonjs/web';
 import { runDoctorCommand } from '../doctor.js';
 import { regenerateGaonOnce, resolveDevLayout } from '../dev.js';
 import { registerTsResolve } from '../tsResolve.js';
+import { listFrontendApps, verifyAppDist } from '../dev/build.js';
+import { generateMessagesDts } from '../messages-gen.js';
 /**
  * 프로젝트 스크립트 존재 여부. pnpm/npm 어느 쪽이든 `scripts.<name>` 을
  * 정의해 두면 우선 사용한다.
@@ -78,6 +80,17 @@ async function runStep(step, cwd) {
         const cmd = 'pnpm';
         const args = ['run', scriptName];
         const { exitCode, output } = await runSubprocess(cwd, cmd, args);
+        // 결정 146(12차 W2): build 가 성공했으면 **등록된 앱마다** dist/<앱>/index.html 과
+        // 그 문서가 참조하는 에셋이 실제로 존재하는지 검증한다. build 스크립트가 통과해도
+        // 둘째 앱(admin)의 dist 가 안 생기거나 에셋이 404 면 여기서 잡는다("build passed 인데
+        // /admin 은 빈 화면" 사각 제거 · curl data-page 만으로 못 보던 지점).
+        if (step === 'build' && exitCode === 0) {
+            const verify = await verifyBuildOutput(cwd);
+            if (!verify.ok) {
+                return { step, status: 'failed', command: `${cmd} ${args.join(' ')}`, exitCode, output: output + '\n' + verify.message };
+            }
+            return { step, status: 'passed', command: `${cmd} ${args.join(' ')}`, exitCode, output: output + '\n' + verify.message };
+        }
         return {
             step,
             status: exitCode === 0 ? 'passed' : 'failed',
@@ -159,6 +172,35 @@ async function runStep(step, cwd) {
             '→ 프론트 프로덕션 빌드를 검사에 포함하려면 package.json 에 "build": "vite build" 를 정의하세요.',
     };
 }
+/**
+ * build 산출 검증(결정 146 · 12차 W2). 등록된 프론트 앱마다 dist/<앱>/index.html 과
+ * 그 문서가 참조하는 로컬 에셋이 존재하는지 확인한다. 하나라도 빠지면 ok=false.
+ */
+async function verifyBuildOutput(cwd) {
+    const apps = await listFrontendApps(cwd);
+    if (apps.length === 0)
+        return { ok: true, message: '프론트 앱이 없어 dist 검증을 건너뜁니다.' };
+    const problems = [];
+    const okApps = [];
+    for (const app of apps) {
+        const r = await verifyAppDist(cwd, app);
+        if (!r.indexExists) {
+            problems.push(`✗ apps/${app}: dist/${app}/index.html 이 없습니다 — 이 앱이 빌드되지 않았습니다.\n` +
+                `  → build 가 apps/${app} 를 순회 빌드하는지 확인하세요(gaon build · 결정 146).`);
+        }
+        else if (r.missing.length > 0) {
+            problems.push(`✗ apps/${app}: index.html 이 참조하는 에셋이 dist/${app} 에 없습니다: ${r.missing.join(', ')}\n` +
+                `  → base(${app === 'web' ? '/' : `/${app}/`}) 주입이 빠졌을 수 있습니다(비-루트 앱은 /<앱>/ base 필요).`);
+        }
+        else {
+            okApps.push(app);
+        }
+    }
+    if (problems.length > 0) {
+        return { ok: false, message: `build 산출 검증 실패(결정 146):\n${problems.join('\n')}` };
+    }
+    return { ok: true, message: `build 산출 검증 통과 — 앱별 dist: ${okApps.map((a) => `dist/${a}`).join(' · ')}` };
+}
 /** doctor 는 이미 있는 명령을 재사용 — cwd 만 넘긴다. json 은 상위에서. */
 async function runDoctorStep(cwd) {
     try {
@@ -192,7 +234,7 @@ async function runDoctorStep(cwd) {
  */
 async function regenerateGaon(cwd) {
     const layout = resolveDevLayout(cwd);
-    if (!layout.schemaDir && layout.apps.length === 0) {
+    if (!layout.schemaDir && layout.apps.length === 0 && !layout.localesDir) {
         return { status: 'skipped', tables: false, apps: [] };
     }
     // 생성기는 사용자 스키마·컨트롤러 .ts 를 동적 import 한다. TS-for-ESM
@@ -203,6 +245,7 @@ async function regenerateGaon(cwd) {
         const result = await regenerateGaonOnce(layout, {
             regenerateTables: generateTablesDts,
             regenerateRoutes: generateRoutesDts,
+            regenerateMessages: generateMessagesDts,
         });
         return { status: 'done', tables: result.tables, apps: result.apps };
     }
@@ -228,7 +271,9 @@ export async function runCheckCommand(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const json = opts.json ?? false;
     const only = opts.only;
-    const includeDoctor = opts.includeDoctor ?? false;
+    // 결정 157: doctor 는 기본 포함(규칙 5 등 doctor 규칙이 check 만 도는 CI 에서 새지 않게).
+    // --no-doctor 로만 뺀다. --include-doctor(구)는 이제 no-op(기본이 된 동작).
+    const runDoctor = !opts.noDoctor;
     // 규칙 3 — 검사는 최신 타입 브리지 위에서만 신뢰할 수 있다. 재생성이
     // 실패하면 stale .gaon 으로 검사하지 않고 즉시 중단한다.
     const regen = await regenerateGaon(cwd);
@@ -236,7 +281,7 @@ export async function runCheckCommand(opts = {}) {
         ? []
         : only
             ? [only]
-            : ['typecheck', 'vue-tsc', 'build', ...(includeDoctor ? ['doctor'] : [])];
+            : ['typecheck', 'vue-tsc', 'build', ...(runDoctor ? ['doctor'] : [])];
     const results = [];
     for (const step of steps) {
         if (step === 'doctor') {

package/dist/commands/dev.js

@@ -26,6 +26,7 @@ import { registerTsResolve } from '../tsResolve.js';
 import { startDev, resolveDevLayout } from '../dev.js';
 import { generateTablesDts, watchDir } from '@gaonjs/data';
 import { generateRoutesDts } from '@gaonjs/web';
+import { generateMessagesDts } from '../messages-gen.js';
 import { createDevConsole } from '../dev/console.js';
 import { ensureInfra, composeDown } from '../dev/docker.js';
 import { startTscWatchers, killChild } from '../dev/tsc.js';
@@ -86,6 +87,7 @@ async function startGaonRegen(args) {
         layout,
         regenerateTables: generateTablesDts,
         regenerateRoutes: generateRoutesDts,
+        regenerateMessages: generateMessagesDts,
         watch: watchDir,
         log: (e) => {
             if (e.kind === 'ready') {

package/dist/commands/gen.js

@@ -15,6 +15,7 @@
  */
 import { generateTablesDts } from '@gaonjs/data';
 import { generateRoutesDts } from '@gaonjs/web';
+import { generateMessagesDts } from '../messages-gen.js';
 import { regenerateGaonOnce, resolveDevLayout } from '../dev.js';
 import { registerTsResolve } from '../tsResolve.js';
 /**
@@ -24,13 +25,14 @@ import { registerTsResolve } from '../tsResolve.js';
  */
 export async function regenerateProjectGaon(cwd) {
     const layout = resolveDevLayout(cwd);
-    if (!layout.schemaDir && layout.apps.length === 0) {
-        return { tables: false, apps: [], skipped: true };
+    if (!layout.schemaDir && layout.apps.length === 0 && !layout.localesDir) {
+        return { tables: false, apps: [], messages: false, skipped: true };
     }
     registerTsResolve();
     const result = await regenerateGaonOnce(layout, {
         regenerateTables: generateTablesDts,
         regenerateRoutes: generateRoutesDts,
+        regenerateMessages: generateMessagesDts,
     });
     return { ...result, skipped: false };
 }

package/dist/db/projectData.d.ts

@@ -0,0 +1,14 @@
+import type { ConnectionConfig } from '@gaonjs/data';
+/** 프로젝트(projDir) 관점에서 @gaonjs/data 가 해상되는 경로. 미설치면 null. */
+export declare function resolveProjectDataPath(projDir: string): string | null;
+/** 프로젝트 @gaonjs/data 가 CLI 것과 **다른 인스턴스**인가(전역 설치 이중 로드 신호). */
+export declare function isSplitDataInstance(projDir: string): boolean;
+/**
+ * 프로젝트의 @gaonjs/data 인스턴스가 CLI 것과 다르면(전역 설치) 그 인스턴스에 커넥션을
+ * 등록해 모델 레이어가 같은 레지스트리를 보게 한다. 같은 인스턴스(로컬)면 resolveDbTarget
+ * 이 이미 등록했으므로 **no-op(null 반환)** — 로컬 경로 무회귀. 반환 핸들의 close() 는
+ * 프로젝트 인스턴스 커넥션을 정리한다(다른 인스턴스일 때만).
+ */
+export declare function registerInProjectData(projDir: string, dbKey: string, connCfg: ConnectionConfig): Promise<{
+    close(): Promise<void>;
+} | null>;

package/dist/db/projectData.js

@@ -0,0 +1,51 @@
+// @gaonjs/cli · 프로젝트 로컬 @gaonjs/data 해상 (결정 156 · 전역-로컬 레지스트리 분열 근본 수정)
+//
+// 전역 설치 CLI(`npm i -g gaonjs`)는 자기 번들의 @gaonjs/data 를 로드하고, 프로젝트의
+// domain 코드(seed 가 실행하는 모델)는 **프로젝트 node_modules** 의 @gaonjs/data 를
+// 로드한다(tsResolve 훅이 bare 지정자를 안 건드림 · dual package hazard). 두 인스턴스는
+// 커넥션 레지스트리가 갈려, resolveDbTarget 이 CLI 인스턴스에 등록한 커넥션을 모델
+// 레이어(프로젝트 인스턴스)가 못 봐서 seed 가 "커넥션 'main' 미등록" 으로 죽었다.
+// db migrate/diff/status 는 모델을 안 거쳐 이 분열을 가렸다(13차 실측).
+//
+// 근본 수정: seed 처럼 **프로젝트 모델 레이어를 거치는** 명령은, 프로젝트 인스턴스의
+// @gaonjs/data 에도 커넥션을 등록해 모델과 **단일 레지스트리**를 공유한다. 로컬 설치
+// (CLI·프로젝트가 같은 @gaonjs/data)면 두 경로가 같은 모듈이라 no-op — migrate/diff/
+// status 를 비롯한 로컬 경로는 무회귀다.
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { join, resolve as resolvePath } from 'node:path';
+/** CLI 자신이 로드한 @gaonjs/data 의 해상 경로. */
+function cliDataPath() {
+    return createRequire(import.meta.url).resolve('@gaonjs/data');
+}
+/** 프로젝트(projDir) 관점에서 @gaonjs/data 가 해상되는 경로. 미설치면 null. */
+export function resolveProjectDataPath(projDir) {
+    try {
+        // projDir/package.json 기준으로 해상 — 프로젝트 node_modules 의 @gaonjs/data.
+        const req = createRequire(join(resolvePath(projDir), 'package.json'));
+        return req.resolve('@gaonjs/data');
+    }
+    catch {
+        return null;
+    }
+}
+/** 프로젝트 @gaonjs/data 가 CLI 것과 **다른 인스턴스**인가(전역 설치 이중 로드 신호). */
+export function isSplitDataInstance(projDir) {
+    const projPath = resolveProjectDataPath(projDir);
+    return projPath !== null && projPath !== cliDataPath();
+}
+/**
+ * 프로젝트의 @gaonjs/data 인스턴스가 CLI 것과 다르면(전역 설치) 그 인스턴스에 커넥션을
+ * 등록해 모델 레이어가 같은 레지스트리를 보게 한다. 같은 인스턴스(로컬)면 resolveDbTarget
+ * 이 이미 등록했으므로 **no-op(null 반환)** — 로컬 경로 무회귀. 반환 핸들의 close() 는
+ * 프로젝트 인스턴스 커넥션을 정리한다(다른 인스턴스일 때만).
+ */
+export async function registerInProjectData(projDir, dbKey, connCfg) {
+    const projPath = resolveProjectDataPath(projDir);
+    if (!projPath || projPath === cliDataPath())
+        return null; // 로컬 설치 = 단일 인스턴스 · no-op
+    const mod = (await import(pathToFileURL(projPath).href));
+    const db = mod.createDb(connCfg);
+    mod.registerConnection(dbKey, db, connCfg.adapter);
+    return { close: () => mod.destroyAllConnections() };
+}

package/dist/db.js

@@ -12,6 +12,7 @@ import { pathToFileURL } from 'node:url';
 import { createDb, registerConnection, destroyAllConnections, isSeedDef, } from '@gaonjs/data';
 import { registerTsResolve } from './tsResolve.js';
 import { resolveDbTarget } from './db/resolve.js';
+import { registerInProjectData, isSplitDataInstance } from './db/projectData.js';
 /** DB URL 에서 어댑터를 추정한다(gaon work 와 동일 규칙). */
 function dbConfigFromUrl(url) {
     if (url.startsWith('mysql://') || url.startsWith('mariadb://')) {
@@ -52,24 +53,59 @@ export async function runDbSeedCommand(opts = {}) {
     if (opts.databaseUrl) {
         const cfg = dbConfigFromUrl(opts.databaseUrl);
         registerConnection(dbKey, createDb(cfg), cfg.adapter);
+        // 결정 156: 전역 설치면 프로젝트 인스턴스에도 등록(모델과 단일 레지스트리 공유).
+        const projData = await registerInProjectData(root, dbKey, cfg);
         try {
             const def = await loadSeed(root);
-            await def.run();
+            await runSeed(def, root);
             return { exitCode: 0, ...SEED_OK };
         }
         finally {
+            if (projData)
+                await projData.close();
             await destroyAllConnections();
         }
     }
     // 그 외 — migrate 와 같은 해석 경로: gaon.config.ts db.<키> → GAON_DATABASE_URL.
     // config 도 env 도 없으면 resolveDbTarget 이 수리 안내 에러를 던진다(§7.5.3).
     const target = await resolveDbTarget({ cwd: root, dbKey, configPath: opts.configPath });
+    // 결정 156: seed 는 모델 레이어를 거친다 — 전역 설치(CLI≠프로젝트 @gaonjs/data)면
+    // 프로젝트 인스턴스에도 커넥션을 등록해 "main 미등록" 분열을 근본에서 없앤다. 로컬
+    // 설치(단일 인스턴스)면 no-op. url 없는 config 는 seed 대상이 아니라 안내한다.
+    if (!target.url) {
+        await target.close();
+        throw new Error(`[gaon db seed] 커넥션 '${dbKey}' 에 url 이 없어 시드를 실행할 수 없습니다.\n` +
+            `  → gaon.config.ts 의 db.${dbKey} 에 url 을 두거나 .env 의 GAON_DATABASE_URL 을 설정하세요.`);
+    }
+    const projData = await registerInProjectData(root, dbKey, { adapter: target.adapter, url: target.url, poolMax: 1 });
     try {
         const def = await loadSeed(root);
-        await def.run();
+        await runSeed(def, root);
         return { exitCode: 0, ...SEED_OK };
     }
     finally {
+        if (projData)
+            await projData.close();
         await target.close();
     }
 }
+/**
+ * 시드를 실행하되, "커넥션 미등록" 계열 실패는 전역-로컬 @gaonjs/data 분열로 진단해
+ * 실제 수리(로컬 실행)로 안내한다(결정 156 · §7.5.3 — 이미 등록된 커넥션을 또 선언하라던
+ * 오진 제거).
+ */
+async function runSeed(def, root) {
+    try {
+        await def.run();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (/등록되지 않았|not registered|미등록/.test(msg) && isSplitDataInstance(root)) {
+            throw new Error(`[gaon db seed] 시드 실행 중 커넥션을 찾지 못했습니다 — 전역 설치 CLI 와 프로젝트가\n` +
+                `@gaonjs/data 를 각각 로드해 커넥션 레지스트리가 갈렸습니다(dual package hazard).\n` +
+                `  → 프로젝트 로컬로 실행하세요: npx gaon db seed (또는 package.json 스크립트로 실행)\n` +
+                `  (원본: ${msg})`);
+        }
+        throw err;
+    }
+}

package/dist/dev/build.d.ts

@@ -0,0 +1,34 @@
+/** 앱의 URL base — web 은 루트('/'), 그 외는 '/<app>/'(결정 146). vite build 시 주입. */
+export declare function appBase(app: string): string;
+/** apps/* 중 프론트 진입(index.html)이 있는 앱 이름들. web 을 먼저(루트 앱 관례). */
+export declare function listFrontendApps(cwd: string): Promise<string[]>;
+/** vite.config 를 프로젝트 루트·앱 루트 순으로 찾는다(configFile 명시용 · vue 플러그인 보장). */
+export declare function findViteConfig(cwd: string, appRoot: string): string | undefined;
+export interface BuildAppOptions {
+    /** watch 모드(dev) — RollupWatcher 를 담은 핸들을 돌려준다(close 로 정리). */
+    readonly watch?: boolean;
+    /** 통합 콘솔 로그 훅(생략 = vite 가 stdout 으로 직접 출력). */
+    readonly onLog?: (line: string, level: 'info' | 'warn' | 'error') => void;
+}
+export interface BuildAppHandle {
+    /** watch 모드에서 감시를 종료한다. non-watch 는 no-op. */
+    close(): Promise<void>;
+}
+/** 한 앱을 vite 로 빌드한다(programmatic · configFile 명시 → vue 플러그인·alias 보장). */
+export declare function buildApp(cwd: string, app: string, opts?: BuildAppOptions): Promise<BuildAppHandle>;
+/** 등록된 프론트 앱을 전부 빌드한다(build 커맨드·게이트 공용). 빌드한 앱 이름을 돌려준다. */
+export declare function buildAllApps(cwd: string, opts?: BuildAppOptions): Promise<string[]>;
+/** 한 앱의 dist 검증 결과. missing 가 비어 있지 않으면 게이트 실패(결정 146). */
+export interface DistVerifyResult {
+    readonly app: string;
+    readonly indexExists: boolean;
+    /** index.html 이 참조하는데 실제 파일이 없는 로컬 에셋 경로(base 기준). */
+    readonly missing: string[];
+}
+/**
+ * 앱의 dist/<앱>/index.html 과 그 문서가 참조하는 로컬 에셋(script src·link href)이
+ * 실제로 존재하는지 검증한다(결정 146 · gaon check build 게이트). base(/<앱>/)로 시작하는
+ * 참조만 검사한다(외부 URL 제외). curl data-page 만으로는 못 보던 "문서는 뜨는데 스크립트
+ * 404" 를 정면으로 막는다.
+ */
+export declare function verifyAppDist(cwd: string, app: string): Promise<DistVerifyResult>;

package/dist/dev/build.js

@@ -0,0 +1,144 @@
+// @gaonjs/cli · dev/build — 멀티 앱 프론트 빌드 파이프라인 (결정 146 · 12차 W2)
+//
+// gaon new 프로젝트는 앱이 하나 이상일 수 있다(gaon g app admin). 각 앱은 자기
+// prefix 아래로 서빙되고(web→'/' · admin→'/admin/'), serve 는 앱별 dist/<앱> 를
+// 기대한다(결정 67). 그런데 예전 파이프라인은 apps/web 하나만 빌드해(vite.config
+// root 하드코딩) 둘째 앱의 dist 가 안 생기고, 생겨도 base 가 없어 index.html 이
+// 절대경로 `/assets/*` 를 박아 비-루트 앱에서 404 였다. 이 모듈이 apps/* 를 순회해
+// 앱마다 root=apps/<앱>·outDir=dist/<앱>·base=/<앱>/ 로 빌드한다(결정 146).
+//
+// vite 는 **프로그램적 build()** 로 부른다 — configFile 을 명시로 넘겨야 vue 플러그인·
+// @shared alias 가 로드된다(positional root 만 주면 앱 폴더에 vite.config 가 없어
+// vue 플러그인이 빠지는 함정 · 결정 146). inline root/base/outDir 가 configFile 을
+// 덮어써 앱별 override 가 확실하다.
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+/** 앱의 URL base — web 은 루트('/'), 그 외는 '/<app>/'(결정 146). vite build 시 주입. */
+export function appBase(app) {
+    return app === 'web' ? '/' : `/${app}/`;
+}
+/** apps/* 중 프론트 진입(index.html)이 있는 앱 이름들. web 을 먼저(루트 앱 관례). */
+export async function listFrontendApps(cwd) {
+    const appsDir = join(resolve(cwd), 'apps');
+    let entries;
+    try {
+        entries = (await readdir(appsDir, { withFileTypes: true }));
+    }
+    catch {
+        return [];
+    }
+    const apps = entries
+        .filter((e) => e.isDirectory() && existsSync(join(appsDir, e.name, 'index.html')))
+        .map((e) => e.name);
+    return apps.sort((a, b) => (a === 'web' ? -1 : b === 'web' ? 1 : a.localeCompare(b)));
+}
+/** vite.config 를 프로젝트 루트·앱 루트 순으로 찾는다(configFile 명시용 · vue 플러그인 보장). */
+export function findViteConfig(cwd, appRoot) {
+    for (const dir of [appRoot, resolve(cwd)]) {
+        for (const name of ['vite.config.ts', 'vite.config.js', 'vite.config.mts', 'vite.config.mjs']) {
+            const p = join(dir, name);
+            if (existsSync(p))
+                return p;
+        }
+    }
+    return undefined;
+}
+/** 한 앱을 vite 로 빌드한다(programmatic · configFile 명시 → vue 플러그인·alias 보장). */
+export async function buildApp(cwd, app, opts = {}) {
+    const root = resolve(cwd);
+    const appRoot = join(root, 'apps', app);
+    const vite = await loadVite();
+    const result = await vite.build({
+        configFile: findViteConfig(root, appRoot),
+        root: appRoot,
+        base: appBase(app),
+        // onLog 있으면 vite 출력을 그 훅으로 라우팅(customLogger 가 stdout 대신 훅으로).
+        // 없으면(예: `gaon build --json`) 완전히 침묵 — vite 진행 로그가 stdout 의 JSON 을
+        // 오염시키면 안 된다(클린룸이 마지막 줄을 JSON 으로 파싱 · 결정 146 실측).
+        logLevel: opts.onLog ? 'info' : 'silent',
+        customLogger: opts.onLog ? makeLogger(opts.onLog) : undefined,
+        build: {
+            outDir: join(root, 'dist', app),
+            emptyOutDir: true,
+            watch: opts.watch ? {} : null,
+        },
+    });
+    const watcher = result;
+    if (opts.watch && watcher && typeof watcher.close === 'function') {
+        return { close: async () => void (await watcher.close()) };
+    }
+    return { close: async () => { } };
+}
+/** 등록된 프론트 앱을 전부 빌드한다(build 커맨드·게이트 공용). 빌드한 앱 이름을 돌려준다. */
+export async function buildAllApps(cwd, opts = {}) {
+    const apps = await listFrontendApps(cwd);
+    for (const app of apps) {
+        opts.onLog?.(`▶ vite build — apps/${app} → dist/${app} (base=${appBase(app)})`, 'info');
+        await buildApp(cwd, app, { onLog: opts.onLog });
+    }
+    return apps;
+}
+/**
+ * 앱의 dist/<앱>/index.html 과 그 문서가 참조하는 로컬 에셋(script src·link href)이
+ * 실제로 존재하는지 검증한다(결정 146 · gaon check build 게이트). base(/<앱>/)로 시작하는
+ * 참조만 검사한다(외부 URL 제외). curl data-page 만으로는 못 보던 "문서는 뜨는데 스크립트
+ * 404" 를 정면으로 막는다.
+ */
+export async function verifyAppDist(cwd, app) {
+    const distDir = join(resolve(cwd), 'dist', app);
+    const indexPath = join(distDir, 'index.html');
+    if (!existsSync(indexPath))
+        return { app, indexExists: false, missing: [] };
+    const html = await readFile(indexPath, 'utf8');
+    const base = appBase(app);
+    const missing = [];
+    const refs = new Set();
+    // <script ... src="..."> · <link ... href="..."> 의 값 추출.
+    for (const m of html.matchAll(/<(?:script|link)\b[^>]*\b(?:src|href)\s*=\s*["']([^"']+)["']/gi)) {
+        refs.add(m[1]);
+    }
+    for (const ref of refs) {
+        // 이 앱 base 로 시작하는 로컬 에셋만 검사(외부·절대 URL·data: 제외).
+        if (!ref.startsWith(base))
+            continue;
+        const rel = ref.slice(base.length); // base 를 벗겨 dist 상대 경로로.
+        const file = join(distDir, rel.split('?')[0].split('#')[0]);
+        if (!existsSync(file))
+            missing.push(ref);
+    }
+    return { app, indexExists: true, missing };
+}
+async function loadVite() {
+    try {
+        return await import('vite');
+    }
+    catch (err) {
+        throw new Error(`[gaon build · vite] vite 모듈을 찾을 수 없습니다.\n` +
+            `→ 프로젝트 루트에서 설치하세요: pnpm add -D vite @vitejs/plugin-vue\n` +
+            `원인: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/** vite 로거 어댑터 — 라인을 통합 콘솔 훅으로 흘린다(필요 메서드만). */
+function makeLogger(onLog) {
+    const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+    let hasWarned = false;
+    const seen = new WeakSet();
+    return {
+        info: (m) => onLog(strip(m), 'info'),
+        warn: (m) => {
+            hasWarned = true;
+            onLog(strip(m), 'warn');
+        },
+        warnOnce: (m) => {
+            hasWarned = true;
+            onLog(strip(m), 'warn');
+        },
+        error: (m) => onLog(strip(m), 'error'),
+        clearScreen: () => { },
+        hasErrorLogged: (e) => seen.has(e),
+        get hasWarned() {
+            return hasWarned;
+        },
+    };
+}

package/dist/dev/frontend-build.d.ts

@@ -1,5 +1,5 @@
 export interface FrontendBuildHandle {
-    /** watch 빌드 프로세스를 종료한다. */
+    /** watch 빌드(모든 앱)를 종료한다. */
     close(): void;
 }
 export interface StartFrontendBuildOptions {
@@ -8,7 +8,7 @@ export interface StartFrontendBuildOptions {
     readonly onLog: (line: string, level: 'info' | 'warn' | 'error') => void;
 }
 /**
- * vite build --watch 를 띄운다. 프론트가 없거나 vite 가 없으면 아무 것도 하지
- * 않고 no-op 핸들을 돌려준다(dev 는 계속 진행).
+ * apps/* 를 순회해 앱마다 vite watch 빌드를 띄운다. 프론트가 없거나 vite 가 없으면
+ * 아무 것도 하지 않고 no-op 핸들을 돌려준다(dev 는 계속 진행 · fail-open).
  */
 export declare function startFrontendBuild(opts: StartFrontendBuildOptions): FrontendBuildHandle;