gencow 0.1.115 → 0.1.117

package/bin/gencow.mjs

@@ -1718,6 +1718,10 @@ ${BOLD}BaaS commands (login required):${RESET}
   ${GREEN}env set K=V${RESET}      Set cloud env var ${DIM}(hot-reload, no restart)${RESET}
   ${GREEN}env unset KEY${RESET}    Remove cloud env var
   ${GREEN}env push${RESET}         Push .env to cloud
+  ${GREEN}files upload${RESET}     Upload files to app storage ${DIM}(--recursive for dirs)${RESET}
+  ${GREEN}files list${RESET}       List uploaded files
+  ${GREEN}files delete${RESET}     Delete uploaded file ${DIM}(--yes to skip confirm)${RESET}
+  ${GREEN}files url${RESET}        Get serving URL for a file
   ${GREEN}domain set${RESET}       Connect custom domain ${DIM}(myapp.com)${RESET}
   ${GREEN}domain status${RESET}    Check domain DNS/TLS status
   ${GREEN}domain remove${RESET}    Disconnect custom domain
@@ -2451,9 +2455,13 @@ ${BOLD}Examples:${RESET}
                     };
                     const tsFiles = scanTsFiles(gencowDir);
                     // query(, mutation(, httpAction( 호출이 하나라도 있으면 실질적 백엔드
+                    // ⚠️ 주석 내 코드 예시를 오탐하지 않도록 주석을 먼저 제거
                     const hasApiCalls = tsFiles.some(f => {
                         const src = readFileSync(f, "utf8");
-                        return /\b(query|mutation|httpAction)\s*\(/.test(src);
+                        const stripped = src
+                            .replace(/\/\/.*$/gm, "")          // 한줄 주석 제거
+                            .replace(/\/\*[\s\S]*?\*\//g, ""); // 블록 주석 제거
+                        return /\b(query|mutation|httpAction)\s*\(/.test(stripped);
                     });
                     if (!hasApiCalls) {
                         isBackendEmpty = true;
@@ -2699,23 +2707,29 @@ ${BOLD}Examples:${RESET}
                         warn("서버 시작 실패 원인:");
                         for (const line of errData.crashLogs) log(`  ${DIM}${line}${RESET}`);
                     }
-                    error("백엔드 배포 실패로 프론트엔드 배포를 건너뜁니다.");
-                    process.exit(1);
-                }
+                    if (targetDir) {
+                        // --static 모드: 백엔드 실패해도 프론트엔드 배포는 계속 진행
+                        warn("백엔드 배포 실패 — 정적 파일 배포는 계속 진행합니다.");
+                        log("");
+                    } else {
+                        error("백엔드 배포 실패로 프론트엔드 배포를 건너뜁니다.");
+                        process.exit(1);
+                    }
+                } else {
+                    const backendData = await backendDeployRes.json();
+                    const backendElapsed = ((Date.now() - backendStartTime) / 1000).toFixed(1);
+                    success(`백엔드 빌드 완료! (${backendElapsed}s)`);
 
-                const backendData = await backendDeployRes.json();
-                const backendElapsed = ((Date.now() - backendStartTime) / 1000).toFixed(1);
-                success(`백엔드 빌드 완료! (${backendElapsed}s)`);
+                    // Health check — 백엔드 앱 URL로 실제 응답 확인
+                    if (backendData.url) {
+                        await this._verifyAppReady(backendData.url, appId);
+                    }
 
-                // Health check — 백엔드 앱 URL로 실제 응답 확인
-                if (backendData.url) {
-                    await this._verifyAppReady(backendData.url, appId);
+                    info(`URL:   ${backendData.url}`);
+                    info(`Hash:  ${backendData.bundleHash}`);
+                    updateEnvLocalUrl(backendData.url);
+                    log("");
                 }
-
-                info(`URL:   ${backendData.url}`);
-                info(`Hash:  ${backendData.bundleHash}`);
-                updateEnvLocalUrl(backendData.url);
-                log("");
                 log(`  ${BOLD}── 프론트엔드 배포 ──────────────────${RESET}\n`);
             }
 
@@ -2971,6 +2985,297 @@ ${BOLD}Examples:${RESET}
         },
 
 
+    // ── files ─────────────────────────────────────────────
+    async files(...filesArgs) {
+            const subCmd = filesArgs[0] || "help";
+            const restArgs = filesArgs.slice(1);
+
+            // help는 인증/앱 정보 없이도 표시
+            if (subCmd === "help" || subCmd === "--help" || subCmd === "-h") {
+                log(`\n${BOLD}${CYAN}gencow files${RESET} — 파일 관리\n`);
+                log(`  ${CYAN}upload${RESET} <경로...> [--recursive|-r]  파일 업로드`);
+                log(`  ${CYAN}list${RESET}                              파일 목록`);
+                log(`  ${CYAN}delete${RESET} <storage_id> [--yes|-y]     파일 삭제`);
+                log(`  ${CYAN}url${RESET}    <storage_id>               서빙 URL 출력`);
+                log(`\n  ${DIM}옵션:${RESET}`);
+                log(`    ${DIM}--app, -a <앱이름>  대상 앱 지정 (기본: gencow.json)${RESET}\n`);
+                return;
+            }
+
+            const creds = requireCreds();
+
+            // 앱 ID 결정 + --app 플래그 위치 추적 (paths 필터링용)
+            let appId = null;
+            const flagIndices = new Set(); // --app와 그 값의 인덱스
+            for (let i = 0; i < restArgs.length; i++) {
+                if (restArgs[i] === "--app" || restArgs[i] === "-a") {
+                    flagIndices.add(i);
+                    flagIndices.add(i + 1);
+                    appId = restArgs[++i];
+                }
+            }
+
+            if (!appId) {
+                const gencowJsonPath = resolve(process.cwd(), "gencow.json");
+                if (existsSync(gencowJsonPath)) {
+                    const gencowJson = JSON.parse(readFileSync(gencowJsonPath, "utf8"));
+                    appId = gencowJson.appId || gencowJson.appName;
+                }
+            }
+
+            if (!appId) {
+                error("앱 ID를 찾을 수 없습니다. gencow deploy를 먼저 실행하세요.");
+                return;
+            }
+
+            const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50 MB
+
+            function fmtFileSize(bytes) {
+                if (bytes < 1024) return `${bytes} B`;
+                if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+                return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+            }
+
+            function fmtDate(d) {
+                return new Date(d).toLocaleString("ko-KR", {
+                    year: "numeric", month: "2-digit", day: "2-digit",
+                    hour: "2-digit", minute: "2-digit",
+                });
+            }
+
+            /** 파일 서빙 URL 생성 */
+            function getFileUrl(storageId) {
+                return `${getAppUrl(appId, creds.platformUrl)}/api/storage/${storageId}`;
+            }
+
+            /** 단일 파일 업로드 */
+            async function uploadFile(filePath) {
+                const fileName = basename(filePath);
+                const stat = statSync(filePath);
+
+                // 로컬 크기 검증 (서버 왕복 방지)
+                if (stat.size > MAX_FILE_SIZE) {
+                    error(`${fileName}: ${fmtFileSize(stat.size)} — 50MB 제한 초과`);
+                    return null;
+                }
+
+                info(`${fileName} (${fmtFileSize(stat.size)}) 업로드 중...`);
+
+                const fileBuffer = readFileSync(filePath);
+                const blob = new Blob([fileBuffer]);
+
+                const formData = new FormData();
+                formData.append("file", blob, fileName);
+
+                try {
+                    const res = await fetch(
+                        `${creds.platformUrl}/platform/files/upload?appName=${appId}`,
+                        {
+                            method: "POST",
+                            headers: {
+                                "Authorization": `Bearer ${creds.apiKey}`,
+                            },
+                            body: formData,
+                        }
+                    );
+
+                    const data = await res.json().catch(() => ({}));
+                    if (!res.ok) {
+                        error(`${fileName}: ${data.error || res.statusText}`);
+                        return null;
+                    }
+
+                    success(`${fileName} → ${data.storageId}`);
+                    info(`  URL: ${getFileUrl(data.storageId)}`);
+                    return data;
+                } catch (err) {
+                    error(`${fileName}: ${err.message}`);
+                    return null;
+                }
+            }
+
+            /** 디렉토리 재귀 파일 수집 */
+            function collectFiles(dirPath) {
+                const results = [];
+                const entries = readdirSync(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const full = resolve(dirPath, entry.name);
+                    if (entry.isDirectory()) {
+                        results.push(...collectFiles(full));
+                    } else if (entry.isFile()) {
+                        results.push(full);
+                    }
+                }
+                return results;
+            }
+
+            switch (subCmd) {
+                case "upload":
+                case "up": {
+                    const recursive = restArgs.includes("--recursive") || restArgs.includes("-r");
+                    const paths = restArgs.filter((a, i) => !a.startsWith("-") && !flagIndices.has(i));
+
+                    if (paths.length === 0) {
+                        error("사용법: gencow files upload <파일|폴더 경로...> [--recursive|-r]");
+                        return;
+                    }
+
+                    let filesToUpload = [];
+                    for (const p of paths) {
+                        const resolved = resolve(process.cwd(), p);
+                        if (!existsSync(resolved)) {
+                            error(`파일을 찾을 수 없습니다: ${p}`);
+                            continue;
+                        }
+                        const stat = statSync(resolved);
+                        if (stat.isDirectory()) {
+                            if (!recursive) {
+                                error(`${p}는 디렉토리입니다. --recursive (-r) 옵션을 사용하세요.`);
+                                continue;
+                            }
+                            filesToUpload.push(...collectFiles(resolved));
+                        } else {
+                            filesToUpload.push(resolved);
+                        }
+                    }
+
+                    if (filesToUpload.length === 0) {
+                        error("업로드할 파일이 없습니다.");
+                        return;
+                    }
+
+                    log(`\n${BOLD}${CYAN}파일 업로드${RESET} — ${appId}\n`);
+                    info(`${filesToUpload.length}개 파일 업로드 시작...\n`);
+
+                    let uploaded = 0;
+                    let failed = 0;
+                    for (const filePath of filesToUpload) {
+                        const result = await uploadFile(filePath);
+                        if (result) uploaded++;
+                        else failed++;
+                    }
+
+                    log("");
+                    if (uploaded > 0) success(`${uploaded}개 파일 업로드 완료`);
+                    if (failed > 0) warn(`${failed}개 파일 실패`);
+                    break;
+                }
+
+                case "list":
+                case "ls": {
+                    log(`\n${BOLD}${CYAN}파일 목록${RESET} — ${appId}\n`);
+
+                    const res = await fetch(
+                        `${creds.platformUrl}/platform/files/list`,
+                        {
+                            method: "POST",
+                            headers: {
+                                "Authorization": `Bearer ${creds.apiKey}`,
+                                "Content-Type": "application/json",
+                            },
+                            body: JSON.stringify({ appName: appId }),
+                        }
+                    );
+
+                    const data = await res.json().catch(() => []);
+                    if (!res.ok) {
+                        error(data.error || "파일 목록 조회 실패");
+                        return;
+                    }
+
+                    const files = Array.isArray(data) ? data : [];
+                    if (files.length === 0) {
+                        info("저장된 파일이 없습니다.");
+                        log("");
+                        return;
+                    }
+
+                    // 테이블 형식 출력
+                    const idWidth = Math.max(12, ...files.map(f => (f.storage_id || "").length));
+                    const nameWidth = Math.max(8, ...files.map(f => (f.name || "").length).map(l => Math.min(l, 40)));
+
+                    log(`  ${DIM}${"ID".padEnd(idWidth)}  ${"이름".padEnd(nameWidth)}  ${"크기".padStart(10)}  ${"소스".padEnd(10)}  업로드 시각${RESET}`);
+                    log(`  ${DIM}${"─".repeat(idWidth)}  ${"─".repeat(nameWidth)}  ${"─".repeat(10)}  ${"─".repeat(10)}  ${"─".repeat(16)}${RESET}`);
+
+                    for (const f of files) {
+                        const name = (f.name || "").length > 40 ? f.name.slice(0, 37) + "..." : (f.name || "");
+                        const size = fmtFileSize(Number(f.size) || 0).padStart(10);
+                        const source = (f.uploaded_by || "api").padEnd(10);
+                        const date = f.created_at ? fmtDate(f.created_at) : "-";
+                        log(`  ${(f.storage_id || "").padEnd(idWidth)}  ${name.padEnd(nameWidth)}  ${size}  ${source}  ${date}`);
+                    }
+                    log(`\n  ${DIM}총 ${files.length}개 파일${RESET}\n`);
+                    break;
+                }
+
+                case "delete":
+                case "rm": {
+                    const storageId = restArgs.find((a, i) => !a.startsWith("-") && !flagIndices.has(i));
+                    if (!storageId) {
+                        error("사용법: gencow files delete <storage_id>");
+                        return;
+                    }
+
+                    // 확인 프롬프트
+                    const skipConfirm = restArgs.includes("--yes") || restArgs.includes("-y");
+                    if (!skipConfirm) {
+                        const { createInterface } = await import("readline");
+                        const rl = createInterface({ input: process.stdin, output: process.stdout });
+                        const answer = await new Promise(resolve => {
+                            rl.question(`\n  ${YELLOW}정말 삭제하시겠습니까?${RESET} ${DIM}${storageId}${RESET} (y/N): `, a => {
+                                rl.close();
+                                resolve(a.trim().toLowerCase());
+                            });
+                        });
+                        if (answer !== "y" && answer !== "yes") {
+                            info("삭제를 취소했습니다.");
+                            return;
+                        }
+                    }
+
+                    const res = await fetch(
+                        `${creds.platformUrl}/platform/files/delete`,
+                        {
+                            method: "POST",
+                            headers: {
+                                "Authorization": `Bearer ${creds.apiKey}`,
+                                "Content-Type": "application/json",
+                            },
+                            body: JSON.stringify({ appName: appId, storageId }),
+                        }
+                    );
+
+                    const data = await res.json().catch(() => ({}));
+                    if (res.ok && data.success) {
+                        success(`파일 삭제 완료: ${storageId}`);
+                    } else {
+                        error(`삭제 실패: ${data.error || res.statusText}`);
+                    }
+                    break;
+                }
+
+                case "url": {
+                    const storageId = restArgs.find((a, i) => !a.startsWith("-") && !flagIndices.has(i));
+                    if (!storageId) {
+                        error("사용법: gencow files url <storage_id>");
+                        return;
+                    }
+                    log(getFileUrl(storageId));
+                    break;
+                }
+
+                default:
+                    if (subCmd !== "help") error(`알 수 없는 하위 명령: ${subCmd}`);
+                    log(`\n${BOLD}${CYAN}gencow files${RESET} — 파일 관리\n`);
+                    log(`  ${CYAN}upload${RESET} <경로...> [--recursive|-r]  파일 업로드`);
+                    log(`  ${CYAN}list${RESET}                              파일 목록`);
+                    log(`  ${CYAN}delete${RESET} <storage_id> [--yes|-y]     파일 삭제`);
+                    log(`  ${CYAN}url${RESET}    <storage_id>               서빙 URL 출력`);
+                    log(`\n  ${DIM}옵션:${RESET}`);
+                    log(`    ${DIM}--app, -a <앱이름>  대상 앱 지정 (기본: gencow.json)${RESET}\n`);
+            }
+        },
+
     // ── backup ─────────────────────────────────────────────
     async backup(...backupArgs) {
             const creds = requireCreds();

package/core/index.js

@@ -1800,11 +1800,13 @@ function parseArgs(schema, args) {
     }
   }
   if (typeof schema === "object" && schema !== null) {
+    const schemaKeys = Object.keys(schema);
+    if (schemaKeys.length === 0) return args;
     if (typeof args !== "object" || args === null) {
       throw new GencowValidationError("Expected an object for arguments");
     }
     const result = {};
-    for (const key in schema) {
+    for (const key of schemaKeys) {
       const validator = schema[key];
       if (validator && typeof validator.parse === "function") {
         try {