@enformik/cli 0.4.0 → 0.6.0

package/dist/commands/app.js

@@ -1,7 +1,7 @@
 import { CliError } from '../errors.js';
 import { assertSecureUrl, joinUrl, request } from '../http.js';
 import { DeployClient } from '../site.js';
-import { prepare } from './schema.js';
+import { assertExpectedAppHost, prepare } from './schema.js';
 const ICON = { ok: '✓', warn: '!', fail: '✗', skip: '-' };
 /** Web kullanıcısına (external) açık sayılan kural: rol "external" ya da özel rol; en az bir okuma eylemi. */
 function grantsWebRead(r) {
@@ -14,9 +14,9 @@ function grantsWebRead(r) {
     return null;
 }
 /**
- * enformik app check [--entity a,b] — web uygulamasının Enformik'le entegrasyon sağlığını SALT OKUNUR denetler.
- * Site tarafı (ENFORMIK_CONSOLE_URL + ENFORMIK_DEPLOY_KEY) ve uygulama tarafı (ENFORMIK_APP_URL + istemci) bağımsızdır;
- * kimliği olmayan taraf atlanır. Çıkış: engelleyici sorun 1, yalnız uyarı 2, hepsi tamam 0.
+ * enformik app check [--entity a,b] — READ-ONLY check of the web app's integration health with Enformik.
+ * The site side (ENFORMIK_CONSOLE_URL + ENFORMIK_DEPLOY_KEY) and the app side (ENFORMIK_APP_URL + client) are independent;
+ * a side without credentials is skipped. Exit: blocking problem 1, warnings only 2, all OK 0.
  */
 export async function appCheck(ctx) {
     const { settings, out } = ctx;
@@ -24,99 +24,116 @@ export async function appCheck(ctx) {
     const hasSite = !!(settings.consoleUrl && settings.deployKey);
     const hasApp = !!(settings.appUrl && settings.clientId && settings.clientSecret);
     if (!hasSite && !hasApp) {
-        throw new CliError('Denetlenecek kimlik yok. Site için ENFORMIK_CONSOLE_URL + ENFORMIK_DEPLOY_KEY, uygulama için ENFORMIK_APP_URL + ENFORMIK_CLIENT_ID/SECRET tanımlayın.');
+        throw new CliError('No credentials to check. Set ENFORMIK_CONSOLE_URL + ENFORMIK_DEPLOY_KEY for the site, and ENFORMIK_APP_URL + ENFORMIK_CLIENT_ID/SECRET for the app.');
     }
+    // --expect-host is about the APP host (as in the schema commands); the site half ignores it. Checked first, so a mismatch stops the whole
+    // command (a hard error, not a check entry) before ANY request is sent, including the site half's GET /site.
+    if (settings.appUrl && typeof ctx.flags['expect-host'] === 'string')
+        assertExpectedAppHost(ctx, assertSecureUrl(settings.appUrl, 'App URL'));
     // ── Site: yayınlanmış çalışma zamanı yapılandırması ──────────────────────────────────────────
     if (hasSite) {
-        const info = await new DeployClient({ consoleUrl: settings.consoleUrl, deployKey: settings.deployKey, version: ctx.version, fetchImpl: ctx.fetchImpl }).getSite();
-        if (!info.live) {
-            checks.push({ id: 'site.live', status: 'warn', message: 'Sitede henüz canlı dağıtım yok; giriş yapılandırması denetlenemedi.', hint: '`enformik site deploy` ile yayınlayın.' });
-        }
-        else {
-            assertSecureUrl(info.url, 'Site adresi');
-            let cfg;
-            try {
-                const res = await request(joinUrl(info.url, '/_enformik/config.json'), { retries: 1, fetchImpl: ctx.fetchImpl });
-                if (res.ok && res.json && typeof res.json === 'object')
-                    cfg = res.json;
-            }
-            catch { /* ulaşılamadı → aşağıda uyarı */ }
-            if (!cfg) {
-                checks.push({ id: 'site.config', status: 'warn', message: `${info.url}/_enformik/config.json okunamadı.`, hint: 'Site yayında mı? Yeniden dağıtmayı deneyin.' });
+        if (typeof ctx.flags['expect-host'] === 'string')
+            out.warn('Note: --expect-host checks the app host only; the site side is not checked against it.');
+        try {
+            const info = await new DeployClient({ consoleUrl: settings.consoleUrl, deployKey: settings.deployKey, version: ctx.version, fetchImpl: ctx.fetchImpl }).getSite();
+            if (!info.live) {
+                checks.push({ id: 'site.live', status: 'warn', message: 'The site has no live deployment yet; the sign-in configuration could not be checked.', hint: 'Publish it with `enformik site deploy`.' });
             }
             else {
-                const auth = cfg.auth;
-                if (!auth || !auth.clientId) {
-                    checks.push({ id: 'site.auth', status: 'fail', message: 'Site girişi kapalı: yayınlanmış yapılandırmada giriş (auth) bilgisi yok.', hint: 'Konsol → Geliştirici sitesi → Site girişi sekmesinden girişi açıp siteyi yeniden dağıtın.' });
+                assertSecureUrl(info.url, 'Site URL');
+                let cfg;
+                try {
+                    const res = await request(joinUrl(info.url, '/_enformik/config.json'), { retries: 1, fetchImpl: ctx.fetchImpl });
+                    if (res.ok && res.json && typeof res.json === 'object')
+                        cfg = res.json;
+                }
+                catch { /* ulaşılamadı → aşağıda uyarı */ }
+                if (!cfg) {
+                    checks.push({ id: 'site.config', status: 'warn', message: `Could not read ${info.url}/_enformik/config.json.`, hint: 'Is the site live? Try redeploying.' });
                 }
                 else {
-                    checks.push({ id: 'site.auth', status: 'ok', message: 'Site girişi açık; yayınlanmış yapılandırmada giriş bilgisi var.' });
+                    const auth = cfg.auth;
+                    if (!auth || !auth.clientId) {
+                        checks.push({ id: 'site.auth', status: 'fail', message: 'Site sign-in is off: the published configuration has no sign-in (auth) information.', hint: 'Enable sign-in under Console → Developer site → Site sign-in, then redeploy the site.' });
+                    }
+                    else {
+                        checks.push({ id: 'site.auth', status: 'ok', message: 'Site sign-in is on; the published configuration has sign-in information.' });
+                    }
+                    const ok = typeof cfg.appUrl === 'string' && typeof cfg.apiUrl === 'string' && !!cfg.workspaceId;
+                    checks.push(ok ? { id: 'site.binding', status: 'ok', message: 'The site is linked to an app and a workspace.' }
+                        : { id: 'site.binding', status: 'fail', message: 'The configuration is missing the app/workspace link.', hint: 'Check the developer site\'s app link in the console.' });
                 }
-                const ok = typeof cfg.appUrl === 'string' && typeof cfg.apiUrl === 'string' && !!cfg.workspaceId;
-                checks.push(ok ? { id: 'site.binding', status: 'ok', message: 'Site bir uygulamaya ve çalışma alanına bağlı.' }
-                    : { id: 'site.binding', status: 'fail', message: 'Yapılandırmada uygulama/çalışma alanı bağlantısı eksik.', hint: 'Konsolda geliştirici sitesinin uygulama bağlantısını kontrol edin.' });
             }
         }
+        catch (e) {
+            // Bir yarının hatası diğer yarıyı ve checks[] çıktısını kaybettirmesin.
+            checks.push({ id: 'site.error', status: 'fail', message: `The site check could not be completed: ${e.message}` });
+        }
     }
     else {
-        checks.push({ id: 'site', status: 'skip', message: 'Site denetimi atlandı (ENFORMIK_CONSOLE_URL + ENFORMIK_DEPLOY_KEY yok).' });
+        checks.push({ id: 'site', status: 'skip', message: 'Site check skipped (ENFORMIK_CONSOLE_URL + ENFORMIK_DEPLOY_KEY not set).' });
     }
     // ── Uygulama: modül, erişim modu ve web kullanıcısı erişimi ──────────────────────────────────
     if (hasApp) {
-        const p = await prepare(ctx, 'validate');
-        const slug = p.manifest.module.slug;
-        const mod = await p.client.findModule(slug);
-        if (!mod) {
-            checks.push({ id: 'module.installed', status: 'fail', message: `"${slug}" modülü uygulamada kurulu değil.`, hint: '`enformik schema install` (Şema oluşturucu) ile kurun.' });
-        }
-        else if (mod.version !== p.manifest.module.version) {
-            checks.push({ id: 'module.version', status: 'warn', message: `Uygulamadaki modül sürümü ${mod.version}, manifest ${p.manifest.module.version}.`, hint: '`enformik schema diff` / `schema push` ile eşitleyin.' });
-        }
-        else {
-            checks.push({ id: 'module.version', status: 'ok', message: `Modül ${slug} ${mod.version} kurulu ve manifestle aynı sürümde.` });
-        }
-        const wanted = typeof ctx.flags.entity === 'string' && ctx.flags.entity !== ''
-            ? ctx.flags.entity.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean)
-            : (p.manifest.entities ?? []).map((e) => (e.slug ?? '').toLowerCase()).filter(Boolean);
-        const summary = await p.client.accessSummary(wanted);
-        if (!summary) {
-            checks.push({ id: 'access', status: 'warn', message: 'Bu uygulama sürümü erişim özeti ucunu desteklemiyor; web kullanıcısı erişimi denetlenemedi.', hint: 'Uygulama güncellenince yeniden deneyin.' });
-        }
-        else {
-            if (summary.mode !== 'on') {
-                checks.push({ id: 'access.mode', status: 'fail', message: `Kayıt erişim kuralları "${summary.mode || 'bilinmiyor'}" modunda; web kullanıcıları bu modda çalışmaz.`, hint: 'Etkinleştirilmesi için Enformik yönetim konsolundan destek kaydı açın.' });
+        try {
+            const p = await prepare(ctx, 'validate');
+            const slug = p.manifest.module.slug;
+            const mod = await p.client.findModule(slug);
+            if (!mod) {
+                checks.push({ id: 'module.installed', status: 'fail', message: `Module "${slug}" is not installed in the app.`, hint: 'Install it with `enformik schema install` (Schema builder).' });
             }
-            else {
-                checks.push({ id: 'access.mode', status: 'ok', message: 'Kayıt erişim kuralları etkin.' });
+            else if (mod.version !== p.manifest.module.version) {
+                checks.push({ id: 'module.version', status: 'warn', message: `The module version in the app is ${mod.version}; the manifest is ${p.manifest.module.version}.`, hint: 'Sync them with `enformik schema diff` / `schema push`.' });
             }
-            const byName = new Map(summary.entities.map((e) => [e.entity.toLowerCase(), e.rules]));
-            const none = [];
-            const custom = [];
-            for (const name of wanted) {
-                const kinds = (byName.get(name) ?? []).map(grantsWebRead);
-                if (kinds.includes('external'))
-                    continue;
-                if (kinds.includes('custom'))
-                    custom.push(name);
-                else
-                    none.push(name);
-            }
-            if (wanted.length === 0) {
-                checks.push({ id: 'access.web', status: 'skip', message: 'Denetlenecek entity yok (manifestte entity ya da --entity yok).' });
+            else {
+                checks.push({ id: 'module.version', status: 'ok', message: `Module ${slug} ${mod.version} is installed and matches the manifest version.` });
             }
-            else if (none.length > 0) {
-                checks.push({ id: 'access.web', status: 'warn', message: `Web kullanıcıları şu tablolarda veri göremez (okuma kuralı yok): ${none.join(', ')}.`, hint: 'Bir yönetici ilgili tabloların Kayıt Erişimi ekranında "Web Kullanıcısı" (ya da özel rol) için okuma kuralı tanımlamalı; düşük rollü istemci erişim kuralı uygulayamaz.' });
+            const wanted = typeof ctx.flags.entity === 'string' && ctx.flags.entity !== ''
+                ? ctx.flags.entity.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean)
+                : (p.manifest.entities ?? []).map((e) => (e.slug ?? '').toLowerCase()).filter(Boolean);
+            const summary = await p.client.accessSummary(wanted);
+            if (!summary) {
+                checks.push({ id: 'access', status: 'warn', message: 'This app version does not support the access summary endpoint; web user access could not be checked.', hint: 'Try again once the app is updated.' });
             }
             else {
-                checks.push({ id: 'access.web', status: 'ok', message: `Web kullanıcıları için okuma kuralı var (${wanted.length - custom.length} tablo).` });
-            }
-            if (custom.length > 0) {
-                checks.push({ id: 'access.custom', status: 'warn', message: `Şu tablolarda yalnızca özel rol kuralı var: ${custom.join(', ')}.`, hint: 'Web kullanıcılarına ilgili özel rolün atandığından emin olun (yeni kullanıcı varsayılan rolü ya da yönetici ataması).' });
+                if (summary.mode !== 'on') {
+                    checks.push({ id: 'access.mode', status: 'fail', message: `Record access rules are in "${summary.mode || 'unknown'}" mode; web users do not work in this mode.`, hint: 'Open a support ticket from the Enformik management console to have it enabled.' });
+                }
+                else {
+                    checks.push({ id: 'access.mode', status: 'ok', message: 'Record access rules are enabled.' });
+                }
+                const byName = new Map(summary.entities.map((e) => [e.entity.toLowerCase(), e.rules]));
+                const none = [];
+                const custom = [];
+                for (const name of wanted) {
+                    const kinds = (byName.get(name) ?? []).map(grantsWebRead);
+                    if (kinds.includes('external'))
+                        continue;
+                    if (kinds.includes('custom'))
+                        custom.push(name);
+                    else
+                        none.push(name);
+                }
+                if (wanted.length === 0) {
+                    checks.push({ id: 'access.web', status: 'skip', message: 'No entities to check (no entities in the manifest and no --entity).' });
+                }
+                else if (none.length > 0) {
+                    checks.push({ id: 'access.web', status: 'warn', message: `Web users cannot see data in these tables (no read rule): ${none.join(', ')}.`, hint: 'An administrator must define a read rule for "Web User" (or a custom role) on the Record Access screen of those tables; a low-role client cannot apply access rules.' });
+                }
+                else {
+                    checks.push({ id: 'access.web', status: 'ok', message: `Read rules exist for web users (${wanted.length - custom.length} tables).` });
+                }
+                if (custom.length > 0) {
+                    checks.push({ id: 'access.custom', status: 'warn', message: `These tables have only a custom role rule: ${custom.join(', ')}.`, hint: 'Make sure the relevant custom role is assigned to web users (the default role for new users, or an administrator assignment).' });
+                }
             }
         }
+        catch (e) {
+            checks.push({ id: 'app.error', status: 'fail', message: `The app check could not be completed: ${e.message}` });
+        }
     }
     else {
-        checks.push({ id: 'app', status: 'skip', message: 'Uygulama denetimi atlandı (ENFORMIK_APP_URL + ENFORMIK_CLIENT_ID/SECRET yok).' });
+        checks.push({ id: 'app', status: 'skip', message: 'App check skipped (ENFORMIK_APP_URL + ENFORMIK_CLIENT_ID/SECRET not set).' });
     }
     for (const c of checks) {
         const paint = c.status === 'ok' ? 'green' : c.status === 'fail' ? 'red' : c.status === 'warn' ? 'yellow' : 'dim';

package/dist/commands/codegen.js

@@ -5,7 +5,7 @@ import { CliError } from '../errors.js';
 import { parseManifest } from '../schema.js';
 /**
  * enformik codegen [--manifest module.json] [--out src/enformik.generated.ts] [--check]
- * Yerel manifestten TypeScript tipleri + tipli veri istemcisi üretir; ağ/kimlik gerekmez. --check: dosya güncel değilse çıkış 2.
+ * Generates TypeScript types + a typed data client from the local manifest; no network or credentials needed. --check: exit 2 if the file is out of date.
  */
 export async function codegen(ctx) {
     const manifestPath = resolve(ctx.cwd, ctx.settings.manifestPath);
@@ -14,26 +14,29 @@ export async function codegen(ctx) {
         text = readFileSync(manifestPath, 'utf8');
     }
     catch {
-        throw new CliError(`Manifest okunamadı: ${manifestPath}`);
+        throw new CliError(`Could not read the manifest: ${manifestPath}`);
     }
     const manifest = parseManifest(text, ctx.settings.manifestPath);
     const code = generateClient(manifest);
     const outPath = resolve(ctx.cwd, ctx.settings.codegenOut);
     const current = existsSync(outPath) ? readFileSync(outPath, 'utf8') : null;
+    // Windows'ta git autocrlf dosyayı CRLF'ye çevirir; satır sonu/BOM farkı "güncel değil" sayılmasın.
+    const norm = (s) => s.replace(/^\uFEFF/, '').replace(/\r\n/g, '\n');
+    const same = current !== null && norm(current) === norm(code);
     const slug = manifest.module.slug;
     if (ctx.flags.check === true) {
-        const upToDate = current === code;
-        ctx.out.info(upToDate ? `✓ ${ctx.settings.codegenOut} güncel (${slug}).` : `✗ ${ctx.settings.codegenOut} ${current === null ? 'yok' : 'manifestle uyumsuz'}; \`enformik codegen\` ile yeniden üretin.`);
+        const upToDate = same;
+        ctx.out.info(upToDate ? `✓ ${ctx.settings.codegenOut} up to date (${slug}).` : `✗ ${ctx.settings.codegenOut} ${current === null ? 'is missing' : 'does not match the manifest'}; regenerate it with \`enformik codegen\`.`);
         ctx.out.result({ module: slug, out: ctx.settings.codegenOut, upToDate });
         return upToDate ? 0 : 2;
     }
-    const changed = current !== code;
+    const changed = !same;
     if (changed) {
         mkdirSync(dirname(outPath), { recursive: true });
         writeFileSync(outPath, code);
     }
     const n = (code.match(/^export interface \w+Input /gm) ?? []).length;
-    ctx.out.info(changed ? `✓ ${ctx.settings.codegenOut} yazıldı (${slug}, ${n} entity).` : `= ${ctx.settings.codegenOut} zaten güncel (${slug}, ${n} entity).`);
+    ctx.out.info(changed ? `✓ ${ctx.settings.codegenOut} written (${slug}, ${n} entities).` : `= ${ctx.settings.codegenOut} already up to date (${slug}, ${n} entities).`);
     ctx.out.result({ module: slug, out: ctx.settings.codegenOut, entities: n, written: changed });
     return 0;
 }

package/dist/commands/link.js

@@ -15,10 +15,10 @@ export async function link(ctx) {
             return cur;
         return (await ctx.ask(label, cur)) || undefined;
     };
-    next.consoleUrl = await prompt('Konsol adresi (site dağıtımı için; boş bırakılabilir)', config.consoleUrl, str('console-url'));
-    next.appUrl = await prompt('Uygulama adresi (şema yükseltme için; boş bırakılabilir)', config.appUrl, str('app-url'));
-    next.workspaceId = await prompt('Çalışma alanı kimliği (isteğe bağlı)', config.workspaceId, str('workspace'));
-    const slug = await prompt('Modül slug (şema yükseltme için)', config.module?.slug, str('module'));
+    next.consoleUrl = await prompt('Console URL (for site deployment; may be left empty)', config.consoleUrl, str('console-url'));
+    next.appUrl = await prompt('App URL (for schema upgrades; may be left empty)', config.appUrl, str('app-url'));
+    next.workspaceId = await prompt('Workspace ID (optional)', config.workspaceId, str('workspace'));
+    const slug = await prompt('Module slug (for schema upgrades)', config.module?.slug, str('module'));
     const manifest = str('manifest') ?? config.module?.manifest;
     const dir = str('dir') ?? config.site?.dir;
     if (slug || manifest)
@@ -26,26 +26,26 @@ export async function link(ctx) {
     if (dir)
         next.site = { ...(config.site ?? {}), dir };
     if (!next.consoleUrl && !next.appUrl)
-        throw new CliError('En az bir adres gerekli: --console-url (site dağıtımı) ve/ya da --app-url (şema yükseltme).');
+        throw new CliError('At least one URL is required: --console-url (site deployment) and/or --app-url (schema upgrades).');
     if (next.consoleUrl)
-        assertSecureUrl(next.consoleUrl, 'Konsol adresi');
+        assertSecureUrl(next.consoleUrl, 'Console URL');
     if (next.appUrl) {
-        assertSecureUrl(next.appUrl, 'Uygulama adresi');
+        assertSecureUrl(next.appUrl, 'App URL');
         if (flags['no-verify'] !== true) {
             await discoverApp(next.appUrl, ctx.version, ctx.fetchImpl); // erişilebilir mi / API istemcisi kabul ediyor mu
-            out.info('✓ Uygulama erişilebilir.');
+            out.info('✓ The app is reachable.');
         }
     }
     for (const k of Object.keys(next))
         if (next[k] === undefined)
             delete next[k];
     const path = saveConfig(root, next);
-    out.info(`Yapılandırma yazıldı: ${path}`);
-    out.info('Sırlar dosyaya yazılmaz; ortam değişkeni olarak verin:');
+    out.info(`Config written: ${path}`);
+    out.info('Secrets are not written to the file; provide them as environment variables:');
     if (next.consoleUrl)
-        out.info('  ENFORMIK_DEPLOY_KEY      (site dağıtımı: dağıtım anahtarı)');
+        out.info('  ENFORMIK_DEPLOY_KEY      (site deployment: deploy key)');
     if (next.appUrl)
-        out.info('  ENFORMIK_CLIENT_ID / ENFORMIK_CLIENT_SECRET   (şema yükseltme: API istemcisi)');
+        out.info('  ENFORMIK_CLIENT_ID / ENFORMIK_CLIENT_SECRET   (schema upgrades: API client)');
     out.result({ linked: true, path, config: next });
     return 0;
 }

package/dist/commands/schema.js

@@ -3,56 +3,64 @@ import { resolve } from 'node:path';
 import { discoverApp, fetchAccessToken } from '../auth.js';
 import { CliError } from '../errors.js';
 import { assertSecureUrl } from '../http.js';
-import { adminOnlySections, parseManifest, pendingChanges, renderDiff, SchemaClient, typeChanges } from '../schema.js';
+import { adminOnlySections, parseManifest, pendingChanges, renderDiff, SchemaClient, stripBom, typeChanges, unapprovedChanges } from '../schema.js';
 import { renderTable } from '../output.js';
+/** --expect-host: the app's host name must match (case-insensitive); checked before any request so nothing reaches the wrong app. */
+export function assertExpectedAppHost(ctx, appUrl) {
+    const expect = ctx.flags['expect-host'];
+    if (typeof expect === 'string' && expect.toLowerCase() !== appUrl.hostname.toLowerCase()) {
+        throw new CliError(`Expected app "${expect}" but the target is "${appUrl.hostname}". Stopped so that nothing is applied to the wrong app.`);
+    }
+}
 /** Ortak hazırlık: manifest → uygulama keşfi → belirteç → modül kimliği. */
 export async function prepare(ctx, mode = 'existing') {
     const { settings, out } = ctx;
     if (!settings.appUrl)
-        throw new CliError('Uygulama adresi yok. `enformik link --app-url https://…` çalıştırın ya da ENFORMIK_APP_URL tanımlayın.');
+        throw new CliError('No app URL. Run `enformik link --app-url https://…` or set ENFORMIK_APP_URL.');
     if (!settings.clientId || !settings.clientSecret) {
-        throw new CliError('ENFORMIK_CLIENT_ID ve ENFORMIK_CLIENT_SECRET tanımlı olmalı (konsolda "API anahtarları" sayfasından rolü "Şema yükseltici" — ilk kurulum için "Şema oluşturucu" — olan bir istemci oluşturun).');
-    }
-    const appUrl = assertSecureUrl(settings.appUrl, 'Uygulama adresi');
-    const expect = ctx.flags['expect-host'];
-    if (typeof expect === 'string' && expect.toLowerCase() !== appUrl.hostname.toLowerCase()) {
-        throw new CliError(`Beklenen uygulama "${expect}" ama hedef "${appUrl.hostname}". Yanlış uygulamaya işlem yapılmaması için durduruldu.`);
+        throw new CliError('ENFORMIK_CLIENT_ID and ENFORMIK_CLIENT_SECRET must be set (in the console, create a client with the "Schema upgrader" role — or "Schema builder" for the first installation — on the "API keys" page).');
     }
+    const appUrl = assertSecureUrl(settings.appUrl, 'App URL');
+    assertExpectedAppHost(ctx, appUrl);
     const manifestPath = resolve(ctx.cwd, settings.manifestPath);
     let text;
     try {
-        text = readFileSync(manifestPath, 'utf8');
+        text = stripBom(readFileSync(manifestPath, 'utf8'));
     }
     catch {
-        throw new CliError(`Manifest okunamadı: ${manifestPath}`);
+        throw new CliError(`Could not read the manifest: ${manifestPath}`);
     }
     const manifest = parseManifest(text, settings.manifestPath);
+    // Sunucuya dosyanın kendi metni gider (JSON.stringify yeniden serileştirmesi büyük sayıları/biçimi değiştirebilirdi).
+    const manifestJson = text;
     const slug = settings.moduleSlug ?? manifest.module.slug;
     if (settings.moduleSlug && settings.moduleSlug !== manifest.module.slug) {
-        throw new CliError(`Yapılandırmadaki modül ("${settings.moduleSlug}") ile manifestteki slug ("${manifest.module.slug}") farklı.`);
+        throw new CliError(`The module in the config ("${settings.moduleSlug}") differs from the slug in the manifest ("${manifest.module.slug}").`);
     }
     const seedData = ctx.flags['seed-data'] === true;
     const admin = adminOnlySections(manifest, { seedData });
     if (admin.length > 0) {
-        out.warn(`Not: manifest yönetici gerektiren bölümler içeriyor (${admin.join(', ')}). "Şema yükseltici/oluşturucu" rolündeki bir istemci bunu uygulayamaz.`);
+        out.warn(`Note: the manifest contains sections that require an administrator (${admin.join(', ')}). A client with the "Schema upgrader/builder" role cannot apply them.`);
     }
     const app = await discoverApp(settings.appUrl, ctx.version, ctx.fetchImpl);
     const workspaceId = settings.workspaceId || app.tenantId;
     if (!workspaceId)
-        throw new CliError('Çalışma alanı belirlenemedi. --workspace <kimlik> verin ya da `enformik link --workspace` ile kaydedin.');
+        throw new CliError('Could not determine the workspace. Pass --workspace <id> or save it with `enformik link --workspace`.');
+    // Token adresi uygulamanın /api/config yanıtından gelir; istemci sırrı oraya gider, bu yüzden hedefi görünür kıl.
+    out.info(`Identity provider: ${new URL(app.oidcAuthority).host} (the client credentials are sent here)`);
     const tok = await fetchAccessToken(app, settings.clientId, settings.clientSecret, ctx.version, ctx.fetchImpl);
     const client = new SchemaClient({ appUrl: settings.appUrl, token: tok.token, workspaceId, version: ctx.version, fetchImpl: ctx.fetchImpl });
     if (mode === 'validate') {
-        return { client, manifest, manifestJson: JSON.stringify(manifest), moduleId: '', installedVersion: '', appHost: appUrl.hostname, seedData };
+        return { client, manifest, manifestJson, moduleId: '', installedVersion: '', appHost: appUrl.hostname, seedData };
     }
     if (mode === 'install') {
         const existing = await client.findModule(slug);
         if (existing)
-            throw new CliError(`"${slug}" modülü bu uygulamada zaten kurulu (sürüm ${existing.version}). Yükseltmek için \`enformik schema push\` kullanın.`);
-        return { client, manifest, manifestJson: JSON.stringify(manifest), moduleId: '', installedVersion: '', appHost: appUrl.hostname, seedData };
+            throw new CliError(`Module "${slug}" is already installed in this app (version ${existing.version}). Use \`enformik schema push\` to upgrade it.`);
+        return { client, manifest, manifestJson, moduleId: '', installedVersion: '', appHost: appUrl.hostname, seedData };
     }
     const mod = await client.resolveModule(slug);
-    return { client, manifest, manifestJson: JSON.stringify(manifest), moduleId: mod.id, installedVersion: mod.version, appHost: appUrl.hostname, seedData };
+    return { client, manifest, manifestJson, moduleId: mod.id, installedVersion: mod.version, appHost: appUrl.hostname, seedData };
 }
 function summary(p, r) {
     return {
@@ -69,7 +77,7 @@ function summary(p, r) {
 export async function schemaDiff(ctx) {
     const p = await prepare(ctx);
     const r = await p.client.diff(p.moduleId, p.manifestJson, { seedData: p.seedData });
-    ctx.out.info(`Modül: ${p.manifest.module.slug}  kurulu ${p.installedVersion} → manifest ${p.manifest.module.version}`);
+    ctx.out.info(`Module: ${p.manifest.module.slug}  installed ${p.installedVersion} → manifest ${p.manifest.module.version}`);
     ctx.out.info(renderDiff(ctx.out, r, { appHost: p.appHost }));
     const s = summary(p, r);
     ctx.out.result(s);
@@ -83,7 +91,7 @@ export async function schemaDiff(ctx) {
 export async function schemaPush(ctx) {
     const p = await prepare(ctx);
     const dry = await p.client.diff(p.moduleId, p.manifestJson, { seedData: p.seedData });
-    ctx.out.info(`Modül: ${p.manifest.module.slug}  kurulu ${p.installedVersion} → manifest ${p.manifest.module.version}`);
+    ctx.out.info(`Module: ${p.manifest.module.slug}  installed ${p.installedVersion} → manifest ${p.manifest.module.version}`);
     ctx.out.info(renderDiff(ctx.out, dry, { appHost: p.appHost }));
     if (dry.errors.length > 0) {
         ctx.out.result({ ...summary(p, dry), applied: false });
@@ -92,18 +100,18 @@ export async function schemaPush(ctx) {
     const pending = pendingChanges(dry.diffs);
     // Sürüm farkı olsa bile yapısal değişiklik yoksa uygulanacak bir şey yok.
     if (pending.length === 0) {
-        ctx.out.info('Uygulanacak değişiklik yok.');
+        ctx.out.info('No changes to apply.');
         ctx.out.result({ ...summary(p, dry), applied: false });
         return 0;
     }
     const tc = typeChanges(dry.diffs);
     if (tc.length > 0)
-        ctx.out.warn(`Alan türü değişiyor (${tc.map((d) => d.slug).join(', ')}): bu işlem yalnızca yönetici rolüyle uygulanabilir.`);
+        ctx.out.warn(`Field type is changing (${tc.map((d) => d.slug).join(', ')}): this can only be applied with the administrator role.`);
     if (ctx.flags.yes !== true) {
         if (!ctx.isTTY)
-            throw new CliError('Etkileşimli terminal yok: değişiklikleri uygulamak için --yes verin (sessizce onaylanmaz).');
-        if (!(await ctx.confirm('Değişiklikleri uygulamak istiyor musunuz?'))) {
-            ctx.out.info('Vazgeçildi; hiçbir değişiklik uygulanmadı.');
+            throw new CliError('No interactive terminal: pass --yes to apply the changes (nothing is confirmed silently).');
+        if (!(await ctx.confirm('Do you want to apply the changes?'))) {
+            ctx.out.info('Cancelled; no changes were applied.');
             ctx.out.result({ ...summary(p, dry), applied: false });
             return 1;
         }
@@ -111,20 +119,27 @@ export async function schemaPush(ctx) {
     const res = await p.client.upgrade(p.moduleId, p.manifestJson, { seedData: p.seedData });
     if (res.errors.length > 0) {
         for (const e of res.errors)
-            ctx.out.error(`Hata: ${e}`);
+            ctx.out.error(`Error: ${e}`);
         ctx.out.result({ ...summary(p, res), applied: false });
         return 1;
     }
-    ctx.out.info(ctx.out.paint('green', `✓ Uygulandı: ${pendingChanges(res.diffs).length || pending.length} değişiklik (modül ${p.manifest.module.slug} ${p.manifest.module.version}).`));
+    ctx.out.info(ctx.out.paint('green', `✓ Applied: ${pendingChanges(res.diffs).length || pending.length} changes (module ${p.manifest.module.slug} ${p.manifest.module.version}).`));
+    // Onay ile uygulama arasında uygulama başkası tarafından değişmiş olabilir: onaylanmayan bir değişiklik uygulandıysa açıkça bildir.
+    const extra = unapprovedChanges(dry.diffs, res.diffs);
+    if (extra.length > 0) {
+        ctx.out.error(`Warning: ${extra.length} change(s) that were not in the diff you approved were also applied (the app may have changed between diff and upgrade): ${extra.map((d) => `${d.resourceType} ${d.slug} (${d.action})`).join(', ')}. Verify the result with \`enformik schema diff\`.`);
+        ctx.out.result({ ...summary(p, res), applied: true, diverged: true, unapproved: extra });
+        return 1;
+    }
     ctx.out.result({ ...summary(p, res), applied: true });
     return 0;
 }
-/** enformik schema install [--yes] [--dry-run] — modülün ilk kurulumu (rol: Şema oluşturucu ya da Yönetici). */
+/** enformik schema install [--yes] [--dry-run] — first installation of the module (role: Schema builder or Administrator). */
 export async function schemaInstall(ctx) {
     const p = await prepare(ctx, 'install');
     const slug = p.manifest.module.slug;
     const dry = await p.client.install(p.manifestJson, { seedData: p.seedData, dryRun: true });
-    ctx.out.info(`Modül: ${slug}  yeni kurulum → manifest ${p.manifest.module.version}`);
+    ctx.out.info(`Module: ${slug}  new installation → manifest ${p.manifest.module.version}`);
     ctx.out.info(renderDiff(ctx.out, dry, { appHost: p.appHost }));
     const base = { module: slug, manifestVersion: p.manifest.module.version, changes: pendingChanges(dry.diffs).length, diffs: dry.diffs, errors: dry.errors };
     if (dry.errors.length > 0) {
@@ -137,9 +152,9 @@ export async function schemaInstall(ctx) {
     }
     if (ctx.flags.yes !== true) {
         if (!ctx.isTTY)
-            throw new CliError('Etkileşimli terminal yok: modülü kurmak için --yes verin (sessizce onaylanmaz).');
-        if (!(await ctx.confirm('Modülü kurmak istiyor musunuz?'))) {
-            ctx.out.info('Vazgeçildi; hiçbir şey kurulmadı.');
+            throw new CliError('No interactive terminal: pass --yes to install the module (nothing is confirmed silently).');
+        if (!(await ctx.confirm('Do you want to install the module?'))) {
+            ctx.out.info('Cancelled; nothing was installed.');
             ctx.out.result({ ...base, installed: false });
             return 1;
         }
@@ -147,11 +162,11 @@ export async function schemaInstall(ctx) {
     const res = await p.client.install(p.manifestJson, { seedData: p.seedData, dryRun: false });
     if (res.errors.length > 0) {
         for (const e of res.errors)
-            ctx.out.error(`Hata: ${e}`);
+            ctx.out.error(`Error: ${e}`);
         ctx.out.result({ ...base, diffs: res.diffs, errors: res.errors, installed: false });
         return 1;
     }
-    ctx.out.info(ctx.out.paint('green', `✓ Kuruldu: modül ${slug} ${p.manifest.module.version} (${pendingChanges(res.diffs).length} kaynak). Sonraki değişiklikler için \`enformik schema push\` kullanın.`));
+    ctx.out.info(ctx.out.paint('green', `✓ Installed: module ${slug} ${p.manifest.module.version} (${pendingChanges(res.diffs).length} resources). Use \`enformik schema push\` for later changes.`));
     ctx.out.result({ ...base, moduleId: res.moduleId, diffs: res.diffs, errors: [], installed: true });
     return 0;
 }
@@ -163,7 +178,7 @@ export async function schemaInstall(ctx) {
 export async function schemaValidate(ctx) {
     const profileFlag = ctx.flags.profile;
     if (profileFlag !== undefined && profileFlag !== 'import' && profileFlag !== 'ai') {
-        throw new CliError(`--profile "import" ya da "ai" olmalı (verilen: ${String(profileFlag)}).`);
+        throw new CliError(`--profile must be "import" or "ai" (got: ${String(profileFlag)}).`);
     }
     const profile = profileFlag === 'ai' ? 'ai' : 'import';
     const seedData = ctx.flags['seed-data'] === true;
@@ -171,19 +186,22 @@ export async function schemaValidate(ctx) {
     let source;
     let slug;
     if (ctx.flags.offline === true) {
+        // ai profilinin kuralları (isimlendirme/yapı) yalnızca sunucuda denetlenir; yerel denetimle "geçerli" demek yanlış güven verir.
+        if (profileFlag === 'ai')
+            throw new CliError('--offline cannot be combined with --profile ai: the ai profile rules are checked only on the server. Run without --offline.');
         const manifestPath = resolve(ctx.cwd, ctx.settings.manifestPath);
         let text;
         try {
             text = readFileSync(manifestPath, 'utf8');
         }
         catch {
-            throw new CliError(`Manifest okunamadı: ${manifestPath}`);
+            throw new CliError(`Could not read the manifest: ${manifestPath}`);
         }
         const manifest = parseManifest(text, ctx.settings.manifestPath); // JSON + module.slug/version
         slug = manifest.module.slug;
         result = { valid: true, profile, issues: [], adminSections: adminOnlySections(manifest, { seedData }).map((section) => ({ section })) };
         source = 'local';
-        ctx.out.warn('Yalnızca yerel denetim yapıldı (JSON, module.slug/version, yönetici bölümleri); isimlendirme ve yapı kuralları sunucuda denetlenir.');
+        ctx.out.warn('Only local checks were run (JSON, module.slug/version, administrator sections); naming and structure rules are checked on the server.');
     }
     else {
         const p = await prepare(ctx, 'validate');
@@ -191,14 +209,16 @@ export async function schemaValidate(ctx) {
         result = await p.client.validate(p.manifestJson, { profile, seedData });
         source = 'server';
     }
-    ctx.out.info(`Modül: ${slug}  profil: ${profile}  (${source === 'server' ? 'sunucu doğrulaması' : 'yerel'})`);
+    ctx.out.info(`Module: ${slug}  profile: ${profile}  (${source === 'server' ? 'server validation' : 'local'})`);
     if (result.issues.length > 0) {
-        ctx.out.info(renderTable(ctx.out, ['KOD', 'AÇIKLAMA'], result.issues.map((i) => [i.code, i.message])));
+        ctx.out.info(renderTable(ctx.out, ['CODE', 'DESCRIPTION'], result.issues.map((i) => [i.code, i.message])));
     }
     if (result.adminSections.length > 0) {
-        ctx.out.info(ctx.out.paint('yellow', `Yönetici adımı gerekir (düşük rollü istemci uygulayamaz): ${result.adminSections.map((s) => s.section).join(', ')}`));
+        ctx.out.info(ctx.out.paint('yellow', `Administrator step required (a low-role client cannot apply these): ${result.adminSections.map((s) => s.section).join(', ')}`));
     }
-    ctx.out.info(result.valid ? ctx.out.paint('green', '✓ Manifest geçerli.') : ctx.out.paint('red', `✗ ${result.issues.length} bulgu var.`));
+    ctx.out.info(result.valid
+        ? ctx.out.paint('green', source === 'local' ? '✓ Local checks passed (server rules were not checked).' : '✓ Manifest is valid.')
+        : ctx.out.paint('red', `✗ ${result.issues.length} issue(s) found.`));
     ctx.out.result({ module: slug, source, ...result });
     return result.valid ? 0 : 1;
 }