gencow 0.1.78 → 0.1.80

package/bin/gencow.mjs

@@ -1738,17 +1738,15 @@ ${BOLD}Examples:${RESET}
                 process.exit(1);
             }
 
-            // 1-0. Pre-deploy dependency audit
+            // 1-0. Pre-deploy dependency audit (informational — user deps auto-installed)
             if (!forceDeploy) {
                 try {
                     const { auditDeployDependencies, formatAuditError } = await import("../lib/deploy-auditor.mjs");
                     const entryPoint = resolve(process.cwd(), "gencow", "index.ts");
                     if (existsSync(entryPoint)) {
                         const auditResult = await auditDeployDependencies(entryPoint);
-                        if (!auditResult.passed) {
-                            log(formatAuditError(auditResult));
-                            process.exit(1);
-                        }
+                        const auditMsg = formatAuditError(auditResult);
+                        if (auditMsg) log(auditMsg);
                     }
                 } catch (auditErr) {
                     warn(`의존성 검사 스킵: ${auditErr.message}`);
@@ -2013,17 +2011,15 @@ ${BOLD}Examples:${RESET}
             if (shouldDeployBackend) {
                 log(`  ${BOLD}── 백엔드 배포 ──────────────────────${RESET}\n`);
 
-                // 1-0. Pre-deploy dependency audit
+                // 1-0. Pre-deploy dependency audit (informational — user deps auto-installed)
                 if (!forceDeploy) {
                     try {
                         const { auditDeployDependencies, formatAuditError } = await import("../lib/deploy-auditor.mjs");
                         const entryPoint = resolve(backendRoot, "gencow", "index.ts");
                         if (existsSync(entryPoint)) {
                             const auditResult = await auditDeployDependencies(entryPoint);
-                            if (!auditResult.passed) {
-                                log(formatAuditError(auditResult));
-                                process.exit(1);
-                            }
+                            const auditMsg = formatAuditError(auditResult);
+                            if (auditMsg) log(auditMsg);
                         }
                     } catch (auditErr) {
                         warn(`의존성 검사 스킵: ${auditErr.message}`);

package/lib/__tests__/deploy-auditor.test.ts

@@ -78,36 +78,38 @@ describe("isNodeBuiltin", () => {
 });
 
 describe("formatAuditError", () => {
-    it("returns empty string when passed", () => {
-        expect(formatAuditError({ passed: true, unsupported: [] })).toBe("");
+    it("returns empty string when no user deps", () => {
+        expect(formatAuditError({ passed: true, unsupported: [], hasUserDependencies: false })).toBe("");
     });
 
-    it("formats error with unsupported packages", () => {
+    it("formats info message with user dependencies (auto-install)", () => {
         const result = {
-            passed: false,
+            passed: true,
             unsupported: [
                 { packageName: "langfuse", importedFrom: "gencow/llmActions.ts" },
                 { packageName: "cheerio", importedFrom: "gencow/crawlPipeline.ts" },
             ],
+            hasUserDependencies: true,
         };
         const output = formatAuditError(result);
-        expect(output).toContain("DEPLOY BLOCKED");
+        // 이제 차단이 아닌 안내 메시지
         expect(output).toContain("langfuse");
-        expect(output).toContain("gencow/llmActions.ts");
         expect(output).toContain("cheerio");
-        expect(output).toContain("gencow/crawlPipeline.ts");
-        expect(output).toContain("--force");
+        expect(output).toContain("자동 설치");
+        // 차단 메시지가 없어야 함
+        expect(output).not.toContain("DEPLOY BLOCKED");
+        expect(output).not.toContain("--force");
     });
 
-    it("includes platform package list in error", () => {
+    it("shows rollback info in message", () => {
         const result = {
-            passed: false,
+            passed: true,
             unsupported: [{ packageName: "moment", importedFrom: "gencow/utils.ts" }],
+            hasUserDependencies: true,
         };
         const output = formatAuditError(result);
-        expect(output).toContain("@gencow/core");
-        expect(output).toContain("drizzle-orm");
-        expect(output).toContain("better-auth");
+        expect(output).toContain("moment");
+        expect(output).toContain("롤백");
     });
 });
 

package/lib/deploy-auditor.mjs

@@ -1,18 +1,18 @@
 /**
- * Deploy Auditor — Pure function for pre-deploy dependency validation.
+ * Deploy Auditor — Pre-deploy dependency analysis (informational).
  *
- * Checks if user code imports packages that are not available
- * in the Gencow cloud runtime. This prevents "new version unhealthy"
- * deploy failures caused by missing third-party dependencies.
+ * Detects user third-party dependencies that need auto-install on the
+ * Gencow cloud runtime. User deps are installed via `bun install` on
+ * the server during provisioning.
  *
  * How it works:
  *   1. Uses esbuild metafile to extract all external imports
  *   2. Filters out relative imports, Node built-ins, and platform packages
- *   3. Returns list of unsupported packages with source file info
+ *   3. Returns list of user dependencies with source file info
  *
  * Usage:
  *   const result = await auditDeployDependencies("./gencow/index.ts");
- *   if (!result.passed) { ... block deploy ... }
+ *   if (result.hasUserDependencies) { ... show info ... }
  */
 import { build } from "esbuild";
 
@@ -61,8 +61,9 @@ const NODE_BUILTINS = new Set([
 
 /**
  * @typedef {Object} AuditResult
- * @property {boolean} passed - true if no unsupported deps found
- * @property {UnsupportedDep[]} unsupported - List of unsupported packages
+ * @property {boolean} passed - Always true (audit is informational, not blocking)
+ * @property {UnsupportedDep[]} unsupported - List of user third-party packages
+ * @property {boolean} hasUserDependencies - true if user deps detected (will be auto-installed)
  */
 
 /**
@@ -178,43 +179,31 @@ export async function auditDeployDependencies(entryPoint) {
     }
 
     return {
-        passed: unsupported.length === 0,
+        passed: true,  // Always pass — user deps are auto-installed on server
         unsupported,
+        hasUserDependencies: unsupported.length > 0,
     };
 }
 
 /**
- * Format audit result as a human-readable error message for CLI output.
+ * Format audit result as a human-readable info message for CLI output.
+ * Shows which user dependencies will be auto-installed on the cloud.
  *
  * @param {AuditResult} result
- * @returns {string} Formatted message (empty string if passed)
+ * @returns {string} Formatted message (empty string if no user deps)
  */
 export function formatAuditError(result) {
-    if (result.passed) return "";
+    if (!result.hasUserDependencies) return "";
 
+    const pkgNames = result.unsupported.map(d => d.packageName);
     const lines = [
         "",
-        "╔═══════════════════════════════════════════════════════════════╗",
-        "║  ⛔ DEPLOY BLOCKED — Unsupported Dependencies Detected       ║",
-        "╚═══════════════════════════════════════════════════════════════╝",
-        "",
-        "  The following packages are NOT available in the Gencow cloud runtime:",
+        `  📦 서드파티 패키지 감지: ${pkgNames.join(", ")}`,
+        `     → 클라우드 배포 시 자동 설치됩니다.`,
+        `     → 설치 실패 시 배포가 롤백됩니다.`,
         "",
     ];
 
-    for (const dep of result.unsupported) {
-        lines.push(`    ✗  ${dep.packageName} (imported in ${dep.importedFrom})`);
-    }
-
-    lines.push("");
-    lines.push("  Gencow 클라우드에서 사용 가능한 패키지:");
-    lines.push("    @gencow/core, drizzle-orm, better-auth, postgres, hono, ai, zod");
-    lines.push("");
-    lines.push("  해결 방법:");
-    lines.push("    1. 해당 패키지 사용을 제거하거나 동적 import (try/catch)로 변경");
-    lines.push("    2. gencow deploy --force 로 강제 배포 (서버 크래시 위험)");
-    lines.push("");
-
     return lines.join("\n");
 }
 

package/lib/readme-codegen.mjs

@@ -307,18 +307,16 @@ export function buildAiPrompt(apiObj, namespaces) {
     md += `- .env 파일은 로컬 개발 전용이야. 클라우드에는 gencow env push로 올려.\n`;
     md += `- 로컬 dev 서버에 설정하려면 \`gencow env set --local KEY=VALUE\`를 써.\n`;
     md += `\n`;
-    md += `⚠️ 패키지 제한 (중요):\n`;
-    md += `- gencow 클라우드에서 사용 가능한 npm 패키지는 아래만 해당돼:\n`;
-    md += `  @gencow/core, drizzle-orm, better-auth, postgres, hono, ai, @ai-sdk/openai, zod, esbuild\n`;
-    md += `- npm install로 추가한 서드파티 패키지(langfuse, openai, axios, cheerio 등)는 배포 시 사용 불가.\n`;
-    md += `  배포하면 "new version unhealthy" 에러가 발생해.\n`;
+    md += `⚠️ 패키지 정보:\n`;
+    md += `- npm install로 추가한 서드파티 패키지(langfuse, axios, cheerio 등)는 배포 시 자동 설치돼.\n`;
+    md += `- 단, child_process, vm, os, cluster, worker_threads 모듈은 보안상 차단됨.\n`;
     md += `\n`;
     md += `⚠️ 해싱/암호화:\n`;
-    md += `- node:crypto 모듈은 사용 불가. 해싱이 필요하면 Web Crypto API를 사용해:\n`;
+    md += `- node:crypto 모듈도 사용 가능하지만, 더 가볍게 Web Crypto API(crypto.subtle)도 추천:\n`;
     md += `  const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));\n`;
     md += `  const hex = [...new Uint8Array(hash)].map(b => b.toString(16).padStart(2, "0")).join("");\n`;
     md += `- 직접 구현한 simpleHash 같은 32비트 해시는 충돌 위험이 있으니 SHA-256을 사용해.\n`;
-    md += `- AI 호출이 필요하면 ctx.ai.chat()을 사용해. OpenAI SDK를 직접 설치하지 마.\n`;
+    md += `- AI 호출이 필요하면 ctx.ai.chat()을 사용해. OpenAI SDK를 직접 설치해도 되지만 ctx.ai.chat()이 더 간편해.\n`;
     md += `\`\`\`\n\n`;
     return md;
 }
@@ -401,9 +399,10 @@ export function buildDeploySection() {
     md += `\`\`\`\n\n`;
     md += `> ⚠️ 프론트엔드에서 API를 호출하려면 빌드 시 \`VITE_API_URL\`을 반드시 설정하세요.\n\n`;
 
-    // 패키지 제한 경고
-    md += `### ⚠️ 서드파티 npm 패키지 제한\n\n`;
-    md += `Gencow 클라우드 런타임에서 사용 가능한 패키지는 다음으로 제한됩니다:\n\n`;
+    // 서드파티 패키지 안내 (자동 설치)
+    md += `### 📦 서드파티 npm 패키지\n\n`;
+    md += `\`npm install\`로 추가한 서드파티 패키지는 배포 시 **자동으로 설치**됩니다.\n\n`;
+    md += `클라우드 기본 제공 패키지 (별도 설치 불필요):\n\n`;
     md += `| 패키지 | 설명 |\n`;
     md += `| :--- | :--- |\n`;
     md += `| \`@gencow/core\` | Gencow 핵심 프레임워크 |\n`;
@@ -413,9 +412,8 @@ export function buildDeploySection() {
     md += `| \`hono\` | HTTP 프레임워크 |\n`;
     md += `| \`ai\`, \`@ai-sdk/*\` | AI SDK |\n`;
     md += `| \`zod\` | 밸리데이션 |\n\n`;
-    md += `> ⚠️ \`npm install\`로 추가한 서드파티 패키지(langfuse, openai, axios 등)는 배포 시 사용할 수 없습니다.\n`;
-    md += `> 배포하면 "new version unhealthy" 에러가 발생합니다.\n`;
-    md += `> AI 호출이 필요하면 \`ctx.ai.chat()\`을 사용하세요.\n\n`;
+    md += `> 📦 langfuse, axios, cheerio 등 추가 패키지도 \`npm install\` 후 \`gencow deploy\`하면 자동 설치됩니다.\n`;
+    md += `> ⛔ \`child_process\`, \`vm\`, \`os\`, \`cluster\`, \`worker_threads\` 모듈은 보안상 차단됩니다.\n\n`;
     md += `### CORS 설정\n\n`;
     md += `- \`*.gencow.app\` 서브도메인 간 요청은 **자동 허용**됩니다.\n`;
     md += `- 커스텀 도메인에서 API를 호출하려면 환경변수를 설정하세요:\n\n`;
@@ -424,23 +422,21 @@ export function buildDeploySection() {
     md += `\`\`\`\n\n`;
 
     // 해싱/암호화 대안
-    md += `### 🔐 해싱/암호화 (node:crypto 대안)\n\n`;
-    md += `Gencow 클라우드에서 \`node:crypto\` 모듈은 사용할 수 없습니다.\n`;
-    md += `해싱이 필요하면 **Web Crypto API** (\`crypto.subtle\`)를 사용하세요:\n\n`;
+    md += `### 🔐 해싱/암호화\n\n`;
+    md += `\`node:crypto\` 모듈 사용 가능합니다. Web Crypto API도 대안으로 사용할 수 있습니다:\n\n`;
     md += `\`\`\`typescript\n`;
-    md += `// SHA-256 해싱 (node:crypto 대신 Web Crypto API)\n`;
+    md += `// SHA-256 해싱 (Web Crypto API)
+`;
     md += `async function sha256(text: string): Promise<string> {\n`;
     md += `    const data = new TextEncoder().encode(text);\n`;
     md += `    const hash = await crypto.subtle.digest("SHA-256", data);\n`;
     md += `    return [...new Uint8Array(hash)]\n`;
     md += `        .map(b => b.toString(16).padStart(2, "0"))\n`;
     md += `        .join("");\n`;
-    md += `}\n\n`;
-    md += `// 사용 예: 중복 탐지, 캐시 키, 콘텐츠 해싱\n`;
-    md += `const articleHash = await sha256(article.url + article.title);\n`;
+    md += `}\n`;
     md += `\`\`\`\n\n`;
     md += `> ⚠️ 직접 구현한 \`simpleHash()\` 같은 32비트 해시는 대량 데이터에서 충돌 위험이 있습니다.\n`;
-    md += `> 반드시 SHA-256을 사용하세요 (2^256 가능 값, 사실상 충돌 0).\n\n`;
+    md += `> 반드시 SHA-256을 사용하세요.\n\n`;
 
     return md;
 }

package/package.json

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

package/server/index.js

@@ -71681,16 +71681,8 @@ async function consumeInviteCode(code) {
 // ../server/src/auditor.ts
 var esbuild = __toESM(require_main(), 1);
 var FORBIDDEN_MODULES = /* @__PURE__ */ new Set([
-  "fs",
-  "fs/promises",
-  "node:fs",
-  "node:fs/promises",
   "child_process",
   "node:child_process",
-  "net",
-  "node:net",
-  "tls",
-  "node:tls",
   "dgram",
   "node:dgram",
   "os",
@@ -71699,14 +71691,6 @@ var FORBIDDEN_MODULES = /* @__PURE__ */ new Set([
   "node:cluster",
   "worker_threads",
   "node:worker_threads",
-  "http",
-  "node:http",
-  "https",
-  "node:https",
-  "http2",
-  "node:http2",
-  "readline",
-  "node:readline",
   "v8",
   "node:v8",
   "vm",
@@ -71766,6 +71750,15 @@ var ALLOWED_NODE_MODULES = /* @__PURE__ */ new Set([
   "node:timers",
   "node:timers/promises",
   "node:zlib",
+  // 서드파티 패키지 호환을 위해 허용 (nsjail이 보안 담당)
+  "node:fs",
+  "node:fs/promises",
+  "node:http",
+  "node:https",
+  "node:http2",
+  "node:net",
+  "node:tls",
+  "node:readline",
   // non-prefixed equivalents
   "crypto",
   "path",
@@ -71778,7 +71771,15 @@ var ALLOWED_NODE_MODULES = /* @__PURE__ */ new Set([
   "querystring",
   "string_decoder",
   "timers",
-  "zlib"
+  "zlib",
+  "fs",
+  "fs/promises",
+  "http",
+  "https",
+  "http2",
+  "net",
+  "tls",
+  "readline"
 ]);
 function isAllowedNodeModule(moduleName) {
   return ALLOWED_NODE_MODULES.has(moduleName);
@@ -72553,6 +72554,38 @@ function getOriginalEnvValue(key) {
 }
 
 // ../server/src/index.ts
+var FUNCTION_TIMEOUTS = {
+  query: 3e4,
+  // 30초
+  mutation: 3e4,
+  // 30초
+  httpAction: 3e5,
+  // 5분
+  cron: 6e5
+  // 10분
+};
+async function executeWithTimeout(fn, type, functionName) {
+  const timeoutMs = FUNCTION_TIMEOUTS[type];
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const result = await Promise.race([
+      fn(),
+      new Promise((_, reject) => {
+        controller.signal.addEventListener("abort", () => {
+          const err = new Error(
+            `Function "${functionName}" exceeded ${timeoutMs / 1e3}s time limit. Use ctx.scheduler.runAfter() for long-running tasks.`
+          );
+          err.code = "FUNCTION_TIMEOUT";
+          reject(err);
+        });
+      })
+    ]);
+    return result;
+  } finally {
+    clearTimeout(timer);
+  }
+}
 var METERING_URL = process.env.GENCOW_METERING_URL;
 var IS_BAAS = !!METERING_URL;
 var INTERNAL_TOKEN = process.env.GENCOW_INTERNAL_TOKEN || "";
@@ -72930,7 +72963,9 @@ async function main() {
         }
       }
       const headers = new Headers();
-      headers.set("Content-Type", file3.type || "application/octet-stream");
+      const rawType = file3.type || "application/octet-stream";
+      const needsCharset = (rawType.startsWith("text/") || rawType === "application/json") && !rawType.includes("charset");
+      headers.set("Content-Type", needsCharset ? `${rawType}; charset=utf-8` : rawType);
       const ext = resolved.split(".").pop()?.toLowerCase() || "";
       if (["js", "css", "png", "jpg", "jpeg", "gif", "svg", "ico", "woff", "woff2"].includes(ext)) {
         headers.set("Cache-Control", "public, max-age=31536000, immutable");
@@ -73207,7 +73242,11 @@ async function main() {
     for (const [name21, mut] of mutationMap) {
       scheduler.registerAction(name21, async (args) => {
         const ctx = buildCtx({ get: () => null });
-        await mut.handler(ctx, args ?? {});
+        await executeWithTimeout(
+          () => mut.handler(ctx, args ?? {}),
+          "mutation",
+          name21
+        );
       });
     }
     console.log(`[scheduler] Registered ${mutationMap.size} mutation(s) as scheduler actions`);
@@ -73234,7 +73273,11 @@ async function main() {
               if (mut) {
                 try {
                   const ctx = buildCtx({ get: () => null });
-                  await mut.handler(ctx, {});
+                  await executeWithTimeout(
+                    () => mut.handler(ctx, {}),
+                    "cron",
+                    actionName
+                  );
                   console.log(`[scheduler] Cron action "${actionName}" (mutation) completed`);
                 } catch (err) {
                   const msg = err instanceof Error ? err.message : JSON.stringify(err, null, 2);
@@ -73272,7 +73315,11 @@ async function main() {
     }
     try {
       const validatedArgs = parseArgs(queryDef.argsSchema, args);
-      const result = await queryDef.handler(ctx, validatedArgs);
+      const result = await executeWithTimeout(
+        () => queryDef.handler(ctx, validatedArgs),
+        "query",
+        name21
+      );
       if (queryDef.isPublic && !IS_BAAS && Array.isArray(result) && result.length >= 100) {
         if (!publicQueryWarned.has(name21)) {
           publicQueryWarned.add(name21);
@@ -73282,8 +73329,8 @@ async function main() {
       }
       return c.json(result);
     } catch (err) {
-      const status = err instanceof GencowValidationError ? 400 : 500;
-      return c.json({ error: err.message }, status);
+      const status = err?.code === "FUNCTION_TIMEOUT" ? 408 : err instanceof GencowValidationError ? 400 : 500;
+      return c.json({ error: err.message, ...err?.code ? { code: err.code } : {} }, status);
     }
   }).post("/mutation", async (c) => {
     let name21, args;
@@ -73309,12 +73356,16 @@ async function main() {
     }
     try {
       const validatedArgs = parseArgs(mut.argsSchema, args);
-      const result = await mut.handler(ctx, validatedArgs);
+      const result = await executeWithTimeout(
+        () => mut.handler(ctx, validatedArgs),
+        "mutation",
+        name21
+      );
       await invalidateQueries(mut.invalidates, ctx);
       return c.json(result, 201);
     } catch (err) {
-      const status = err instanceof GencowValidationError ? 400 : 500;
-      return c.json({ error: err.message }, status);
+      const status = err?.code === "FUNCTION_TIMEOUT" ? 408 : err instanceof GencowValidationError ? 400 : 500;
+      return c.json({ error: err.message, ...err?.code ? { code: err.code } : {} }, status);
     }
   }).get("/storage/:id", storageRoutes(storage, rawSql, storageDir));
   const queryNames = getRegisteredQueries();
@@ -73379,7 +73430,11 @@ async function main() {
           text: () => c.req.text()
         };
         try {
-          const result = await action.handler(ctx, req);
+          const result = await executeWithTimeout(
+            () => action.handler(ctx, req),
+            "httpAction",
+            `${action.method} ${action.path}`
+          );
           if (result instanceof Response) {
             return result;
           }