gencow 0.1.124 → 0.1.126

package/bin/gencow.mjs

@@ -677,6 +677,11 @@ function cleanupOldBackups(backupDir, keep = 3) {
     } catch { /* ignore */ }
 }
 
+function isLocalDbTarget(args) {
+    if (process.env.GENCOW_LOCAL === "1") return true;
+    return Array.isArray(args) && args.includes("--local");
+}
+
 // ─── Commands ─────────────────────────────────────────────
 
 const commands = {
@@ -783,8 +788,8 @@ const commands = {
             "@gencow/core": "latest",
             "@electric-sql/pglite": "^0.3.15",
             "better-auth": "^1.5.1",
-            "drizzle-orm": "^0.44.0",
-            "drizzle-kit": "^0.31.0",
+            "drizzle-orm": "^0.45.1",
+            "drizzle-kit": "^0.31.4",
             "postgres": "^3.4.8",
         };
         const pkgJsonPath = resolve(projectDir, "package.json");
@@ -1049,9 +1054,81 @@ ${hasPrompt ? `
     },
 
     // ── db:reset ─────────────────────────────────────────
-    async "db:reset"() {
-            info(`db:reset is ${BOLD}coming soon${RESET}.`);
-            info(`${DIM}Use Gencow Dashboard for cloud DB management.${RESET}\n`);
+    // TRUNCATE all user tables + seed.ts 실행.
+    // 로컬 전용: Cloud DB reset은 위험하므로 CLI에서 미지원 (Dashboard에서만 가능)
+    // 사용: gencow db:reset --local
+    async "db:reset"(...args) {
+            const config = loadConfig();
+            const cwd = process.cwd();
+            const isLocal = isLocalDbTarget(args);
+
+            if (!isLocal) {
+                error("db:reset only applies to the local database.");
+                info(`${DIM}Cloud DB reset is only available via Dashboard (data protection).${RESET}`);
+                info(`${DIM}For local DB: set ${GREEN}GENCOW_LOCAL=1${RESET}${DIM} and run this command again.${RESET}`);
+                log("");
+                return;
+            }
+
+            const port = process.env.PORT || config.port || 5456;
+
+            log(`\n${BOLD}${CYAN}Gencow DB Reset${RESET}\n`);
+
+            let serverAlive = false;
+            try {
+                const res = await fetch(`http://localhost:${port}/_admin/status`, { signal: AbortSignal.timeout(2000) });
+                serverAlive = res.ok;
+            } catch { /* 서버 꺼져있음 */ }
+
+            if (serverAlive) {
+                info(`Server detected on :${port} — using API reset (TRUNCATE + seed)`);
+                log("");
+
+                try {
+                    const res = await fetch(`http://localhost:${port}/_admin/reset`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({ confirm: "delete all data" }),
+                    });
+                    const data = await res.json();
+
+                    if (!res.ok) {
+                        error(`Reset failed: ${data.error || "Unknown error"}`);
+                        log("");
+                        return;
+                    }
+
+                    success(`TRUNCATE done: ${data.truncated?.length || 0} tables`);
+                    if (data.truncated?.length > 0) {
+                        info(`  ${DIM}${data.truncated.join(", ")}${RESET}`);
+                    }
+                    if (data.seeded) {
+                        success(`Seed completed ✓`);
+                    } else {
+                        info(`${DIM}No seed.ts found — skipping${RESET}`);
+                    }
+                } catch (e) {
+                    error(`Server connection failed: ${e.message}`);
+                }
+            } else {
+                const dbPath = resolve(cwd, config.db.url);
+                if (existsSync(dbPath)) {
+                    const backupDir = resolve(cwd, ".gencow", "backups");
+                    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+                    const backupPath = resolve(backupDir, ts);
+                    mkdirSync(backupPath, { recursive: true });
+                    cpSync(dbPath, backupPath, { recursive: true });
+                    success(`Backup created: .gencow/backups/${ts}`);
+
+                    cleanupOldBackups(backupDir, 3);
+
+                    rmSync(dbPath, { recursive: true, force: true });
+                    success("DB deleted — restart with gencow dev:local to create a new one");
+                } else {
+                    info("DB does not exist yet. Run gencow dev:local to get started.");
+                }
+            }
+            log("");
         },
 
     // ── db:seed ──────────────────────────────────────────
@@ -1059,11 +1136,48 @@ ${hasPrompt ? `
     // Cloud-first: 기본=Cloud, --local=로컬
     async "db:seed"(...args) {
             const config = loadConfig();
-            const isLocal = args.includes("--local");
+            const isLocal = isLocalDbTarget(args);
 
             if (isLocal) {
-                info(`Local db:seed is ${BOLD}coming soon${RESET}.`);
-                info(`${DIM}Use cloud mode (default): gencow db:seed${RESET}\n`);
+                const port = process.env.PORT || config.port || 5456;
+
+                log(`\n${BOLD}${CYAN}Gencow DB Seed${RESET} ${DIM}(local)${RESET}\n`);
+
+                try {
+                    const statusRes = await fetch(`http://localhost:${port}/_admin/status`, { signal: AbortSignal.timeout(2000) });
+                    if (!statusRes.ok) throw new Error("Server not ready");
+                } catch {
+                    error(`Server not running on :${port}`);
+                    info(`${DIM}Start the local server first: ${GREEN}gencow dev:local${RESET}`);
+                    log("");
+                    return;
+                }
+
+                try {
+                    const res = await fetch(`http://localhost:${port}/_admin/seed`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                    });
+                    const data = await res.json();
+
+                    if (res.status === 404) {
+                        warn("gencow/seed.ts not found");
+                        info(`\n  ${DIM}Create gencow/seed.ts:${RESET}\n`);
+                        log(`  ${DIM}import { tasks } from "./schema";${RESET}`);
+                        log(`  ${DIM}export default async function seed(ctx) {${RESET}`);
+                        log(`  ${DIM}  await ctx.db.insert(tasks).values([${RESET}`);
+                        log(`  ${DIM}    { title: "Hello World" },${RESET}`);
+                        log(`  ${DIM}  ]);${RESET}`);
+                        log(`  ${DIM}};${RESET}`);
+                    } else if (!res.ok) {
+                        error(`Seed failed: ${data.error || "Unknown error"}`);
+                    } else {
+                        success("Seed completed ✓");
+                    }
+                } catch (e) {
+                    error(`Server connection failed: ${e.message}`);
+                }
+                log("");
                 return;
             }
 
@@ -1198,15 +1312,11 @@ ${hasPrompt ? `
             if (devArgs.includes("--verbose")) {
                 process.env.GENCOW_VERBOSE = "true";
             }
-            // --local 플래그: coming soon
-            if (devArgs.includes("--local")) {
-                log(`\n${BOLD}${CYAN}Gencow Dev${RESET} ${DIM}(local)${RESET}\n`);
-                info(`Local development mode is ${BOLD}coming soon${RESET}.`);
-                info(`${DIM}Use cloud mode (default): gencow dev${RESET}\n`);
-                return;
+            const useLocal = process.env.GENCOW_LOCAL === "1" || devArgs.includes("--local");
+            if (useLocal) {
+                const forwarded = devArgs.filter(a => a !== "--local");
+                return commands["dev:local"](...forwarded);
             }
-            // --cloud 하위 호환 (이미 기본이므로 그대로 진행)
-            // 기본 = 클라우드 모드
             return commands["dev:cloud"](...devArgs);
         },
 
@@ -1422,11 +1532,20 @@ ${hasPrompt ? `
     // Cloud-first: 기본=Cloud, --local=로컬
     async "db:push"(...args) {
             const config = loadConfig();
-            const isLocal = args.includes("--local");
+            const isLocal = isLocalDbTarget(args);
 
             if (isLocal) {
-                info(`Local db:push is ${BOLD}coming soon${RESET}.`);
-                info(`${DIM}Use cloud mode (default): gencow db:push${RESET}\n`);
+                let hasDb = !!process.env.DATABASE_URL;
+                if (!hasDb) {
+                    const envPath = resolve(process.cwd(), ".env");
+                    if (existsSync(envPath)) hasDb = readFileSync(envPath, "utf8").includes("DATABASE_URL=");
+                }
+                const targetDb = hasDb ? "local PG" : "local fallback: PGlite";
+                log(`\n${BOLD}${CYAN}Gencow DB Push${RESET} ${DIM}(${targetDb})${RESET}\n`);
+                info("Pushing schema.ts → database (no migration files)...");
+                runInServer("pnpm db:push --force", buildEnv(config));
+                success("Schema pushed!");
+                log(`  ${DIM}Tables are in sync with schema.ts${RESET}\n`);
                 return;
             }
 
@@ -1630,7 +1749,8 @@ ${BOLD}Commands (login required):${RESET}
   ${GREEN}static [dir]${RESET}     Deploy static files ${DIM}(dist/, out/, build/)${RESET}
                      ${DIM}--prod          Deploy to production app${RESET}
                      ${DIM}--force, -f     Skip dependency audit${RESET}
-  ${GREEN}deploy${RESET}           Deploy backend to production ${DIM}(Pro+ only)${RESET}
+  ${GREEN}deploy${RESET}           Deploy backend to cloud ${DIM}(dev by default)${RESET}
+                     ${DIM}--prod          Deploy to production (Pro+ only)${RESET}
                      ${DIM}--rollback      Rollback to previous deployment${RESET}
                      ${DIM}--force, -f     Skip dependency audit${RESET}
   ${GREEN}env list${RESET}         List cloud env vars ${DIM}(--prod for production)${RESET}
@@ -1656,7 +1776,7 @@ ${BOLD}App management:${RESET}
   ${GREEN}app status${RESET}       Show app status
 
   ${DIM}Tip: Most commands support --prod to target the production app.${RESET}
-  ${DIM}     e.g. gencow env list --prod, gencow db:seed --prod${RESET}
+  ${DIM}     e.g. gencow deploy --prod, gencow env list --prod${RESET}
 
 ${BOLD}Examples:${RESET}
   ${DIM}# New project:${RESET}
@@ -1665,9 +1785,11 @@ ${BOLD}Examples:${RESET}
   ${DIM}# Initialize in current directory:${RESET}
   gencow init . --force
 
-  ${DIM}# Deploy to production (Pro+ only):${RESET}
-  gencow login
+  ${DIM}# Deploy to dev:${RESET}
   gencow deploy
+
+  ${DIM}# Deploy to production (Pro+ only):${RESET}
+  gencow deploy --prod
 `);
         },
 
@@ -1865,14 +1987,14 @@ ${BOLD}Examples:${RESET}
             });
         },
 
-    // ── deploy — 프로덕션 배포 (Pro+ only) ───────────────
+    // ── deploy — 클라우드 배포 (dev 기본, --prod로 프로덕션) ──
     async deploy(...deployArgs) {
             const creds = requireCreds();
 
             // gencow.json에서 앱 ID 확인 (자동 생성된 유니크 ID)
             let appId = null;
             let displayName = null;
-            let envTarget = "prod"; // v0.1.120: deploy = prod 기본값
+            let envTarget = "dev"; // v0.1.125: deploy = dev 기본값, --prod로 prod
             let forceDeploy = false; // --force: skip dependency audit
             let isRollback = false; // --rollback: rollback to previous deploy
 
@@ -1939,9 +2061,6 @@ ${BOLD}Examples:${RESET}
             for (let i = 0; i < deployArgs.length; i++) {
                 const a = deployArgs[i];
                 if (a === "--prod") {
-                    // deprecated: deploy는 이미 prod 기본값
-                    warn(`${YELLOW}--prod flag is no longer needed.${RESET}`);
-                    info(`gencow deploy targets production by default.`);
                     envTarget = "prod";
                 }
                 else if (a === "--force" || a === "-f") forceDeploy = true;
@@ -1960,7 +2079,8 @@ ${BOLD}Examples:${RESET}
                     error(`Unknown deploy argument: "${a}"`);
                     log("");
                     info(`Usage: gencow deploy [options]`);
-                    info(`  gencow deploy              Production backend deploy (Pro+)`);
+                    info(`  gencow deploy              Dev backend deploy`);
+                    info(`  gencow deploy --prod       Production backend deploy (Pro+)`);
                     info(`  gencow deploy --rollback   Rollback to previous version`);
                     info(`  gencow deploy logs         View server logs`);
                     info(`  gencow deploy status       Check app status`);
@@ -1996,15 +2116,15 @@ ${BOLD}Examples:${RESET}
 
             // ── Rollback 분기 ─────────────────────────────────────
             if (isRollback) {
-                // prodApp이 있으면 prod 대상 롤백, 없으면 dev 대상 롤백
-                const rollbackTarget = prodAppId || appId;
+                // --prod: prod 앱 롤백, 기본: dev 앱 롤백
+                const rollbackTarget = envTarget === "prod" ? (prodAppId || appId) : appId;
                 if (!rollbackTarget) {
                     error("App not found. Run from the project root with gencow.json.");
                     process.exit(1);
                 }
 
                 log(`\n${BOLD}${CYAN}Gencow Rollback${RESET}\n`);
-                info(`App: ${rollbackTarget}${prodAppId ? " (prod)" : ""}`);
+                info(`App: ${rollbackTarget}${envTarget === "prod" ? " (prod)" : ""}`);
                 log("");
 
                 const rollbackStartTime = Date.now();
@@ -2078,11 +2198,12 @@ ${BOLD}Examples:${RESET}
                             log("");
                             log(`  ${RED}⛔ Production Deploy — Pro plan or higher required${RESET}`);
                             log("");
-                            log(`  ${DIM}gencow deploy is for production deployment.${RESET}`);
+                            log(`  ${DIM}gencow deploy --prod is for production deployment.${RESET}`);
                             log("");
                             log(`  ${BOLD}💡 Dev environment deploy:${RESET}`);
-                            log(`     ${GREEN}gencow dev${RESET}           ${DIM}← Real-time backend + live logs${RESET}`);
-                            log(`     ${GREEN}gencow static dist/${RESET}  ${DIM}← Static file (dist/) deploy${RESET}`);
+                            log(`     ${GREEN}gencow deploy${RESET}          ${DIM}← Deploy backend to dev${RESET}`);
+                            log(`     ${GREEN}gencow dev${RESET}             ${DIM}← Real-time backend + live logs${RESET}`);
+                            log(`     ${GREEN}gencow static dist/${RESET}    ${DIM}← Static file (dist/) deploy${RESET}`);
                             log("");
                             log(`  ${BOLD}🚀 Unlock production deploy:${RESET}`);
                             log(`     ${GREEN}gencow upgrade${RESET}       ${DIM}← Upgrade to Pro plan${RESET}`);
@@ -2124,7 +2245,7 @@ ${BOLD}Examples:${RESET}
             } else {
                 info(`App:    new (auto-generated ID)`);
             }
-            info(`Env:    ${envTarget}`);
+            info(`Env:    ${envTarget}${envTarget === "prod" ? ` ${YELLOW}(production)${RESET}` : ""}`);
             info(`Format: tar.gz`);
             log("");
 

package/core/index.js

@@ -1979,22 +1979,209 @@ function ownerRls(userIdColumn, options) {
 }
 
 // ../core/src/rls-db.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { sql as sql2 } from "drizzle-orm";
-function createRlsDb(db, userId) {
+var gucNameRe = /^app\.[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*$/;
+var RESERVED_VARS_KEYS = /* @__PURE__ */ new Set([
+  "app.current_user_id",
+  "app.current_user_role",
+  "app.tenant_id"
+]);
+function assertSafeGucName(key) {
+  if (!gucNameRe.test(key)) {
+    throw new Error(
+      `createRlsDb: GUC name "${key}" is invalid \u2014 use lowercase app.* names (e.g. app.org_id)`
+    );
+  }
+}
+function rlsSetConfigPairs(rls) {
+  const pairs = [["app.current_user_id", rls.userId]];
+  if (rls.role !== void 0) {
+    pairs.push(["app.current_user_role", rls.role]);
+  }
+  if (rls.tenantId !== void 0) {
+    pairs.push(["app.tenant_id", rls.tenantId]);
+  }
+  if (rls.vars) {
+    for (const [key, value] of Object.entries(rls.vars)) {
+      assertSafeGucName(key);
+      if (RESERVED_VARS_KEYS.has(key)) {
+        throw new Error(
+          `createRlsDb: vars must not set "${key}" \u2014 use userId, role, or tenantId on the context object`
+        );
+      }
+      pairs.push([key, value]);
+    }
+  }
+  return pairs;
+}
+async function forEachSetConfig(rls, setOne) {
+  for (const [name, value] of rlsSetConfigPairs(rls)) {
+    await setOne(name, value);
+  }
+}
+var rlsExecClient = new AsyncLocalStorage();
+function isDrizzleTransactionDb(db) {
+  const d = db;
+  if (typeof d?.rollback === "function") {
+    return true;
+  }
+  const name = d?.constructor?.name;
+  return typeof name === "string" && name.includes("Transaction");
+}
+async function execSetConfig(client, name, value) {
+  if (typeof client?.unsafe === "function") {
+    await client.unsafe(`select set_config($1::text, $2::text, true)`, [name, value]);
+    return;
+  }
+  if (typeof client?.query === "function") {
+    await client.query(`select set_config($1::text, $2::text, true)`, [name, value]);
+    return;
+  }
+  throw new Error(
+    "createRlsDb: unsupported SQL driver (expected Bun SQL, node-pg client/pool, or PGlite)"
+  );
+}
+async function applyRlsSessionVars(client, rls) {
+  await forEachSetConfig(rls, (name, value) => execSetConfig(client, name, value));
+}
+async function injectRlsVarsOnTx(tx, rls) {
+  await forEachSetConfig(
+    rls,
+    (name, value) => tx.execute(sql2`SELECT set_config(${name}, ${value}, true)`)
+  );
+}
+async function withRlsLeasedConnection(leased, rls, fn) {
+  try {
+    await leased.query("begin");
+    await applyRlsSessionVars(leased, rls);
+    const result = await rlsExecClient.run(leased, () => fn(leased));
+    await leased.query("commit");
+    return result;
+  } catch (e) {
+    try {
+      await leased.query("rollback");
+    } catch {
+    }
+    throw e;
+  } finally {
+    leased.release();
+  }
+}
+async function withRlsConnection(session, rls, reuseOuterConnection, fn) {
+  if (reuseOuterConnection) {
+    const c2 = session.client;
+    return rlsExecClient.run(c2, async () => {
+      await applyRlsSessionVars(c2, rls);
+      return fn(c2);
+    });
+  }
+  const c = session.client;
+  const runInner = async (client) => {
+    await applyRlsSessionVars(client, rls);
+    return rlsExecClient.run(client, () => fn(client));
+  };
+  if (typeof c.begin === "function") {
+    return c.begin(runInner);
+  }
+  if (typeof c.transaction === "function") {
+    return c.transaction(runInner);
+  }
+  if (typeof c.connect === "function" && typeof c.query === "function") {
+    const leased = await c.connect();
+    return withRlsLeasedConnection(leased, rls, fn);
+  }
+  return runInner(c);
+}
+function wrapPreparedQuery(pq, session, rls, reuseOuterConnection) {
+  const origExecute = pq.execute.bind(pq);
+  const origAll = pq.all.bind(pq);
+  pq.execute = async (placeholderValues) => {
+    const active = rlsExecClient.getStore();
+    if (active) {
+      const prev = pq.client;
+      pq.client = active;
+      try {
+        return await origExecute(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    }
+    return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
+      const prev = pq.client;
+      pq.client = client;
+      try {
+        return await origExecute(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    });
+  };
+  pq.all = async (placeholderValues) => {
+    const active = rlsExecClient.getStore();
+    if (active) {
+      const prev = pq.client;
+      pq.client = active;
+      try {
+        return await origAll(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    }
+    return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
+      const prev = pq.client;
+      pq.client = client;
+      try {
+        return await origAll(placeholderValues);
+      } finally {
+        pq.client = prev;
+      }
+    });
+  };
+}
+function wrapSession(session, rls, reuseOuterConnection) {
+  return new Proxy(session, {
+    get(sTarget, sProp, sRecv) {
+      if (sProp === "prepareQuery") {
+        return (...args) => {
+          const pq = sTarget.prepareQuery(...args);
+          wrapPreparedQuery(pq, sTarget, rls, reuseOuterConnection);
+          return pq;
+        };
+      }
+      const v2 = Reflect.get(sTarget, sProp, sRecv);
+      return typeof v2 === "function" ? v2.bind(sTarget) : v2;
+    }
+  });
+}
+function createRlsDb(db, rls) {
+  const reuseOuterConnection = isDrizzleTransactionDb(db);
+  const baseSession = db.session;
+  const wrappedSession = wrapSession(baseSession, rls, reuseOuterConnection);
   return new Proxy(db, {
     get(target, prop, receiver) {
+      if (prop === "session") {
+        return wrappedSession;
+      }
+      if (prop === "_") {
+        const inner = target._;
+        return new Proxy(inner, {
+          get(i, p, r) {
+            if (p === "session") return wrappedSession;
+            return Reflect.get(i, p, r);
+          }
+        });
+      }
       if (prop === "transaction") {
         return async (callback, ...rest) => {
           return await target.transaction(async (tx) => {
-            await tx.execute(
-              sql2`SELECT set_config('app.current_user_id', ${userId}, true)`
-            );
+            await injectRlsVarsOnTx(tx, rls);
             return await callback(tx);
           }, ...rest);
         };
       }
       const value = Reflect.get(target, prop, receiver);
-      return typeof value === "function" ? value.bind(target) : value;
+      return typeof value === "function" ? value.bind(receiver) : value;
     }
   });
 }

package/lib/readme-codegen.mjs

@@ -336,7 +336,7 @@ export function buildAiPrompt(apiObj, namespaces) {
     md += `배포 규칙:\n`;
     md += `- 개발: \`npx gencow dev\` (실시간 배포 — gencow/ 변경 감지 → 자동 배포)\n`;
     md += `- 정적 파일 배포: \`npx gencow static dist/\` (dev 환경, 1회성)\n`;
-    md += `- 프로덕션: \`npx gencow deploy\` (Pro+ only, prod 환경)\n`;
+    md += `- 프로덕션: \`npx gencow deploy --prod\` (Pro+ only, prod 환경)\n`;
     md += `- 풀스택 정적: VITE_API_URL=https://{앱ID}.{도메인} npm run build 후 \`npx gencow static dist/\`\n`;
     md += `  → 백엔드가 감지되면 자동으로 백엔드 먼저 배포 후 프론트엔드 배포\n`;
     md += `- 프론트엔드만 배포: \`npx gencow static --no-backend dist/\`\n`;
@@ -524,8 +524,9 @@ export function buildDeploySection() {
     md += `\`\`\`\n\n`;
     md += `### 프로덕션 배포 (Pro+ only)\n`;
     md += `\`\`\`bash\n`;
-    md += `gencow deploy              # 백엔드를 프로덕션에 배포\n`;
-    md += `gencow deploy --static dist/ # 정적 파일을 프로덕션에 배포\n`;
+    md += `gencow deploy              # 백엔드를 dev에 1회성 배포\n`;
+    md += `gencow deploy --prod       # 백엔드를 프로덕션에 배포 (Pro+)\n`;
+    md += `gencow static --prod dist/ # 정적 파일을 프로덕션에 배포\n`;
     md += `\`\`\`\n\n`;
     md += `> ⚠️ 프론트엔드에서 API를 호출하려면 빌드 시 \`VITE_API_URL\`을 반드시 설정하세요.\n\n`;
 
@@ -603,7 +604,7 @@ export function buildDevTips() {
     md += `- \`gencow/\` 폴더 내 파일을 수정하면 \`api.ts\`와 이 README가 **자동으로 재생성**됩니다.\n`;
     md += `- 스키마 변경 후:\n`;
     md += `  - 로컬 개발 + 배포: \`gencow dev\` 실행 시 자동으로 \`drizzle-kit generate\` 실행 → \`gencow/migrations/\` 생성\n`;
-    md += `  - \`gencow deploy\`(프로덕션)도 번들링 전 자동으로 \`drizzle-kit generate\` 실행\n`;
+    md += `  - \`gencow deploy\`도 번들링 전 자동으로 \`drizzle-kit generate\` 실행\n`;
     md += `  - ⚠️ drizzle.config.ts 없으면 generate 실패 경고 출력 (deploy는 계속 진행, 하지만 migrations/ 없으면 플랫폼이 스키마 스킵)\n`;
     md += `- MCP 서버를 사용하면 AI가 이 구조를 자동으로 인식합니다.\n`;
     md += `- 로컬 개발: \`gencow dev\` — 로컬 서버 시작\n`;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gencow",
-    "version": "0.1.124",
+    "version": "0.1.126",
     "description": "Gencow — AI Backend Engine",
     "type": "module",
     "bin": {