@gaonjs/cli 0.13.1 → 0.14.0

package/dist/commands/dev.d.ts

@@ -36,6 +36,8 @@ export interface DevCommandOptions {
     readonly noVueTsc?: boolean;
     /** Docker 자동 기동 끄기(개별 debug · 사용자가 이미 띄운 경우). */
     readonly noDocker?: boolean;
+    /** 프론트 watch 빌드(vite build --watch) 끄기(개별 debug). */
+    readonly noVite?: boolean;
     /** 통합 콘솔 타임스탬프 표시. */
     readonly timestamp?: boolean;
     /** 시그널(테스트 주입 · 기본 process). */

package/dist/commands/dev.js

@@ -30,6 +30,7 @@ import { createDevConsole } from '../dev/console.js';
 import { ensureInfra, composeDown } from '../dev/docker.js';
 import { startTscWatchers, killChild } from '../dev/tsc.js';
 import { startRestartWatcher } from '../dev/watcher.js';
+import { startFrontendBuild } from '../dev/frontend-build.js';
 /**
  * gaon 셀프 경로를 찾는다. 부모가 gaon 으로 실행됐다면 argv[1] 이
  * gaonjs/dist/cli.js (또는 개발 시 packages/gaonjs/src/cli.ts). 자식
@@ -148,6 +149,15 @@ export async function runDevCommand(opts = {}) {
     }
     // ── 2) .gaon 재생성 워처 ─────────────────────────────────────────
     const regen = await startGaonRegen({ cwd, console: consoleOut });
+    // ── 2') 프론트 번들 watch 빌드(결정 67) ─────────────────────────
+    //   serve 가 dist/<앱>/index.html 을 문서 셸로 읽으므로 dev 에서 dist 를
+    //   최신으로 유지한다. 프론트 없는 프로젝트면 no-op.
+    const frontend = opts.noVite
+        ? undefined
+        : startFrontendBuild({
+            cwd,
+            onLog: (line, level) => consoleOut.log('vite', line, level),
+        });
     // ── 3) tsc / vue-tsc 워치 ────────────────────────────────────────
     const tsc = opts.noTsc && opts.noVueTsc
         ? undefined
@@ -243,6 +253,7 @@ export async function runDevCommand(opts = {}) {
                     if (tsc) {
                         await tsc.stop();
                     }
+                    frontend?.close();
                     regen.close();
                     if (stopDocker && composeFile) {
                         consoleOut.log('docker', '--stop-docker · compose down 실행');

package/dist/dev/console.d.ts

@@ -13,7 +13,7 @@
  * 정책상 chalk 는 쓰지 않는다 — 필요한 코드만 직접 쓴다.
  */
 /** 콘솔이 구분하는 로그 소스. */
-export type DevSource = 'dev' | 'docker' | 'serve' | 'watcher' | 'tsc' | 'vue-tsc';
+export type DevSource = 'dev' | 'docker' | 'serve' | 'watcher' | 'tsc' | 'vue-tsc' | 'vite';
 /** 로그 레벨 — human 은 색상 강조, json 은 필드로 실린다. */
 export type DevLevel = 'info' | 'warn' | 'error';
 export interface DevConsoleOptions {

package/dist/dev/console.js

@@ -26,6 +26,7 @@ const SOURCE_COLOR = {
     watcher: '\x1b[36m', // cyan — 파일 감시
     tsc: '\x1b[33m', // yellow — 타입 검사
     'vue-tsc': '\x1b[95m', // bright magenta — vue 전용
+    vite: '\x1b[92m', // bright green — 프론트 빌드
 };
 /** stdout.isTTY 여부 자동 감지(테스트에서는 stream.isTTY 를 봄). */
 function detectTty(stream) {

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

@@ -0,0 +1,14 @@
+export interface FrontendBuildHandle {
+    /** watch 빌드 프로세스를 종료한다. */
+    close(): void;
+}
+export interface StartFrontendBuildOptions {
+    readonly cwd: string;
+    /** 통합 콘솔 로그 훅. */
+    readonly onLog: (line: string, level: 'info' | 'warn' | 'error') => void;
+}
+/**
+ * vite build --watch 를 띄운다. 프론트가 없거나 vite 가 없으면 아무 것도 하지
+ * 않고 no-op 핸들을 돌려준다(dev 는 계속 진행).
+ */
+export declare function startFrontendBuild(opts: StartFrontendBuildOptions): FrontendBuildHandle;

package/dist/dev/frontend-build.js

@@ -0,0 +1,56 @@
+/**
+ * @gaonjs/cli · dev/frontend-build — 프론트 번들 watch 빌드 (결정 67 · M9-C)
+ *
+ * `gaon dev` 는 서버(serve)를 재시작 방식으로 띄운다(§dev.ts). 프론트 번들은
+ * serve 가 dist/<앱>/index.html 을 매 요청 읽어 문서 셸에 이어 붙이므로
+ * (packages/web frontend.ts), dev 에서 그 dist 를 최신으로 유지하려면 vite 를
+ * watch 모드로 함께 돌린다. 진짜 HMR(모듈 교체)은 v1 어댑터 범위 밖이라(§6.4)
+ * "저장 → 재빌드 → 새로고침" 루프를 제공한다.
+ *
+ * fail-open: apps/web/index.html·vite 가 없으면 조용히 건너뛴다(프론트 없는
+ * API 전용 프로젝트도 gaon dev 가 동작해야 한다). vite 실행 실패는 통합
+ * 콘솔에 알리되 dev 전체를 막지 않는다.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+/** 프로젝트에 프론트 진입 HTML(apps/web/index.html)이 있는가. */
+function hasFrontend(cwd) {
+    return existsSync(join(cwd, 'apps', 'web', 'index.html'));
+}
+/** cwd 의 로컬 vite bin 을 찾는다(없으면 undefined — 건너뜀). */
+function resolveViteBin(cwd) {
+    const bin = join(cwd, 'node_modules', '.bin', 'vite');
+    return existsSync(bin) ? bin : undefined;
+}
+/**
+ * vite build --watch 를 띄운다. 프론트가 없거나 vite 가 없으면 아무 것도 하지
+ * 않고 no-op 핸들을 돌려준다(dev 는 계속 진행).
+ */
+export function startFrontendBuild(opts) {
+    const cwd = resolve(opts.cwd);
+    if (!hasFrontend(cwd)) {
+        opts.onLog('프론트 진입 HTML(apps/web/index.html)이 없어 vite 빌드를 건너뜁니다.', 'info');
+        return { close() { } };
+    }
+    const bin = resolveViteBin(cwd);
+    if (!bin) {
+        opts.onLog('vite 를 찾지 못해 프론트 watch 빌드를 건너뜁니다 → pnpm add -D vite @vitejs/plugin-vue', 'warn');
+        return { close() { } };
+    }
+    const child = spawn(bin, ['build', '--watch'], {
+        cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env },
+    });
+    child.stdout?.on('data', (b) => opts.onLog(b.toString().trimEnd(), 'info'));
+    child.stderr?.on('data', (b) => opts.onLog(b.toString().trimEnd(), 'error'));
+    child.on('error', (err) => opts.onLog(`vite 실행 실패: ${err.message}`, 'error'));
+    opts.onLog('▶ vite build --watch — 프론트 번들 감시 (dist/web)', 'info');
+    return {
+        close() {
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill('SIGTERM');
+        },
+    };
+}

package/dist/dev/index.d.ts

@@ -12,5 +12,7 @@ export { startTscWatchers, killChild } from './tsc.js';
 export type { TscWatcherOptions, TscWatcherHandle } from './tsc.js';
 export { startRestartWatcher, isRestartChange, resolveWatchRoots } from './watcher.js';
 export type { RestartWatcherOptions, RestartWatcherHandle } from './watcher.js';
+export { startFrontendBuild } from './frontend-build.js';
+export type { FrontendBuildHandle, StartFrontendBuildOptions } from './frontend-build.js';
 export { createGaonViteServer } from './vite.js';
 export type { GaonViteServer, CreateGaonViteServerOptions } from './vite.js';

package/dist/dev/index.js

@@ -8,5 +8,7 @@ export { createDevConsole } from './console.js';
 export { findComposeFile, isDockerAvailable, inspectCompose, composeUp, composeDown, ensureInfra, } from './docker.js';
 export { startTscWatchers, killChild } from './tsc.js';
 export { startRestartWatcher, isRestartChange, resolveWatchRoots } from './watcher.js';
+// 프론트 번들 watch 빌드 (결정 67)
+export { startFrontendBuild } from './frontend-build.js';
 // Vite dev server 프로그램적 기동 (M3-runtime) — dev.ts 배선은 M1 이 통합.
 export { createGaonViteServer } from './vite.js';

package/dist/templates/project/agents/data.md.tpl

@@ -434,6 +434,33 @@ gaon db seed          # domain/seed.ts 실행
 **파일명 순으로 실제 실행**(replay)하고, ② 그 뒤 스키마 diff 로 나머지를
 적용한다.
 
+- **replay 가 diff 보다 먼저다 — 손작성 마이그는 "아직 diff 가 안 만든 테이블"을
+  참조할 수 없다** (결정 65). 스키마에만 선언돼 있고 아직 DB 에 없는 테이블을
+  FK 로 거는 마이그레이션은 **빈 DB 에서만** `relation "posts" does not exist` 로
+  실패한다(테이블이 이미 있는 개발 DB 에서는 통과 — 그래서 CI·새 클론에서만
+  터진다). 조인 테이블처럼 남의 테이블을 참조해야 하면 **참조 대상도 같은/앞선
+  마이그 파일에서 함께 만든다**:
+
+  ```ts
+  // 20260728_add_tags.ts — posts 를 FK 로 걸려면 posts 가 먼저 존재해야 한다.
+  export async function up(db: Kysely<any>): Promise<void> {
+    await db.schema.createTable('tags')/* … */.execute()
+    await db.schema.createTable('posts_tags')
+      .addColumn('postId', 'bigint', (c) => c.notNull().references('posts.id').onDelete('cascade'))
+      // ↑ posts 가 스키마에만 있고 DB 에 없으면 빈 DB 에서 실패한다.
+      .execute()
+  }
+  ```
+
+  전부 스키마 우선으로 두면(손작성 마이그 없이) diff 가 의존 순서를 알아서
+  잡으므로 이 함정 자체가 없다 — **손작성 마이그는 diff 로 표현 못 하는 것에만**
+  쓴다(rename·백필·수동 DDL).
+
+  **단, 요구받은 마이그레이션을 생략하라는 뜻이 아니다** (결정 66). 지시나 리뷰가
+  마이그레이션 파일을 명시적으로 요구하면 만들되, 위 방식(참조 대상을 같은
+  파일에서 `ifNotExists()` 로 함께 보장)으로 함정을 피한다. 이 규칙은 마이그를
+  **쓸지 말지**가 아니라 **어떻게 쓸지**를 정한다.
+
 - **손작성 마이그는 `db/migrations/<파일명>.ts`** 에 두고 `up(db)`·`down(db)`
   (Kysely) 를 export 한다. **파일명이 곧 버전 키** — `0001_add_posts.ts`
   시퀀스든 `20260724_add_posts.ts` 타임스탬프든 사전순 정렬이 안정적이면 된다

package/dist/templates/project/agents/web.md.tpl

@@ -172,6 +172,35 @@ const ok = await verifyPassword(plain, user.passwordDigest) // Promise<boolean>
   }
   ```
 
+- **세션을 확정·해제하는 것은 `this.auth`** (결정 65). `requireAuth()` 는 이미
+  로그인된 요청을 **지키는** 쪽이고, 로그인 자체를 **성립시키는** 호출은 따로다:
+
+  | 호출 | 하는 일 |
+  |---|---|
+  | `this.auth.user` | 현재 사용자 (`GaonCurrentUser \| null`) |
+  | `this.auth.login(user)` | 세션에 사용자 id 를 심어 로그인 상태로 만든다 |
+  | `this.auth.logout()` | 세션에서 사용자를 지운다 |
+
+  ```ts
+  // 로그인 — 폼 액션의 유일한 render+redirect 혼용 예외(결정 57 보완)
+  async create() {
+    const { email, password } = this.params({ _row: {} as { email: string; password: string } })
+    const user = await User.where('email', '=', email).first()
+    if (!user || !(await verifyPassword(password, user.passwordDigest))) {
+      return this.render('Auth/Login', { error: '이메일 또는 비밀번호가 올바르지 않습니다.', csrf: this.csrfToken() })
+    }
+    this.auth.login(user)                       // 세션 확정
+    return this.redirect('/dashboard')
+  }
+  // 로그아웃 — DELETE /session (페이지에서 router.delete 로 호출 · 결정 64)
+  async destroy() {
+    this.auth.logout()
+    return this.redirect('/session/new')
+  }
+  ```
+
+  API 앱(JWT)은 세션 대신 `this.jwt.issue(user)` / `this.jwt.refresh(token)` 를 쓴다.
+
 - **`this.auth.user`/`requireAuth()` 사용자 타입은 앱이 증강한다** (결정 58).
   `GaonCurrentUser` 는 빈 인터페이스라 증강 없이는 `user.id` 접근이 타입에러다.
   `gaon g auth` 가 `apps/<app>/auth.ts` 에 심는다:

package/dist/templates/project/package.json.tpl

@@ -8,6 +8,7 @@
   },
   "scripts": {
     "dev": "gaon dev",
+    "build": "vite build",
     "serve": "gaon serve",
     "work": "gaon work",
     "hub": "gaon hub",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaonjs/cli",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "Gaon CLI 구현: 제너레이터·스캐폴딩·로드맵 출력 (M1 스텁)",
   "type": "module",
   "license": "MIT",
@@ -28,10 +28,10 @@
     "typescript": "^5.9.0",
     "vite": "^7.0.0",
     "@gaonjs/async": "0.3.1",
-    "@gaonjs/config": "0.3.0",
-    "@gaonjs/core": "0.1.4",
+    "@gaonjs/config": "0.4.0",
+    "@gaonjs/web": "0.6.0",
     "@gaonjs/data": "0.8.4",
-    "@gaonjs/web": "0.5.3",
+    "@gaonjs/core": "0.2.0",
     "@gaonjs/mail": "0.1.1"
   },
   "scripts": {

package/dist/templates/auth/app.ts.tpl

@@ -1,29 +0,0 @@
-// 웹 앱 팩토리 — gaon g auth 스캐폴드. createWebApp 으로 세션·인증을 배선한다.
-import { createApp, type AppSessionOptions } from 'gaonjs/web'
-import appRoutes from './routes.js'
-import session from './controllers/session.js'
-import registration from './controllers/registration.js'
-import dashboard from './controllers/dashboard.js'
-import { loadUser } from './auth.js'
-
-export interface WebAppDeps {
-  /** 세션 설정 — { redisUrl, secret } (또는 redis 인스턴스). */
-  readonly session: AppSessionOptions
-  /** 서명 쿠키/CSRF 용 비밀. */
-  readonly cookieSecret?: string
-}
-
-export function createWebApp(deps: WebAppDeps) {
-  return createApp({
-    apps: [
-      {
-        name: '{{APP_NAME}}',
-        routes: appRoutes,
-        controllers: { session, registration, dashboard },
-        session: deps.session,
-        auth: { loadUser, loginRedirect: '/session/new' },
-      },
-    ],
-    cookieSecret: deps.cookieSecret,
-  })
-}

package/dist/templates/auth/server.ts.tpl

@@ -1,14 +0,0 @@
-// 서버 진입점 — gaon g auth 스캐폴드. `node dist/server.js` 로 실행.
-import { createWebApp } from './apps/{{APP_NAME}}/app.js'
-
-const app = await createWebApp({
-  session: {
-    redisUrl: process.env.REDIS_URL ?? 'redis://127.0.0.1:6379',
-    secret: process.env.SESSION_SECRET ?? 'change-me-to-a-32+char-random-secret!!',
-  },
-  cookieSecret: process.env.COOKIE_SECRET,
-})
-
-const port = Number(process.env.PORT ?? 3000)
-await app.listen({ port, host: '0.0.0.0' })
-console.log(`web 앱이 http://localhost:${port} 에서 실행 중입니다.`)