@enformik/cli 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,62 @@
-# Temporary Holding Version
+# @enformik/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Enformik geliştirici CLI'si: kendi derlediğiniz **web sitesini** yayınlar ve **uygulama modülünüzü (şema)** yükseltir. CI/CD hatlarında çalışmak için tasarlanmıştır; çalışma zamanı bağımlılığı yoktur (Node.js ≥ 20).
+
+```bash
+npx @enformik/cli --help
+# ya da kalıcı kurulum:
+npm install -g @enformik/cli   # komut: enformik
+```
+
+## Site dağıtımı
+
+Gerekenler: Enformik yönetim konsolunda web sitesi ortamınızda **Geliştirici sitesi** etkin ve bir **dağıtım anahtarı** oluşturulmuş olmalı.
+
+```bash
+export ENFORMIK_CONSOLE_URL=https://<konsol-adresiniz>
+export ENFORMIK_DEPLOY_KEY=enf_dk_…        # CI gizli değişkeni; depoya yazmayın
+
+npx @enformik/cli site deploy --dir dist
+```
+
+`index.html` kökte mi, gizli dosya (`.env`, `.git`…) var mı, boyut/kota uygun mu gibi kurallar **yüklemeden önce** denetlenir; hatalar dosya yoluyla gösterilir. Başarıda yeni sürümün adresi yazdırılır.
+
+## Şema (modül) yükseltme
+
+Gerekenler: uygulamanızda **Şema yükseltici** (ya da Yönetici) rolünde bir **API istemcisi** (konsol → uygulamanın "API erişimi" bölümü) ve uygulamada kurulu bir modül. Modülün **ilk kurulumunu** bir yönetici yapar; sonraki yükseltmeler bu CLI ile yapılır.
+
+```bash
+export ENFORMIK_APP_URL=https://<uygulama-adresiniz>
+export ENFORMIK_CLIENT_ID=apic-…
+export ENFORMIK_CLIENT_SECRET=…
+
+npx @enformik/cli schema diff --manifest module.json --check   # değişiklik varsa çıkış kodu 2
+npx @enformik/cli schema push --manifest module.json --yes
+```
+
+> **Dikkat:** modül (şema) değişikliği uygulamanın **tüm çalışma alanlarını** etkiler. Canlı uygulamaya laptop'tan değil, CI'dan ve canlıya özel bir istemci ile uygulayın.
+
+"Şema yükseltici" rolü betik, otomasyon, yetki tanımı, veri kaynağı, etkileşimli sayfa, arayüz uzantısı ve tohum veri içeren manifestleri ve alan türü değişikliklerini uygulayamaz; bunlar bir yönetici tarafından uygulanır.
+
+## Komutlar
+
+| Komut | Açıklama |
+| --- | --- |
+| `link` | `.enformik/config.json` yazar (adresler; **sır içermez**) |
+| `whoami` | Hangi kimlikle, hangi hedefe bağlanıldığını gösterir |
+| `schema diff` | Manifesti uygulamadakiyle karşılaştırır (`--check`) |
+| `schema push` | Değişiklikleri uygular (etkileşimsiz ortamda `--yes` zorunlu) |
+| `site deploy` | Derlenmiş siteyi yayınlar (`--dir`, `--no-wait`, `--timeout`) |
+| `site status` | Hedef site ve canlı sürüm bilgisi |
+
+Genel bayraklar: `--json` (stdout'a yalnızca JSON; insan çıktısı stderr'e), `--config`, `--debug`.
+Çıkış kodları: `0` başarı · `1` hata · `2` (`--check`) uygulanacak değişiklik var.
+`--expect-host <ad>` (şema komutları): hedef uygulamanın ana makine adı farklıysa işlemi durdurur (yanlış uygulamaya push'a karşı koruma).
+
+## Güvenlik
+
+- Sırlar **yalnızca ortam değişkeniyle** verilir; komut satırı bayrağı veya yapılandırma dosyası yoktur (sır içeren `.enformik/config.json` reddedilir).
+- Kimlik bilgileri yalnızca HTTPS ile gönderilir (`localhost` hariç); yönlendirmeler takip edilmez.
+- Erişim belirteci yalnızca bellekte tutulur.
+
+Ayrıntılı rehber: Enformik geliştirici dokümantasyonunda "CLI" sayfası.

package/dist/auth.js

@@ -0,0 +1,71 @@
+import { ApiError, CliError } from './errors.js';
+import { assertSecureUrl, ensureOk, joinUrl, request } from './http.js';
+export async function discoverApp(appUrl, version, fetchImpl) {
+    assertSecureUrl(appUrl, 'Uygulama adresi');
+    const res = await request(joinUrl(appUrl, '/api/config'), { retries: 2, headers: { 'X-Enformik-CLI-Version': version }, fetchImpl });
+    try {
+        ensureOk(res);
+    }
+    catch (e) {
+        if (e instanceof ApiError)
+            throw new CliError(`Uygulama yapılandırması okunamadı (HTTP ${e.status}). Adres doğru mu: ${appUrl}?`);
+        throw e;
+    }
+    const j = (res.json ?? {});
+    if (!j.oidc_authority)
+        throw new CliError('Uygulama yapılandırması beklenen biçimde değil (oidc_authority yok).');
+    if (!j.api_audience) {
+        throw new CliError('Bu uygulama API istemcisi belirteçlerini kabul etmiyor (api_audience boş). Destek kaydı açın.');
+    }
+    return { oidcAuthority: j.oidc_authority, apiAudience: j.api_audience, tenantId: j.tenant_id ?? '' };
+}
+export function buildScope(audience) {
+    return `openid urn:zitadel:iam:org:projects:roles urn:zitadel:iam:org:project:id:${audience}:aud`;
+}
+export async function fetchAccessToken(app, clientId, clientSecret, version, fetchImpl) {
+    const url = joinUrl(app.oidcAuthority, '/oauth/v2/token');
+    assertSecureUrl(url, 'Kimlik sağlayıcı adresi');
+    const res = await request(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Authorization: 'Basic ' + Buffer.from(`${clientId}:${clientSecret}`).toString('base64'),
+            'X-Enformik-CLI-Version': version,
+        },
+        body: new URLSearchParams({ grant_type: 'client_credentials', scope: buildScope(app.apiAudience) }),
+        retries: 1,
+        fetchImpl,
+    });
+    if (!res.ok) {
+        if (res.status === 400 || res.status === 401) {
+            throw new CliError('Kimlik doğrulanamadı: istemci kimliği/sırrı geçersiz ya da istemci iptal edilmiş. Konsoldan sırrı yenileyin.');
+        }
+        throw new CliError(`Belirteç alınamadı (HTTP ${res.status}).`);
+    }
+    const j = res.json;
+    if (!j?.access_token)
+        throw new CliError('Kimlik sağlayıcı beklenen yanıtı vermedi (access_token yok).');
+    return { token: j.access_token, expiresInSec: j.expires_in ?? 0, claims: decodeJwtPayload(j.access_token) };
+}
+/** İmza DOĞRULANMAZ (yalnızca whoami'de bilgi göstermek için); yetkilendirme sunucuda yapılır. */
+export function decodeJwtPayload(token) {
+    const part = token.split('.')[1];
+    if (!part)
+        return {};
+    try {
+        return JSON.parse(Buffer.from(part, 'base64url').toString('utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** JWT'deki proje rolleri (urn:zitadel:iam:org:project:{id}:roles anahtarları) → rol adları. */
+export function rolesFromClaims(claims) {
+    const roles = new Set();
+    for (const [k, v] of Object.entries(claims)) {
+        if (/^urn:zitadel:iam:org:project(:\d+)?:roles$/.test(k) && v && typeof v === 'object')
+            for (const r of Object.keys(v))
+                roles.add(r);
+    }
+    return [...roles].sort();
+}

package/dist/cli.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+import { readFileSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { link } from './commands/link.js';
+import { schemaDiff, schemaPush } from './commands/schema.js';
+import { siteDeploy, siteStatus } from './commands/site.js';
+import { whoami } from './commands/whoami.js';
+import { loadConfig, resolveSettings } from './config.js';
+import { realPrompts } from './context.js';
+import { ApiError, CliError } from './errors.js';
+import { createOutput } from './output.js';
+// Çıkış kodları: 0 başarı · 1 hata · 2 (--check) uygulanacak değişiklik var.
+const OPTIONS = {
+    json: { type: 'boolean' }, help: { type: 'boolean', short: 'h' }, version: { type: 'boolean', short: 'v' }, debug: { type: 'boolean' },
+    config: { type: 'string' },
+    'console-url': { type: 'string' }, 'app-url': { type: 'string' }, workspace: { type: 'string' },
+    module: { type: 'string' }, manifest: { type: 'string' }, dir: { type: 'string' },
+    check: { type: 'boolean' }, yes: { type: 'boolean', short: 'y' }, 'seed-data': { type: 'boolean' }, 'expect-host': { type: 'string' },
+    'no-wait': { type: 'boolean' }, timeout: { type: 'string' }, 'no-verify': { type: 'boolean' },
+};
+const GLOBAL = ['json', 'help', 'version', 'debug', 'config'];
+const COMMANDS = {
+    link: { flags: ['console-url', 'app-url', 'workspace', 'module', 'manifest', 'dir', 'no-verify'], run: link, usage: 'enformik link [--console-url U] [--app-url U] [--workspace ID] [--module SLUG] [--manifest YOL] [--dir KLASÖR]' },
+    whoami: { flags: ['console-url', 'app-url', 'workspace'], run: whoami, usage: 'enformik whoami' },
+    'schema diff': { flags: ['app-url', 'workspace', 'module', 'manifest', 'check', 'seed-data', 'expect-host'], run: schemaDiff, usage: 'enformik schema diff [--manifest module.json] [--check]' },
+    'schema push': { flags: ['app-url', 'workspace', 'module', 'manifest', 'yes', 'seed-data', 'expect-host'], run: schemaPush, usage: 'enformik schema push [--manifest module.json] [--yes] [--seed-data]' },
+    'site deploy': { flags: ['console-url', 'dir', 'no-wait', 'timeout'], run: siteDeploy, usage: 'enformik site deploy [--dir dist] [--no-wait] [--timeout 600]' },
+    'site status': { flags: ['console-url'], run: siteStatus, usage: 'enformik site status' },
+};
+export function helpText(version) {
+    return `enformik ${version} — Enformik geliştirici CLI'si
+
+Kullanım: enformik <komut> [bayraklar]
+
+Komutlar
+  link          .enformik/config.json yazar (adresler; sır içermez)
+  whoami        Hangi kimlikle, hangi hedefe bağlanıldığını gösterir
+  schema diff   Modül manifestini uygulamadakiyle karşılaştırır (--check: değişiklik varsa çıkış kodu 2)
+  schema push   Değişiklikleri uygular (etkileşimsiz ortamda --yes gerekir)
+  site deploy   Derlenmiş siteyi (varsayılan: dist) web sitesi ortamına yayınlar
+  site status   Hedef site ve canlı sürüm bilgisi
+
+Genel bayraklar: --json (makine-okunur çıktı), --config YOL, --debug, -h/--help, -v/--version
+
+Sırlar yalnızca ortam değişkeniyle verilir:
+  Şema yükseltme : ENFORMIK_CLIENT_ID, ENFORMIK_CLIENT_SECRET   (+ ENFORMIK_APP_URL)
+  Site dağıtımı  : ENFORMIK_DEPLOY_KEY                          (+ ENFORMIK_CONSOLE_URL)
+
+Çıkış kodları: 0 başarı · 1 hata · 2 (--check) uygulanacak değişiklik var
+
+Ayrıntılar: komut yardımı için "enformik <komut> --help"`;
+}
+function readVersion() {
+    try {
+        return JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Test edilebilir giriş noktası: çıkış kodunu döner, process.exit çağırmaz. */
+export async function main(d) {
+    let parsed;
+    try {
+        parsed = parseArgs({ args: d.argv, options: OPTIONS, allowPositionals: true, strict: true });
+    }
+    catch (e) {
+        const out = createOutput({ stderr: d.stderr, stdout: d.stdout, env: d.env });
+        out.error(`${e.message}\n"enformik --help" ile kullanımı görün.`);
+        return 1;
+    }
+    const { values, positionals } = parsed;
+    const out = createOutput({ json: values.json === true, stdout: d.stdout, stderr: d.stderr, env: d.env });
+    if (values.version) {
+        out.info(d.version);
+        return 0;
+    }
+    const name = positionals.slice(0, 2).join(' ');
+    const cmd = COMMANDS[name] ?? COMMANDS[positionals[0] ?? ''];
+    const cmdName = COMMANDS[name] ? name : positionals[0] ?? '';
+    if (values.help || positionals.length === 0 || positionals[0] === 'help') {
+        if (cmd && values.help) {
+            out.info(`Kullanım: ${cmd.usage}`);
+            return 0;
+        }
+        out.info(helpText(d.version));
+        return positionals.length === 0 && !values.help ? 1 : 0;
+    }
+    if (!cmd) {
+        out.error(`Bilinmeyen komut: ${positionals.join(' ')}\n"enformik --help" ile komutları görün.`);
+        return 1;
+    }
+    const used = Object.entries(values).filter(([, v]) => v !== undefined).map(([k]) => k);
+    const bad = used.filter((k) => !GLOBAL.includes(k) && !cmd.flags.includes(k));
+    if (bad.length > 0) {
+        out.error(`"${cmdName}" komutunda geçersiz bayrak: ${bad.map((b) => '--' + b).join(', ')}\nKullanım: ${cmd.usage}`);
+        return 1;
+    }
+    const extra = positionals.slice(cmdName.split(' ').length);
+    if (extra.length > 0) {
+        out.error(`Beklenmeyen argüman: ${extra.join(' ')}\nKullanım: ${cmd.usage}`);
+        return 1;
+    }
+    try {
+        const { config } = loadConfig(d.cwd, typeof values.config === 'string' ? values.config : undefined);
+        const flags = values;
+        const settings = resolveSettings(config, d.env, flags);
+        const prompts = realPrompts();
+        const ctx = {
+            out, settings, flags, cwd: d.cwd, env: d.env, version: d.version,
+            isTTY: d.isTTY ?? !!process.stdin.isTTY,
+            fetchImpl: d.fetchImpl,
+            confirm: d.confirm ?? prompts.confirm,
+            ask: d.ask ?? prompts.ask,
+            sleep: d.sleep,
+        };
+        return await cmd.run(ctx);
+    }
+    catch (e) {
+        if (e instanceof CliError) {
+            out.error(e.message);
+            out.result({ error: e.code ?? 'error', message: e.message });
+            return e.exitCode;
+        }
+        if (e instanceof ApiError) {
+            out.error(`Sunucu hatası (HTTP ${e.status}): ${e.message}`);
+            return 1;
+        }
+        out.error(`Beklenmeyen hata: ${e.message}`);
+        if (values.debug)
+            out.error(e.stack ?? '');
+        return 1;
+    }
+}
+// Doğrudan çalıştırma (import edildiğinde değil).
+const invoked = process.argv[1] ? safeReal(process.argv[1]) : '';
+function safeReal(p) { try {
+    return realpathSync(p);
+}
+catch {
+    return p;
+} }
+if (invoked && invoked === fileURLToPath(import.meta.url)) {
+    main({ argv: process.argv.slice(2), env: process.env, cwd: process.cwd(), version: readVersion() }).then((code) => { process.exitCode = code; });
+}

package/dist/commands/link.js

@@ -0,0 +1,51 @@
+import { discoverApp } from '../auth.js';
+import { loadConfig, saveConfig } from '../config.js';
+import { CliError } from '../errors.js';
+import { assertSecureUrl } from '../http.js';
+/** enformik link: .enformik/config.json yazar (sır içermez). */
+export async function link(ctx) {
+    const { out, flags } = ctx;
+    const { config, root } = loadConfig(ctx.cwd);
+    const next = { ...config };
+    const str = (k) => (typeof flags[k] === 'string' ? flags[k] : undefined);
+    const prompt = async (label, cur, flag) => {
+        if (flag !== undefined)
+            return flag;
+        if (!ctx.isTTY)
+            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'));
+    const manifest = str('manifest') ?? config.module?.manifest;
+    const dir = str('dir') ?? config.site?.dir;
+    if (slug || manifest)
+        next.module = { ...(config.module ?? {}), ...(slug ? { slug } : {}), ...(manifest ? { manifest } : {}) };
+    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).');
+    if (next.consoleUrl)
+        assertSecureUrl(next.consoleUrl, 'Konsol adresi');
+    if (next.appUrl) {
+        assertSecureUrl(next.appUrl, 'Uygulama adresi');
+        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.');
+        }
+    }
+    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:');
+    if (next.consoleUrl)
+        out.info('  ENFORMIK_DEPLOY_KEY      (site dağıtımı: dağıtım anahtarı)');
+    if (next.appUrl)
+        out.info('  ENFORMIK_CLIENT_ID / ENFORMIK_CLIENT_SECRET   (şema yükseltme: API istemcisi)');
+    out.result({ linked: true, path, config: next });
+    return 0;
+}

package/dist/commands/schema.js

@@ -0,0 +1,111 @@
+import { readFileSync } from 'node:fs';
+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';
+/** Ortak hazırlık: manifest → uygulama keşfi → belirteç → modül kimliği. */
+async function prepare(ctx) {
+    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.');
+    if (!settings.clientId || !settings.clientSecret) {
+        throw new CliError('ENFORMIK_CLIENT_ID ve ENFORMIK_CLIENT_SECRET tanımlı olmalı (konsolda uygulamanızın "API erişimi" bölümünden rolü "Şema yükseltici" 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.`);
+    }
+    const manifestPath = resolve(ctx.cwd, settings.manifestPath);
+    let text;
+    try {
+        text = readFileSync(manifestPath, 'utf8');
+    }
+    catch {
+        throw new CliError(`Manifest okunamadı: ${manifestPath}`);
+    }
+    const manifest = parseManifest(text, settings.manifestPath);
+    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ı.`);
+    }
+    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" rolündeki bir istemci bunu uygulayamaz.`);
+    }
+    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.');
+    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 });
+    const mod = await client.resolveModule(slug);
+    return { client, manifest, manifestJson: JSON.stringify(manifest), moduleId: mod.id, installedVersion: mod.version, appHost: appUrl.hostname, seedData };
+}
+function summary(p, r) {
+    return {
+        module: p.manifest.module.slug,
+        installedVersion: p.installedVersion,
+        manifestVersion: p.manifest.module.version,
+        moduleId: p.moduleId,
+        changes: pendingChanges(r.diffs).length,
+        diffs: r.diffs,
+        errors: r.errors,
+    };
+}
+/** enformik schema diff [--check] */
+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(renderDiff(ctx.out, r, { appHost: p.appHost }));
+    const s = summary(p, r);
+    ctx.out.result(s);
+    if (r.errors.length > 0)
+        return 1;
+    if (ctx.flags.check === true && s.changes > 0)
+        return 2;
+    return 0;
+}
+/** enformik schema push [--yes] */
+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(renderDiff(ctx.out, dry, { appHost: p.appHost }));
+    if (dry.errors.length > 0) {
+        ctx.out.result({ ...summary(p, dry), applied: false });
+        return 1;
+    }
+    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.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.`);
+    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ı.');
+            ctx.out.result({ ...summary(p, dry), applied: false });
+            return 1;
+        }
+    }
+    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.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.result({ ...summary(p, res), applied: true });
+    return 0;
+}

package/dist/commands/site.js

@@ -0,0 +1,100 @@
+import { mkdtempSync, 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 { 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.');
+    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');
+    return new DeployClient({ consoleUrl: settings.consoleUrl, deployKey: settings.deployKey, version: ctx.version, fetchImpl: ctx.fetchImpl });
+}
+/** 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}`);
+    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.result(info);
+    return 0;
+}
+/** enformik site deploy [--dir dist] [--no-wait] [--timeout 600] */
+export async function siteDeploy(ctx) {
+    const { out, settings } = ctx;
+    const api = client(ctx);
+    const dir = resolve(ctx.cwd, settings.siteDir);
+    try {
+        if (!statSync(dir).isDirectory())
+            throw new Error();
+    }
+    catch {
+        throw new CliError(`Derleme klasörü bulunamadı: ${dir} (önce siteyi derleyin ya da --dir verin).`);
+    }
+    // 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 });
+    if (pre.issues.length > 0) {
+        out.error('Site arşivi kurallara uymuyor; yükleme yapılmadı:');
+        for (const i of pre.issues)
+            out.error(`  - ${i.path ? i.path + ': ' : ''}${i.message}`);
+        out.result({ deployed: false, issues: pre.issues });
+        return 1;
+    }
+    const tmp = mkdtempSync(join(tmpdir(), 'enformik-'));
+    try {
+        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)`);
+        const sha = sha256File(zipPath);
+        const init = await api.init({ sizeBytes: z.bytes, sha256: sha, meta: collectMeta(ctx.env, ctx.cwd) }, idempotencyKey(ctx.env));
+        let dep = init.deployment;
+        if (init.replayed)
+            out.info(`Önceki deneme bulundu (#${dep.seq}, durum: ${dep.status}); kaldığı yerden devam ediliyor.`);
+        // 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})…`);
+            await api.upload(dep.deploymentId, zipPath);
+            dep = { ...dep, status: 'uploaded' };
+        }
+        if (dep.status === 'uploaded') {
+            await api.finalize(dep.deploymentId);
+            dep = { ...dep, status: 'validating' };
+        }
+        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.`);
+            out.result({ deployed: false, deploymentId: dep.deploymentId, seq: dep.seq, status: dep.status });
+            return 0;
+        }
+        const timeoutSec = Number(typeof ctx.flags.timeout === 'string' ? ctx.flags.timeout : 600);
+        const final = isTerminal(dep.status) ? dep : await waitForDeployment(api, dep.deploymentId, {
+            timeoutMs: (Number.isFinite(timeoutSec) && timeoutSec > 0 ? timeoutSec : 600) * 1000,
+            onStatus: (s) => out.info(`  durum: ${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.result({ deployed: true, deploymentId: final.deploymentId, seq: final.seq, url: final.url ?? info.url });
+            return 0;
+        }
+        out.error(`✗ Dağıtım başarısız (#${final.seq}, ${final.status}): ${final.error ?? 'bilinmeyen neden'}`);
+        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 });
+        return 1;
+    }
+    finally {
+        rmSync(tmp, { recursive: true, force: true });
+    }
+}

package/dist/commands/whoami.js

@@ -0,0 +1,38 @@
+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). */
+export async function whoami(ctx) {
+    const { out, settings } = ctx;
+    const result = {};
+    let any = false;
+    if (settings.appUrl && settings.clientId && settings.clientSecret) {
+        any = true;
+        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 };
+    }
+    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}`);
+        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');
+        return 1;
+    }
+    out.result(result);
+    return 0;
+}

package/dist/config.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { CliError } from './errors.js';
+export const CONFIG_DIR = '.enformik';
+export const CONFIG_FILE = 'config.json';
+/** cwd'den köke doğru .enformik/config.json arar (git gibi). */
+export function findConfigPath(cwd) {
+    let dir = resolve(cwd);
+    for (;;) {
+        const p = join(dir, CONFIG_DIR, CONFIG_FILE);
+        if (existsSync(p))
+            return p;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export function loadConfig(cwd, explicitPath) {
+    const path = explicitPath ? resolve(cwd, explicitPath) : findConfigPath(cwd);
+    if (!path)
+        return { config: {}, path: null, root: resolve(cwd) };
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        throw new CliError(`Yapılandırma okunamadı: ${path}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new CliError(`Yapılandırma geçerli JSON değil: ${path}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        throw new CliError(`Yapılandırma bir nesne olmalı: ${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.`);
+    }
+    // .enformik/config.json → proje kökü = .enformik'in üst dizini
+    return { config: parsed, path, root: dirname(dirname(path)) };
+}
+export function saveConfig(root, config) {
+    const dir = join(root, CONFIG_DIR);
+    mkdirSync(dir, { recursive: true });
+    const p = join(dir, CONFIG_FILE);
+    writeFileSync(p, JSON.stringify(config, null, 2) + '\n');
+    return p;
+}
+/** Öncelik: bayrak > ortam değişkeni > yapılandırma dosyası. */
+export function resolveSettings(config, env, flags) {
+    const pick = (...v) => v.find((x) => x !== undefined && x !== '');
+    return {
+        consoleUrl: pick(flags['console-url'], env.ENFORMIK_CONSOLE_URL, config.consoleUrl),
+        appUrl: pick(flags['app-url'], env.ENFORMIK_APP_URL, config.appUrl),
+        workspaceId: pick(flags.workspace, env.ENFORMIK_WORKSPACE_ID, config.workspaceId),
+        clientId: pick(env.ENFORMIK_CLIENT_ID),
+        clientSecret: pick(env.ENFORMIK_CLIENT_SECRET),
+        deployKey: pick(env.ENFORMIK_DEPLOY_KEY),
+        moduleSlug: pick(flags.module, config.module?.slug),
+        manifestPath: pick(flags.manifest, config.module?.manifest) ?? 'module.json',
+        siteDir: pick(flags.dir, config.site?.dir) ?? 'dist',
+    };
+}