@gaonjs/cli 0.31.1 → 0.33.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.js

@@ -33,6 +33,7 @@ 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';
 /**
  * 프로젝트 스크립트 존재 여부. pnpm/npm 어느 쪽이든 `scripts.<name>` 을
  * 정의해 두면 우선 사용한다.
@@ -78,6 +79,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 +171,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 {

package/dist/commands/db.d.ts

@@ -4,7 +4,11 @@ export interface DbCommandOptions {
     readonly cwd?: string;
     /** 자동화 출력. 기본 false(사람 텍스트). */
     readonly json?: boolean;
-    /** 커넥션 키(§4.5). 기본 'main'. */
+    /**
+     * 커넥션 키(§4.5). 결정 139: diff/migrate/status/seed 는 생략(또는 'all') 시
+     * 등록된 **전 커넥션**을 순회 적용한다 · `--db <키>` 는 단일 좁힘. reset(파괴적)은
+     * 항상 단일이며 생략 시 'main'.
+     */
     readonly db?: string;
     /** --config <path> 오버라이드. 없으면 cwd/gaon.config.ts 관례. */
     readonly config?: string;

package/dist/commands/db.js

@@ -11,7 +11,12 @@ import { runDbDiff } from '../db/diff.js';
 import { runDbMigrate } from '../db/migrate.js';
 import { runDbReset } from '../db/reset.js';
 import { runDbStatus } from '../db/status.js';
+import { listConnectionKeys } from '../db/resolve.js';
 import { runDbSeedCommand } from '../db.js';
+/** 전 커넥션 순회 대상 서브커맨드(결정 139 · reset 은 파괴적이라 제외 · 단일 유지). */
+const MULTI_CONN_SUBS = new Set(['diff', 'migrate', 'status', 'seed']);
+/** 알려진 서브커맨드. dispatcher 방어(모르는 값이 오면 seed 로 새지 않게). */
+const KNOWN_SUBS = new Set(['diff', 'migrate', 'reset', 'seed', 'status']);
 /**
  * `gaon db <sub>` 진입점. 사람/JSON 출력을 자체 처리하고 exitCode 를
  * 돌려준다. seed 는 기존 M8 runDbSeedCommand 로 위임(신규 서명에 정합).
@@ -19,7 +24,6 @@ import { runDbSeedCommand } from '../db.js';
 export async function runDbCommand(subcommand, opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const json = opts.json ?? false;
-    const dbKey = opts.db ?? 'main';
     const configPath = opts.config;
     const dryRun = opts.dryRun ?? false;
     const emit = (text, jsonValue) => {
@@ -28,45 +32,55 @@ export async function runDbCommand(subcommand, opts = {}) {
         else
             process.stdout.write(text + '\n');
     };
-    try {
-        if (subcommand === 'diff') {
-            const r = await runDbDiff({ cwd, dbKey, json, configPath });
-            emit(r.text, r.json);
-            return r.exitCode;
-        }
-        if (subcommand === 'migrate') {
-            const r = await runDbMigrate({ cwd, dbKey, json, dryRun, down: opts.down ?? false, configPath });
-            emit(r.text, r.json);
-            return r.exitCode;
-        }
-        if (subcommand === 'status') {
-            const r = await runDbStatus({ cwd, dbKey, json, configPath });
-            emit(r.text, r.json);
-            return r.exitCode;
-        }
-        if (subcommand === 'reset') {
-            const r = await runDbReset({
-                cwd,
-                dbKey,
-                json,
-                yes: opts.yes ?? false,
-                dryRun,
-                configPath,
-            });
-            emit(r.text, r.json);
-            return r.exitCode;
-        }
-        if (subcommand === 'seed') {
-            // 결정 101: seed 도 diff/migrate 와 같은 설정 해석 경로(config → env)를 쓴다.
-            const r = await runDbSeedCommand({ root: cwd, json, configPath, dbKey });
-            emit(r.text, r.json);
-            return r.exitCode;
-        }
-        // 방어 — dispatcher 라 도달할 수 없지만 컴파일러 만족용.
+    // 한 커넥션에 대해 서브커맨드를 실행한다(순회 루프의 단위).
+    const runOne = async (subKey) => {
+        if (subcommand === 'diff')
+            return runDbDiff({ cwd, dbKey: subKey, json, configPath });
+        if (subcommand === 'migrate')
+            return runDbMigrate({ cwd, dbKey: subKey, json, dryRun, down: opts.down ?? false, configPath });
+        if (subcommand === 'status')
+            return runDbStatus({ cwd, dbKey: subKey, json, configPath });
+        if (subcommand === 'reset')
+            return runDbReset({ cwd, dbKey: subKey, json, yes: opts.yes ?? false, dryRun, configPath });
+        // seed (결정 101: diff/migrate 와 같은 설정 해석 경로 config → env).
+        return runDbSeedCommand({ root: cwd, json, configPath, dbKey: subKey });
+    };
+    // 방어 — dispatcher 라 도달할 수 없지만, 모르는 서브커맨드가 seed 로 새지 않게.
+    if (!KNOWN_SUBS.has(subcommand)) {
         process.stderr.write(`  ✗ 알 수 없는 db 서브커맨드: ${String(subcommand)}\n` +
             `  → 지원: diff | migrate | reset | seed | status\n`);
         return 1;
     }
+    try {
+        // 결정 139: diff/migrate/status/seed 는 --db 생략(또는 'all') 시 등록된 전
+        // 커넥션을 순회 적용한다(One Way — 커넥션 하나를 잊어 빈 채 배포하는 사고 방지).
+        // `--db <키>` 는 단일 좁힘. reset(파괴적)은 항상 단일(main 폴백).
+        const wantsAll = subcommand !== 'reset' && (opts.db === undefined || opts.db === 'all');
+        if (wantsAll && MULTI_CONN_SUBS.has(subcommand)) {
+            const keys = await listConnectionKeys(cwd, configPath);
+            // 단일 커넥션이면 종전 출력과 100% 동일(하위 호환).
+            if (keys.length === 1) {
+                const r = await runOne(keys[0]);
+                emit(r.text, r.json);
+                return r.exitCode;
+            }
+            return runAcrossConnections(subcommand, keys, runOne, emit, json);
+        }
+        // 단일 커넥션 경로(--db <키> · reset · env-only 폴백) — 종전 동작 그대로.
+        if (subcommand === 'reset' && opts.db === 'all') {
+            // reset 은 전 커넥션 순회를 하지 않는다(파괴적). 명시적으로 거부한다.
+            const msg = `reset 은 전 커넥션 순회를 지원하지 않습니다(파괴적).\n` +
+                `→ 커넥션을 하나씩 지정하세요: 'gaon db reset --db main --yes'.`;
+            if (json)
+                process.stdout.write(JSON.stringify({ command: 'reset', ok: false, error: msg }) + '\n');
+            else
+                process.stderr.write(`  ✗ ${msg}\n`);
+            return 1;
+        }
+        const r = await runOne(opts.db ?? 'main');
+        emit(r.text, r.json);
+        return r.exitCode;
+    }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         if (json) {
@@ -78,3 +92,45 @@ export async function runDbCommand(subcommand, opts = {}) {
         return 1;
     }
 }
+/**
+ * 전 커넥션 순회 실행(결정 139). 각 커넥션을 등록 순서대로 돌리고, 한 커넥션이
+ * 실패해도 나머지를 계속한다(부분 적용 방지가 아니라 부분 진행 후 전체 보고 — 어느
+ * 커넥션이 성공/실패했는지가 사용자에게 필요). exitCode = 하나라도 실패면 1.
+ */
+async function runAcrossConnections(subcommand, keys, runOne, emit, json) {
+    const results = [];
+    for (const key of keys) {
+        try {
+            const r = await runOne(key);
+            results.push({ db: key, ok: r.exitCode === 0, exitCode: r.exitCode, text: r.text, json: r.json });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            results.push({
+                db: key,
+                ok: false,
+                exitCode: 1,
+                text: `  ✗ [${key}] gaon db ${subcommand} 실패: ${msg}`,
+                json: { command: subcommand, db: key, ok: false, error: msg },
+            });
+        }
+    }
+    const failed = results.filter((r) => !r.ok);
+    const exitCode = failed.length > 0 ? 1 : 0;
+    if (json) {
+        emit('', {
+            command: subcommand,
+            connections: keys,
+            ok: failed.length === 0,
+            results: results.map((r) => ({ db: r.db, ok: r.ok, ...r.json })),
+        });
+        return exitCode;
+    }
+    const header = `  gaon db ${subcommand} · 커넥션 ${keys.length}개 순회: ${keys.join(', ')}`;
+    const sections = results.map((r) => `  ── [${r.db}] ${'─'.repeat(Math.max(0, 40 - r.db.length))}\n${r.text}`);
+    const footer = failed.length === 0
+        ? `  ✓ 전 커넥션 완료(${keys.length}개).`
+        : `  ✗ ${failed.length}/${keys.length} 커넥션 실패: ${failed.map((r) => r.db).join(', ')}`;
+    emit([header, ...sections, footer].join('\n'), null);
+    return exitCode;
+}

package/dist/db/resolve.d.ts

@@ -28,11 +28,9 @@ export interface ResolvedDbTarget {
     close(): Promise<void>;
 }
 /**
- * gaon.config.ts 를 로드해 target db 커넥션을 등록하고 스키마 테이블을 모아 온다.
- *
- * 커넥션 결정 순서:
- *  1) config.db[dbKey] 가 있으면 그 어댑터·URL 사용
- *  2) dbKey='main' 이고 GAON_DATABASE_URL 이 있으면 그 URL 로 main 을 세움
- *  3) 그 외 → 수리 안내 에러
+ * 프로젝트의 커넥션 키 목록을 돌려준다(결정 139 · `gaon db <sub>` 전 커넥션 순회용).
+ * config.db 에 선언된 키 순서 그대로. 선언이 없으면(env-only 프로젝트) `['main']`
+ * 폴백(GAON_DATABASE_URL 관례) — 단일 커넥션 프로젝트의 종전 동작과 정합.
  */
+export declare function listConnectionKeys(cwd: string, configPath?: string): Promise<string[]>;
 export declare function resolveDbTarget(opts: ResolveDbOptions): Promise<ResolvedDbTarget>;

package/dist/db/resolve.js

@@ -65,15 +65,15 @@ function isTableDef(v) {
  *  2) dbKey='main' 이고 GAON_DATABASE_URL 이 있으면 그 URL 로 main 을 세움
  *  3) 그 외 → 수리 안내 에러
  */
-export async function resolveDbTarget(opts) {
-    const cwd = resolvePath(opts.cwd);
+/**
+ * gaon.config 를 로드해 config 값과 실 경로를 돌려준다. --config <path> 가 있으면
+ * 그 파일의 default export 를, 없으면 cwd 관례(gaon.config.ts)를 쓴다.
+ * resolveDbTarget·listConnectionKeys 가 공유한다(결정 139).
+ */
+async function loadDbConfig(cwd, configPathOpt) {
     registerTsResolve();
-    // 사용자가 --config <path> 를 준 경우 그 경로에서 default export 를 로드한다.
-    // 없으면 cwd 관례.
-    let configPath;
-    let config;
-    if (opts.configPath) {
-        configPath = resolvePath(opts.configPath);
+    if (configPathOpt) {
+        const configPath = resolvePath(configPathOpt);
         if (!existsSync(configPath)) {
             throw new Error(`[gaon db] --config 로 지정한 파일이 없습니다: ${configPath}\n` +
                 `→ 경로를 확인하거나 --config 없이 실행해 cwd/gaon.config.ts 를 쓰세요.`);
@@ -83,12 +83,25 @@ export async function resolveDbTarget(opts) {
             throw new Error(`[gaon db] --config 파일의 default export 가 객체가 아닙니다: ${configPath}\n` +
                 `→ export default defineConfig({ db: { main: { adapter: 'postgres', url: '...' } } }) 형태로 두세요.`);
         }
-        config = mod.default;
-    }
-    else {
-        configPath = findConfigPath(cwd);
-        config = await loadGaonConfig(cwd);
+        return { config: mod.default, configPath };
     }
+    return { config: await loadGaonConfig(cwd), configPath: findConfigPath(cwd) };
+}
+/**
+ * 프로젝트의 커넥션 키 목록을 돌려준다(결정 139 · `gaon db <sub>` 전 커넥션 순회용).
+ * config.db 에 선언된 키 순서 그대로. 선언이 없으면(env-only 프로젝트) `['main']`
+ * 폴백(GAON_DATABASE_URL 관례) — 단일 커넥션 프로젝트의 종전 동작과 정합.
+ */
+export async function listConnectionKeys(cwd, configPath) {
+    const { config } = await loadDbConfig(resolvePath(cwd), configPath);
+    const keys = Object.keys(config.db ?? {});
+    return keys.length ? keys : ['main'];
+}
+export async function resolveDbTarget(opts) {
+    const cwd = resolvePath(opts.cwd);
+    // 사용자가 --config <path> 를 준 경우 그 경로에서 default export 를 로드한다.
+    // 없으면 cwd 관례.
+    const { config, configPath } = await loadDbConfig(cwd, opts.configPath);
     const dbKey = opts.dbKey;
     const cfg = config.db?.[dbKey];
     let connCfg;

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;