@enformik/cli 0.4.0 → 0.6.0

package/dist/commands/site.js

@@ -1,30 +1,43 @@
-import { mkdtempSync, rmSync, statSync } from 'node:fs';
+import { mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { CliError } from '../errors.js';
-import { assertSecureUrl } from '../http.js';
 import { formatBytes } from '../output.js';
-import { precheckSite, DEFAULT_LIMITS } from '../precheck.js';
-import { collectMeta, DeployClient, idempotencyKey, isTerminal, MAX_ARCHIVE_BYTES, sha256File, waitForDeployment } from '../site.js';
+import { precheckSite, parseScanIgnore, DEFAULT_LIMITS } from '../precheck.js';
+import { collectMeta, DeployClient, finalizeDeployment, idempotencyKey, isTerminal, MAX_ARCHIVE_BYTES, sha256File, waitForDeployment } from '../site.js';
 import { writeZipFile } from '../zip.js';
 function client(ctx) {
     const { settings } = ctx;
     if (!settings.consoleUrl)
-        throw new CliError('Konsol adresi yok. `enformik link --console-url https://…` çalıştırın ya da ENFORMIK_CONSOLE_URL tanımlayın.');
+        throw new CliError('No console URL. Run `enformik link --console-url https://…` or set ENFORMIK_CONSOLE_URL.');
     if (!settings.deployKey)
-        throw new CliError('ENFORMIK_DEPLOY_KEY tanımlı değil (konsolda Ek ortamlar → Geliştirici sitesi → Dağıtım anahtarları).');
-    assertSecureUrl(settings.consoleUrl, 'Konsol adresi');
+        throw new CliError('ENFORMIK_DEPLOY_KEY is not set (in the console: Add-on environments → Developer site → Deploy keys).');
     return new DeployClient({ consoleUrl: settings.consoleUrl, deployKey: settings.deployKey, version: ctx.version, fetchImpl: ctx.fetchImpl });
 }
+/** --expect-host verilmişse hedef sitenin ana makine adı eşleşmeli; eşleşmezse hiçbir şey yüklenmeden durur. */
+function assertExpectedHost(ctx, info) {
+    const expect = ctx.flags['expect-host'];
+    if (typeof expect !== 'string')
+        return;
+    let host = '';
+    try {
+        host = new URL(info.url).hostname;
+    }
+    catch { /* adres bozuksa eşleşmez */ }
+    if (expect.toLowerCase() !== host.toLowerCase()) {
+        throw new CliError(`Expected site "${expect}" but the target is "${host || info.url}". Stopped so that nothing is deployed to the wrong site.`);
+    }
+}
 /** enformik site status */
 export async function siteStatus(ctx) {
     const info = await client(ctx).getSite();
-    ctx.out.info(`Web sitesi ortamı : ${info.environment.name}`);
-    ctx.out.info(`Adres             : ${info.url}`);
+    assertExpectedHost(ctx, info);
+    ctx.out.info(`Website environment : ${info.environment.name}`);
+    ctx.out.info(`URL                 : ${info.url}`);
     if (info.app)
-        ctx.out.info(`Uygulama          : ${info.app.name}${info.app.workspaceId ? ` (çalışma alanı ${info.app.workspaceId})` : ''}`);
-    ctx.out.info(`Canlı sürüm       : ${info.live ? `#${info.live.seq} (${info.live.at})` : 'henüz dağıtım yok'}`);
-    ctx.out.info(`Anahtar bitişi    : ${info.key.expiresAt.slice(0, 10)}`);
+        ctx.out.info(`App                 : ${info.app.name}${info.app.workspaceId ? ` (workspace ${info.app.workspaceId})` : ''}`);
+    ctx.out.info(`Live release        : ${info.live ? `#${info.live.seq} (${info.live.at})` : 'no deployment yet'}`);
+    ctx.out.info(`Key expires         : ${info.key.expiresAt.slice(0, 10)}`);
     ctx.out.result(info);
     return 0;
 }
@@ -38,14 +51,23 @@ export async function siteDeploy(ctx) {
             throw new Error();
     }
     catch {
-        throw new CliError(`Derleme klasörü bulunamadı: ${dir} (önce siteyi derleyin ya da --dir verin).`);
+        throw new CliError(`Build folder not found: ${dir} (build the site first or pass --dir).`);
     }
     const timeoutSec = parseTimeout(ctx.flags.timeout);
     // Sunucunun kotası biliniyorsa ön denetimde kullan (aşımı yüklemeden görmek için).
     const info = await api.getSite();
-    const pre = precheckSite(dir, { ...DEFAULT_LIMITS, maxFiles: info.limits.maxFiles, maxFileBytes: info.limits.maxFileBytes, maxUnpackedBytes: info.limits.maxUnpackedBytes });
+    assertExpectedHost(ctx, info);
+    // Sır taraması yanlış alarmı için proje kökündeki .enformikignore (yol listesi); yoksa boş.
+    let scanIgnore = [];
+    try {
+        scanIgnore = parseScanIgnore(readFileSync(join(ctx.cwd, '.enformikignore'), 'utf8'));
+    }
+    catch { /* dosya yok */ }
+    const pre = precheckSite(dir, { ...DEFAULT_LIMITS, maxFiles: info.limits.maxFiles, maxFileBytes: info.limits.maxFileBytes, maxUnpackedBytes: info.limits.maxUnpackedBytes }, { scanIgnore });
+    for (const w of pre.warnings)
+        out.warn(w);
     if (pre.issues.length > 0) {
-        out.error('Site arşivi kurallara uymuyor; yükleme yapılmadı:');
+        out.error('The site archive does not meet the rules; nothing was uploaded:');
         for (const i of pre.issues)
             out.error(`  - ${i.path ? i.path + ': ' : ''}${i.message}`);
         out.result({ deployed: false, issues: pre.issues });
@@ -56,45 +78,45 @@ export async function siteDeploy(ctx) {
         const zipPath = join(tmp, 'site.zip');
         const z = writeZipFile(pre.files.map((f) => ({ name: f.name, path: f.path, mtime: f.mtime })), zipPath);
         if (z.bytes > MAX_ARCHIVE_BYTES)
-            throw new CliError(`Sıkıştırılmış arşiv ${formatBytes(z.bytes)}; en çok ${formatBytes(MAX_ARCHIVE_BYTES)} olabilir.`);
-        out.info(`${pre.files.length} dosya, ${formatBytes(pre.unpackedBytes)} → ${formatBytes(z.bytes)} (zip)`);
+            throw new CliError(`The compressed archive is ${formatBytes(z.bytes)}; the maximum is ${formatBytes(MAX_ARCHIVE_BYTES)}.`);
+        out.info(`${pre.files.length} files, ${formatBytes(pre.unpackedBytes)} → ${formatBytes(z.bytes)} (zip)`);
         const sha = sha256File(zipPath);
-        const init = await api.init({ sizeBytes: z.bytes, sha256: sha, meta: collectMeta(ctx.env, ctx.cwd) }, idempotencyKey(ctx.env));
+        const init = await api.init({ sizeBytes: z.bytes, sha256: sha, meta: collectMeta(ctx.env, ctx.cwd) }, idempotencyKey(ctx.env, undefined, sha));
         let dep = init.deployment;
         if (init.replayed)
-            out.info(`Önceki deneme bulundu (#${dep.seq}, durum: ${dep.status}); kaldığı yerden devam ediliyor.`);
+            out.info(`Found a previous attempt (#${dep.seq}, status: ${dep.status}); resuming where it left off.`);
         // Durumuna göre devam: yükle → sonlandır → bekle (yeniden oynatılan kayıt için de doğru).
         if (dep.status === 'awaiting_upload') {
-            out.info(`Yükleniyor (#${dep.seq})…`);
+            out.info(`Uploading (#${dep.seq})…`);
             await api.upload(dep.deploymentId, zipPath);
             dep = { ...dep, status: 'uploaded' };
         }
         if (dep.status === 'uploaded') {
-            await api.finalize(dep.deploymentId);
-            dep = { ...dep, status: 'validating' };
+            dep = await finalizeDeployment(api, dep);
         }
-        if (ctx.flags['no-wait'] === true) {
-            out.info(`Dağıtım başlatıldı (#${dep.seq}). Durum için: konsol → Geliştirici sitesi → Sürümler.`);
+        // Terminal durumdaki (failed/expired/live) yeniden oynatılan kayıt --no-wait ile de gerçek sonucu vermeli.
+        if (ctx.flags['no-wait'] === true && !isTerminal(dep.status)) {
+            out.info(`Deployment started (#${dep.seq}). To follow its status: console → Developer site → Releases.`);
             out.result({ deployed: false, deploymentId: dep.deploymentId, seq: dep.seq, status: dep.status });
             return 0;
         }
         const final = isTerminal(dep.status) ? dep : await waitForDeployment(api, dep.deploymentId, {
             timeoutMs: timeoutSec * 1000,
-            onStatus: (s) => out.info(`  durum: ${s}`),
+            onStatus: (s) => out.info(`  status: ${s}`),
             sleep: ctx.sleep,
         });
         if (final.status === 'live') {
-            out.info(out.paint('green', `✓ Yayında: ${final.url ?? info.url}  (sürüm #${final.seq})`));
+            out.info(out.paint('green', `✓ Live: ${final.url ?? info.url}  (release #${final.seq})`));
             out.result({ deployed: true, deploymentId: final.deploymentId, seq: final.seq, url: final.url ?? info.url });
             return 0;
         }
         if (final.status === 'superseded') {
             // Daha yeni bir sürüm canlıya çıktı: istenen son durum sağlandı; CI'ı kırmayız ama açıkça uyarırız.
-            out.warn(`Uyarı: bu dağıtım (#${final.seq}) daha yeni bir sürümle değiştirildi; canlı olan daha yeni sürümdür.`);
+            out.warn(`Warning: this deployment (#${final.seq}) was superseded by a newer release; the newer release is the one that is live.`);
             out.result({ deployed: false, superseded: true, status: 'superseded', deploymentId: final.deploymentId, seq: final.seq, url: info.url });
             return 0;
         }
-        out.error(`✗ Dağıtım başarısız (#${final.seq}, ${final.status}): ${final.error ?? 'bilinmeyen neden'}`);
+        out.error(`✗ Deployment failed (#${final.seq}, ${final.status}): ${final.error ?? 'unknown reason'}`);
         for (const i of final.issues ?? [])
             out.error(`  - ${i.path ? i.path + ': ' : ''}${i.message}`);
         out.result({ deployed: false, deploymentId: final.deploymentId, seq: final.seq, status: final.status, error: final.error, issues: final.issues });
@@ -110,6 +132,6 @@ function parseTimeout(raw) {
         return 600;
     const n = typeof raw === 'string' ? Number(raw) : NaN;
     if (!Number.isFinite(n) || n <= 0)
-        throw new CliError(`--timeout pozitif bir saniye sayısı olmalı (verilen: ${String(raw)}).`);
+        throw new CliError(`--timeout must be a positive number of seconds (got: ${String(raw)}).`);
     return n;
 }

package/dist/commands/whoami.js

@@ -1,6 +1,6 @@
 import { discoverApp, fetchAccessToken, rolesFromClaims } from '../auth.js';
 import { DeployClient } from '../site.js';
-/** enformik whoami: hangi kimlikle, hangi hedefe bağlanıldığını gösterir (sır yazdırmaz). */
+/** enformik whoami: shows which identity connects to which target (prints no secrets). */
 export async function whoami(ctx) {
     const { out, settings } = ctx;
     const result = {};
@@ -10,27 +10,32 @@ export async function whoami(ctx) {
         const app = await discoverApp(settings.appUrl, ctx.version, ctx.fetchImpl);
         const tok = await fetchAccessToken(app, settings.clientId, settings.clientSecret, ctx.version, ctx.fetchImpl);
         const roles = rolesFromClaims(tok.claims);
-        out.info('Şema yükseltme (API istemcisi)');
-        out.info(`  Uygulama      : ${settings.appUrl}`);
-        out.info(`  İstemci       : ${settings.clientId}`);
-        out.info(`  Roller        : ${roles.join(', ') || '(belirteçte rol yok)'}`);
-        out.info(`  Çalışma alanı : ${settings.workspaceId || app.tenantId || '(belirtilmedi)'}`);
-        out.info(`  Belirteç      : geçerli (${Math.round(tok.expiresInSec / 60)} dk)`);
-        result.schema = { appUrl: settings.appUrl, clientId: settings.clientId, roles, workspaceId: settings.workspaceId || app.tenantId || null };
+        out.info('Schema upgrades (API client)');
+        out.info(`  App           : ${settings.appUrl}`);
+        out.info(`  Client        : ${settings.clientId}`);
+        out.info(`  Identity provider : ${new URL(app.oidcAuthority).host}`);
+        out.info(`  Roles         : ${roles.join(', ') || '(no roles in the token)'}`);
+        out.info(`  Workspace     : ${settings.workspaceId || app.tenantId || '(not specified)'}`);
+        out.info(`  Token         : valid${tok.expiresInSec > 0 ? ` (${Math.round(tok.expiresInSec / 60)} min)` : ' (no expiry info)'}`);
+        result.schema = { appUrl: settings.appUrl, authorityHost: new URL(app.oidcAuthority).host, clientId: settings.clientId, roles, workspaceId: settings.workspaceId || app.tenantId || null };
     }
     if (settings.consoleUrl && settings.deployKey) {
         any = true;
         const info = await new DeployClient({ consoleUrl: settings.consoleUrl, deployKey: settings.deployKey, version: ctx.version, fetchImpl: ctx.fetchImpl }).getSite();
-        out.info('Site dağıtımı (dağıtım anahtarı)');
-        out.info(`  Konsol        : ${settings.consoleUrl}`);
-        out.info(`  Anahtar       : ${settings.deployKey.slice(0, 12)}…  (bitiş ${info.key.expiresAt.slice(0, 10)})`);
-        out.info(`  Ortam / adres : ${info.environment.name} → ${info.url}`);
+        out.info('Site deployment (deploy key)');
+        out.info(`  Console       : ${settings.consoleUrl}`);
+        out.info(`  Key           : ${settings.deployKey.slice(0, 12)}…  (expires ${info.key.expiresAt.slice(0, 10)})`);
+        out.info(`  Environment / URL : ${info.environment.name} → ${info.url}`);
         result.site = { consoleUrl: settings.consoleUrl, keyPrefix: settings.deployKey.slice(0, 12), expiresAt: info.key.expiresAt, environment: info.environment.name, url: info.url };
     }
     if (!any) {
-        out.info('Tanımlı kimlik bilgisi yok. Gerekenler:');
-        out.info('  Şema yükseltme : ENFORMIK_APP_URL (ya da link) + ENFORMIK_CLIENT_ID + ENFORMIK_CLIENT_SECRET');
-        out.info('  Site dağıtımı  : ENFORMIK_CONSOLE_URL (ya da link) + ENFORMIK_DEPLOY_KEY');
+        out.info('No credentials configured. Required:');
+        out.info('  Schema upgrade : ENFORMIK_APP_URL (or link) + ENFORMIK_CLIENT_ID + ENFORMIK_CLIENT_SECRET');
+        out.info('  Site deployment: ENFORMIK_CONSOLE_URL (or link) + ENFORMIK_DEPLOY_KEY');
+        out.result({
+            error: 'no_credentials', message: 'No credentials configured.',
+            required: ['ENFORMIK_APP_URL + ENFORMIK_CLIENT_ID + ENFORMIK_CLIENT_SECRET', 'ENFORMIK_CONSOLE_URL + ENFORMIK_DEPLOY_KEY'],
+        });
         return 1;
     }
     out.result(result);

package/dist/config.js

@@ -25,21 +25,21 @@ export function loadConfig(cwd, explicitPath) {
         raw = readFileSync(path, 'utf8');
     }
     catch {
-        throw new CliError(`Yapılandırma okunamadı: ${path}`);
+        throw new CliError(`Could not read the config: ${path}`);
     }
     let parsed;
     try {
         parsed = JSON.parse(raw);
     }
     catch {
-        throw new CliError(`Yapılandırma geçerli JSON değil: ${path}`);
+        throw new CliError(`The config is not valid JSON: ${path}`);
     }
     if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
-        throw new CliError(`Yapılandırma bir nesne olmalı: ${path}`);
+        throw new CliError(`The config must be an object: ${path}`);
     // Depoya yanlışlıkla sır yazılmasını engelle.
     const s = raw.toLowerCase();
     if (s.includes('enf_dk_') || /"(client_?secret|secret|deploy_?key|password|token)"/.test(s)) {
-        throw new CliError(`${path} sır içeriyor gibi görünüyor. Sırlar yapılandırma dosyasına değil, ortam değişkenlerine (ENFORMIK_CLIENT_SECRET, ENFORMIK_DEPLOY_KEY) yazılır; dosyadan çıkarın.`);
+        throw new CliError(`${path} appears to contain a secret. Secrets belong in environment variables (ENFORMIK_CLIENT_SECRET, ENFORMIK_DEPLOY_KEY), not in the config file; remove it from the file.`);
     }
     // .enformik/config.json → proje kökü = .enformik'in üst dizini
     return { config: parsed, path, root: dirname(dirname(path)) };

package/dist/context.js

@@ -1,25 +1,40 @@
 import { createInterface } from 'node:readline/promises';
-export function realPrompts() {
+export function realPrompts(input = process.stdin, output = process.stderr) {
+    /**
+     * One line, or null when the input ends before an answer. A closed stdin must read as "no": left pending, the question never settles
+     * and the process would end silently with exit code 0 although nothing was applied.
+     */
+    const readLine = async (question) => {
+        const ended = input;
+        if (ended.readableEnded || ended.destroyed) {
+            output.write(`${question}\n`);
+            return null;
+        }
+        const rl = createInterface({ input, output });
+        try {
+            const closed = new Promise((resolve) => rl.once('close', () => resolve(null)));
+            const line = await Promise.race([rl.question(question), closed]);
+            if (line === null)
+                output.write('\n');
+            return line;
+        }
+        finally {
+            rl.close();
+        }
+    };
     return {
         async confirm(question) {
-            const rl = createInterface({ input: process.stdin, output: process.stderr });
-            try {
-                const a = (await rl.question(`${question} [e/H]: `)).trim().toLowerCase();
-                return a === 'e' || a === 'evet' || a === 'y' || a === 'yes';
-            }
-            finally {
-                rl.close();
-            }
+            const a = await readLine(`${question} [y/N]: `);
+            if (a === null)
+                return false;
+            const t = a.trim().toLowerCase();
+            return t === 'y' || t === 'yes';
         },
         async ask(question, def) {
-            const rl = createInterface({ input: process.stdin, output: process.stderr });
-            try {
-                const a = (await rl.question(def ? `${question} [${def}]: ` : `${question}: `)).trim();
-                return a || def || '';
-            }
-            finally {
-                rl.close();
-            }
+            const a = await readLine(def ? `${question} [${def}]: ` : `${question}: `);
+            if (a === null)
+                return def ?? '';
+            return a.trim() || def || '';
         },
     };
 }

package/dist/errors.js

@@ -16,11 +16,15 @@ export class ApiError extends Error {
     status;
     code;
     body;
-    constructor(status, message, code, body) {
+    retryAfterSeconds;
+    constructor(status, message, code, body, 
+    /** Only for 429: seconds from the Retry-After header (clamped 0..3600), when the server sent one. */
+    retryAfterSeconds) {
         super(message);
         this.status = status;
         this.code = code;
         this.body = body;
+        this.retryAfterSeconds = retryAfterSeconds;
         this.name = 'ApiError';
     }
 }

package/dist/http.js

@@ -7,10 +7,10 @@ export function assertSecureUrl(raw, what) {
         u = new URL(raw);
     }
     catch {
-        throw new CliError(`${what} geçerli bir adres değil: ${raw}`);
+        throw new CliError(`${what} is not a valid URL: ${raw}`);
     }
     if (u.protocol !== 'https:' && !(u.protocol === 'http:' && LOCAL_HOSTS.has(u.hostname))) {
-        throw new CliError(`${what} HTTPS olmalı (kimlik bilgileri açık metin gönderilmez): ${raw}`);
+        throw new CliError(`${what} must use HTTPS (credentials are never sent in plain text): ${raw}`);
     }
     return u;
 }
@@ -18,6 +18,8 @@ export function joinUrl(base, path) {
     return base.replace(/\/+$/, '') + (path.startsWith('/') ? path : '/' + path);
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** fetch(redirect:'error') yönlendirmede "fetch failed" + cause "unexpected redirect" ile reddeder. */
+const isRedirectError = (e) => /redirect/i.test(String(e?.cause?.message ?? e?.message ?? ''));
 export async function request(url, opts = {}) {
     const doFetch = opts.fetchImpl ?? fetch;
     const attempts = (opts.retries ?? 0) + 1;
@@ -47,6 +49,8 @@ export async function request(url, opts = {}) {
         }
         catch (err) {
             lastErr = err;
+            if (isRedirectError(err))
+                break; // yönlendirme tekrar denemeyle değişmez
             if (i < attempts - 1) {
                 await sleep(400 * 2 ** i);
                 continue;
@@ -54,15 +58,47 @@ export async function request(url, opts = {}) {
         }
     }
     const e = lastErr;
-    const reason = e?.name === 'TimeoutError' ? 'zaman aşımı' : (e?.cause?.code ?? e?.message ?? 'bilinmeyen hata');
-    throw new CliError(`Sunucuya ulaşılamadı (${new URL(url).host}): ${reason}`);
+    if (isRedirectError(e)) {
+        throw new CliError(`The server redirected to another address (${new URL(url).host}); for security, redirects are not followed when credentials are sent. Update the URL to the redirect target (e.g. https:// or the correct domain).`);
+    }
+    const reason = e?.name === 'TimeoutError' ? 'timed out' : (e?.cause?.code ?? e?.message ?? 'unknown error');
+    throw new CliError(`Could not reach the server (${new URL(url).host}): ${reason}`);
+}
+/** Retry-After (delta-seconds or HTTP-date) → seconds, clamped to 0..3600; undefined when absent or unparsable. */
+export function parseRetryAfter(raw, nowMs = Date.now()) {
+    const v = raw?.trim();
+    if (!v)
+        return undefined;
+    let seconds;
+    if (/^\d+$/.test(v))
+        seconds = Number(v);
+    else {
+        if (!/[A-Za-z]/.test(v))
+            return undefined; // an HTTP-date has letters; Date.parse would turn "1.5" or "-5" into a (past) date
+        const t = Date.parse(v);
+        if (Number.isNaN(t))
+            return undefined;
+        seconds = Math.ceil((t - nowMs) / 1000);
+    }
+    return Math.min(3600, Math.max(0, seconds));
+}
+export const rateLimitMessage = (seconds) => seconds === undefined ? 'Rate limited by the server; try again shortly.' : `Rate limited by the server; retry in about ${seconds} s.`;
+/** HTTP 429 as an ApiError. `code` stays the server's own code (if it sent one); there is deliberately no automatic retry. */
+export function rateLimitedError(res) {
+    const body = res.json;
+    const seconds = parseRetryAfter(res.headers.get('retry-after'));
+    return new ApiError(429, rateLimitMessage(seconds), typeof body?.error === 'string' ? body.error : undefined, res.json ?? res.text, seconds);
 }
 /** Yanıt başarısızsa ApiError fırlatır; gövdeden {error, message} ya da düz metin okur. */
 export function ensureOk(res) {
     if (res.ok)
         return res;
+    if (res.status === 429)
+        throw rateLimitedError(res);
     const body = res.json;
     const code = typeof body?.error === 'string' ? body.error : undefined;
-    const message = body?.message ?? (typeof body?.error === 'string' ? body.error : res.text.trim().slice(0, 300)) ?? '';
+    // Ara katmanların (CDN/WAF) HTML hata sayfaları mesaja girmez; yalnızca "HTTP <durum>" kalır.
+    const plain = /^\s*</.test(res.text) ? '' : res.text.trim().slice(0, 300);
+    const message = body?.message ?? (typeof body?.error === 'string' ? body.error : plain) ?? '';
     throw new ApiError(res.status, message || `HTTP ${res.status}`, code, res.json ?? res.text);
 }

package/dist/output.js

@@ -14,7 +14,7 @@ export function createOutput(opts = {}) {
     const stderr = opts.stderr ?? process.stderr;
     const env = opts.env ?? process.env;
     const json = !!opts.json;
-    const color = !env.NO_COLOR && env.TERM !== 'dumb' && !!stderr.isTTY && !(json && !stderr.isTTY);
+    const color = !env.NO_COLOR && env.TERM !== 'dumb' && !!stderr.isTTY && (json || !!stdout.isTTY); // stdout dosyaya/boruya yönlendirilmişse ANSI kaçışı yazılmaz
     const human = (s) => (json ? stderr : stdout).write(s + '\n');
     return {
         json,

package/dist/precheck.js

@@ -1,25 +1,75 @@
 import { lstatSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+/** İzin listesi: yalnızca sitenin çalışması için gereken türler (SPEC CAP-2). Worker (site_artifact.go) ile aynı kümedir;
+ *  sapmayı temporal-worker testdata/site_file_types.json sözleşme dosyası yakalar. */
+export const ALLOWED_EXTS = new Set([
+    '.html', '.htm', '.css', '.js', '.mjs', '.map',
+    '.json', '.webmanifest', '.xml', '.txt', '.csv', '.md',
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.avif', '.svg', '.ico', '.bmp',
+    '.woff', '.woff2', '.ttf', '.otf', '.eot',
+    '.mp3', '.ogg', '.wav', '.m4a',
+    '.mp4', '.webm',
+    '.pdf', '.wasm',
+]);
+export const EXECUTABLE_EXTS = new Set([
+    '.exe', '.dll', '.msi', '.bat', '.cmd', '.com', '.scr', '.ps1',
+    '.sh', '.apk', '.ipa', '.dmg', '.pkg', '.deb', '.rpm', '.jar', '.app',
+]);
+/** İzin listesinde olmayan dosya için sorun döner; izinliyse null. Uzantısız dosya yalnızca .well-known/ altında izinli. */
+export function fileTypeIssue(relPath) {
+    const base = relPath.slice(relPath.lastIndexOf('/') + 1);
+    const dot = base.lastIndexOf('.');
+    const ext = dot > 0 ? base.slice(dot).toLowerCase() : '';
+    if (EXECUTABLE_EXTS.has(ext)) {
+        return { code: 'executable_file', message: `Executable/package files (${ext}) cannot be uploaded. Remove files the site does not need from the folder.` };
+    }
+    if (ext === '') {
+        return relPath.startsWith('.well-known/') ? null : { code: 'disallowed_file_type', message: 'Files without an extension cannot be uploaded (only allowed under .well-known/).' };
+    }
+    if (!ALLOWED_EXTS.has(ext)) {
+        return { code: 'disallowed_file_type', message: `${ext} files cannot be uploaded; only the types a site needs (pages, scripts, styles, images, fonts, audio, video, pdf, wasm, text/data) are allowed.` };
+    }
+    return null;
+}
 export const DEFAULT_LIMITS = { maxFiles: 10000, maxFileBytes: 100 * 1024 * 1024 };
 export const RESERVED_DIR = '_enformik';
 const MAX_ISSUES = 20;
+/** Worker (site_artifact.go maxSitePathBytes) ile aynı sınır. */
+const MAX_PATH_BYTES = 255;
 // Tarayıcı paketine sızmaması gereken sırlar. Değer ASLA çıktıya yazılmaz; yalnızca dosya yolu ve tür bildirilir.
 // Bilerek dar tutulur (yanlış alarm CI'ı kırar): dağıtım anahtarı, istemci sırrı atamaları, sabit Basic kimlik başlığı.
 const SECRET_PATTERNS = [
-    { kind: 'dağıtım anahtarı (enf_dk_…)', re: /enf_dk_[A-Za-z0-9_-]{16,}/ },
-    { kind: 'istemci sırrı (client_secret)', re: /client_?secret["']?\s*[:=]\s*["'`][^"'`\s]{8,}["'`]/i },
-    { kind: 'ENFORMIK_CLIENT_SECRET değeri', re: /ENFORMIK_CLIENT_SECRET["']?\s*[:=]\s*["'`][^"'`\s]{6,}["'`]/ },
-    { kind: 'sabit Basic kimlik başlığı', re: /Authorization["']?\s*:\s*["'`]Basic\s+[A-Za-z0-9+/=]{16,}/i },
+    { kind: 'deploy key (enf_dk_…)', re: /enf_dk_[A-Za-z0-9_-]{16,}/ },
+    { kind: 'client secret (client_secret)', re: /client_?secret["']?\s*[:=]\s*["'`][^"'`\s]{8,}["'`]/i },
+    { kind: 'ENFORMIK_CLIENT_SECRET value', re: /ENFORMIK_CLIENT_SECRET["']?\s*[:=]\s*["'`][^"'`\s]{6,}["'`]/ },
+    { kind: 'hard-coded Basic auth header', re: /Authorization["']?\s*:\s*["'`]Basic\s+[A-Za-z0-9+/=]{16,}/i },
 ];
-const SCAN_EXT = new Set(['.js', '.mjs', '.cjs', '.html', '.htm', '.json', '.map', '.css', '.txt', '.xml', '.svg', '.webmanifest']);
+const SCAN_EXT = new Set(['.js', '.mjs', '.cjs', '.html', '.htm', '.json', '.map', '.css', '.txt', '.xml', '.svg', '.webmanifest', '.csv', '.md']);
 const SCAN_MAX_BYTES = 5 * 1024 * 1024;
+/**
+ * `.enformikignore` içeriğini yol listesine çevirir: satır başına bir yol (dağıtım klasörüne göre), `#` yorum.
+ * `dir/` ile biten satır o dizinin altındaki her dosyayı kapsar; joker yoktur (bilerek dar). Yalnızca sır taramasını
+ * atlatır; dosya türü, boyut ve diğer denetimler yine uygulanır.
+ */
+export function parseScanIgnore(text) {
+    return text.split(/\r?\n/).map((l) => l.trim().replace(/^\.\//, '')).filter((l) => l && !l.startsWith('#'));
+}
+const isIgnored = (name, ignore) => ignore.some((p) => (p.endsWith('/') ? name.startsWith(p) : name === p));
 /** Metin dosyalarında sır desenlerini arar (dosya başına en çok bir bulgu). */
-export function scanSecrets(files) {
-    const out = [];
+export function scanSecrets(files, ignore = []) {
+    const out = { issues: [], ignored: [], unscanned: [] };
     for (const f of files) {
         const dot = f.name.lastIndexOf('.');
-        if (dot < 0 || !SCAN_EXT.has(f.name.slice(dot).toLowerCase()) || f.size > SCAN_MAX_BYTES)
+        if (dot < 0 || !SCAN_EXT.has(f.name.slice(dot).toLowerCase()))
+            continue;
+        if (isIgnored(f.name, ignore)) {
+            out.ignored.push(f.name);
+            continue;
+        }
+        if (f.size > SCAN_MAX_BYTES) {
+            out.unscanned.push(f.name);
             continue;
+        }
         let text;
         try {
             text = readFileSync(f.path, 'utf8');
@@ -29,11 +79,11 @@ export function scanSecrets(files) {
         }
         const hit = SECRET_PATTERNS.find((p) => p.re.test(text));
         if (hit)
-            out.push({ code: 'secret_in_bundle', path: f.name, message: `Pakette sır var gibi görünüyor: ${hit.kind}. Tarayıcıya giden dosyalara sır konmaz; sırrı paketten çıkarıp (ve sızdıysa iptal edip) yeniden derleyin.` });
+            out.issues.push({ code: 'secret_in_bundle', path: f.name, message: `The bundle appears to contain a secret: ${hit.kind}. Secrets must not be placed in files served to the browser; remove the secret from the bundle (and revoke it if it leaked), then rebuild. If this is a false alarm, add the file path to .enformikignore in the project root.` });
     }
     return out;
 }
-export function precheckSite(dir, limits = DEFAULT_LIMITS) {
+export function precheckSite(dir, limits = DEFAULT_LIMITS, opts = {}) {
     const files = [];
     const issues = [];
     const add = (code, path, message) => {
@@ -49,25 +99,38 @@ export function precheckSite(dir, limits = DEFAULT_LIMITS) {
             const relPath = rel ? `${rel}/${ent.name}` : ent.name;
             const absPath = join(abs, ent.name);
             if (relPath.split('/')[0] === RESERVED_DIR) {
-                add('reserved_path', relPath, `"${RESERVED_DIR}" dizini platform için ayrılmıştır; arşivden çıkarın.`);
+                add('reserved_path', relPath, `The "${RESERVED_DIR}" directory is reserved for the platform; remove it from the archive.`);
                 continue;
             }
             if (ent.name.startsWith('.') && ent.name !== '.well-known') {
-                add('hidden_file', relPath, `Gizli dosya/dizin yüklenemez ("${ent.name}"). .env, .git gibi dosyaları arşive koymayın.`);
+                add('hidden_file', relPath, `Hidden files/directories cannot be uploaded ("${ent.name}"). Do not include files such as .env or .git in the archive.`);
+                continue;
+            }
+            if (Buffer.byteLength(relPath) > MAX_PATH_BYTES) {
+                add('unsafe_path', relPath, `A path cannot be longer than ${MAX_PATH_BYTES} bytes.`);
+                continue;
+            }
+            if (relPath.includes('\\') || /[\u0000-\u001f\u007f]/.test(relPath)) {
+                add('unsafe_path', relPath, 'The path contains an invalid or control character.');
                 continue;
             }
             const st = lstatSync(absPath);
             if (st.isSymbolicLink() || (!st.isFile() && !st.isDirectory())) {
-                add('unsupported_entry', relPath, 'Sembolik bağ veya özel dosya desteklenmez.');
+                add('unsupported_entry', relPath, 'Symbolic links and special files are not supported.');
                 continue;
             }
             if (st.isDirectory()) {
                 walk(absPath, relPath);
                 continue;
             }
+            const ft = fileTypeIssue(relPath);
+            if (ft) {
+                add(ft.code, relPath, ft.message);
+                continue;
+            }
             const key = relPath.toLowerCase();
             if (seen.has(key)) {
-                add('duplicate_path', relPath, 'Aynı yol büyük/küçük harf farkıyla birden fazla var.');
+                add('duplicate_path', relPath, 'The same path appears more than once, differing only in letter case.');
                 continue;
             }
             seen.add(key);
@@ -77,7 +140,7 @@ export function precheckSite(dir, limits = DEFAULT_LIMITS) {
             if (parts.length === 2 && parts[1] === 'index.html')
                 nestedIndexDirs.add(parts[0]);
             if (st.size > limits.maxFileBytes) {
-                add('file_too_large', relPath, `Tek dosya en fazla ${Math.floor(limits.maxFileBytes / 1048576)} MB olabilir.`);
+                add('file_too_large', relPath, `A single file can be at most ${Math.floor(limits.maxFileBytes / 1048576)} MB.`);
                 continue;
             }
             files.push({ name: relPath, path: absPath, size: st.size, mtime: st.mtime });
@@ -85,22 +148,28 @@ export function precheckSite(dir, limits = DEFAULT_LIMITS) {
         }
     };
     walk(dir, '');
-    for (const s of scanSecrets(files))
+    const scan = scanSecrets(files, opts.scanIgnore);
+    for (const s of scan.issues)
         add(s.code, s.path, s.message);
+    const warnings = [];
+    if (scan.ignored.length > 0)
+        warnings.push(`Files skipped by the secret scan because of .enformikignore: ${scan.ignored.join(', ')}`);
+    if (scan.unscanned.length > 0)
+        warnings.push(`Files not scanned for secrets because they exceed ${SCAN_MAX_BYTES / 1048576} MB: ${scan.unscanned.join(', ')}`);
     if (files.length > limits.maxFiles) {
-        add('too_many_files', undefined, `Arşivde en fazla ${limits.maxFiles} dosya olabilir (${files.length} bulundu).`);
+        add('too_many_files', undefined, `The archive can contain at most ${limits.maxFiles} files (${files.length} found).`);
     }
     if (limits.maxUnpackedBytes && total > limits.maxUnpackedBytes) {
-        add('quota_exceeded', undefined, `Sitenin açılmış boyutu ortamınızın disk kotasını aşıyor (${total} > ${limits.maxUnpackedBytes} bayt).`);
+        add('quota_exceeded', undefined, `The unpacked size of the site exceeds your environment's disk quota (${total} > ${limits.maxUnpackedBytes} bytes).`);
     }
     if (!hasRootIndex && issues.length < MAX_ISSUES) {
         if (nestedIndexDirs.size === 1) {
             const d = [...nestedIndexDirs][0];
-            add('nested_root', `${d}/index.html`, `index.html bir üst klasörün ("${d}") içinde. Klasörün kendisini değil, İÇERİĞİNİ yayınlayın (--dir ${join(dir, d)}).`);
+            add('nested_root', `${d}/index.html`, `index.html is inside a subfolder ("${d}"). Publish the folder's CONTENTS, not the folder itself (--dir ${join(dir, d)}).`);
         }
         else {
-            add('missing_index', 'index.html', 'Dizinin kökünde index.html bulunmalı.');
+            add('missing_index', 'index.html', 'index.html must be at the root of the directory.');
         }
     }
-    return { files, unpackedBytes: total, issues };
+    return { files, unpackedBytes: total, issues, warnings };
 }