@enformik/cli 0.0.0-stage → 0.1.0

package/dist/context.js

@@ -0,0 +1,25 @@
+import { createInterface } from 'node:readline/promises';
+export function realPrompts() {
+    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();
+            }
+        },
+        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();
+            }
+        },
+    };
+}

package/dist/errors.js

@@ -0,0 +1,26 @@
+// CLI'nin kendi hata türü: mesaj kullanıcıya gösterilir, exitCode çıkış kodudur (0 başarı, 1 hata, 2 --check'te değişiklik var).
+export class CliError extends Error {
+    exitCode;
+    code;
+    details;
+    constructor(message, exitCode = 1, code, details) {
+        super(message);
+        this.exitCode = exitCode;
+        this.code = code;
+        this.details = details;
+        this.name = 'CliError';
+    }
+}
+/** Sunucu yanıtından gelen hata (HTTP durumu + makine-okunur kod). */
+export class ApiError extends Error {
+    status;
+    code;
+    body;
+    constructor(status, message, code, body) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.body = body;
+        this.name = 'ApiError';
+    }
+}

package/dist/http.js

@@ -0,0 +1,68 @@
+import { ApiError, CliError } from './errors.js';
+const LOCAL_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]', '::1']);
+/** Sır taşıyan istekler yalnızca HTTPS ile gider (yerel geliştirme hariç). */
+export function assertSecureUrl(raw, what) {
+    let u;
+    try {
+        u = new URL(raw);
+    }
+    catch {
+        throw new CliError(`${what} geçerli bir adres değil: ${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}`);
+    }
+    return u;
+}
+export function joinUrl(base, path) {
+    return base.replace(/\/+$/, '') + (path.startsWith('/') ? path : '/' + path);
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function request(url, opts = {}) {
+    const doFetch = opts.fetchImpl ?? fetch;
+    const attempts = (opts.retries ?? 0) + 1;
+    let lastErr;
+    for (let i = 0; i < attempts; i++) {
+        try {
+            const res = await doFetch(url, {
+                method: opts.method ?? 'GET',
+                headers: opts.headers,
+                body: opts.body,
+                signal: AbortSignal.timeout(opts.timeoutMs ?? 30_000),
+                redirect: 'error', // kimlik başlığıyla yönlendirme takip edilmez
+            });
+            const text = await res.text();
+            if ([502, 503, 504].includes(res.status) && i < attempts - 1) {
+                await sleep(400 * 2 ** i);
+                continue;
+            }
+            let json;
+            try {
+                json = text ? JSON.parse(text) : undefined;
+            }
+            catch {
+                json = undefined;
+            }
+            return { status: res.status, ok: res.ok, headers: res.headers, text, json };
+        }
+        catch (err) {
+            lastErr = err;
+            if (i < attempts - 1) {
+                await sleep(400 * 2 ** i);
+                continue;
+            }
+        }
+    }
+    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}`);
+}
+/** 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;
+    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)) ?? '';
+    throw new ApiError(res.status, message || `HTTP ${res.status}`, code, res.json ?? res.text);
+}

package/dist/output.js

@@ -0,0 +1,52 @@
+// Terminal çıktısı: renk (NO_COLOR/TTY'ye saygılı), tablo, --json modu. --json iken insan okuyacağı metin stderr'e gider,
+// stdout yalnızca makine-okunur JSON taşır.
+const CODES = {
+    red: [31, 39], green: [32, 39], yellow: [33, 39], cyan: [36, 39], dim: [2, 22], bold: [1, 22],
+};
+export function paintWith(color, style, text) {
+    if (!color)
+        return text;
+    const [open, close] = CODES[style];
+    return `\u001b[${open}m${text}\u001b[${close}m`;
+}
+export function createOutput(opts = {}) {
+    const stdout = opts.stdout ?? process.stdout;
+    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 human = (s) => (json ? stderr : stdout).write(s + '\n');
+    return {
+        json,
+        color,
+        info: (m) => { human(m); },
+        warn: (m) => { stderr.write(paintWith(color, 'yellow', m) + '\n'); },
+        error: (m) => { stderr.write(paintWith(color, 'red', m) + '\n'); },
+        result: (obj) => { if (json)
+            stdout.write(JSON.stringify(obj, null, 2) + '\n'); },
+        paint: (style, text) => paintWith(color, style, text),
+    };
+}
+/** Sütunları hizalayan basit tablo; başlık dim. */
+export function renderTable(out, headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => visibleLength(r[i] ?? ''))));
+    const line = (cells) => cells.map((c, i) => c + ' '.repeat(Math.max(0, (widths[i] ?? 0) - visibleLength(c)))).join('  ').trimEnd();
+    return [out.paint('dim', line(headers)), ...rows.map(line)].join('\n');
+}
+// eslint-disable-next-line no-control-regex
+const ANSI = /\u001b\[[0-9;]*m/g;
+export function visibleLength(s) {
+    return [...s.replace(ANSI, '')].length;
+}
+export function formatBytes(n) {
+    if (!Number.isFinite(n) || n < 0)
+        return '—';
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let v = n;
+    let i = 0;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return `${v.toFixed(v < 10 && i > 0 ? 1 : 0)} ${units[i]}`;
+}

package/dist/precheck.js

@@ -0,0 +1,74 @@
+import { lstatSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+export const DEFAULT_LIMITS = { maxFiles: 10000, maxFileBytes: 100 * 1024 * 1024 };
+export const RESERVED_DIR = '_enformik';
+const MAX_ISSUES = 20;
+export function precheckSite(dir, limits = DEFAULT_LIMITS) {
+    const files = [];
+    const issues = [];
+    const add = (code, path, message) => {
+        if (issues.length < MAX_ISSUES)
+            issues.push({ code, path, message });
+    };
+    const seen = new Set();
+    let total = 0;
+    let hasRootIndex = false;
+    const nestedIndexDirs = new Set();
+    const walk = (abs, rel) => {
+        for (const ent of readdirSync(abs, { withFileTypes: true }).sort((a, b) => (a.name < b.name ? -1 : 1))) {
+            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.`);
+                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.`);
+                continue;
+            }
+            const st = lstatSync(absPath);
+            if (st.isSymbolicLink() || (!st.isFile() && !st.isDirectory())) {
+                add('unsupported_entry', relPath, 'Sembolik bağ veya özel dosya desteklenmez.');
+                continue;
+            }
+            if (st.isDirectory()) {
+                walk(absPath, relPath);
+                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.');
+                continue;
+            }
+            seen.add(key);
+            if (relPath === 'index.html')
+                hasRootIndex = true;
+            const parts = relPath.split('/');
+            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.`);
+                continue;
+            }
+            files.push({ name: relPath, path: absPath, size: st.size, mtime: st.mtime });
+            total += st.size;
+        }
+    };
+    walk(dir, '');
+    if (files.length > limits.maxFiles) {
+        add('too_many_files', undefined, `Arşivde en fazla ${limits.maxFiles} dosya olabilir (${files.length} bulundu).`);
+    }
+    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).`);
+    }
+    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)}).`);
+        }
+        else {
+            add('missing_index', 'index.html', 'Dizinin kökünde index.html bulunmalı.');
+        }
+    }
+    return { files, unpackedBytes: total, issues };
+}

package/dist/schema.js

@@ -0,0 +1,170 @@
+import { ApiError, CliError } from './errors.js';
+import { ensureOk, joinUrl, request } from './http.js';
+import { renderTable } from './output.js';
+export function parseManifest(text, path) {
+    let m;
+    try {
+        m = JSON.parse(text);
+    }
+    catch (e) {
+        throw new CliError(`${path} geçerli JSON değil: ${e.message}`);
+    }
+    if (typeof m !== 'object' || m === null || Array.isArray(m))
+        throw new CliError(`${path} bir nesne olmalı.`);
+    const mod = m.module;
+    if (!mod || typeof mod.slug !== 'string' || !mod.slug)
+        throw new CliError(`${path}: "module.slug" zorunlu.`);
+    if (typeof mod.version !== 'string' || !mod.version)
+        throw new CliError(`${path}: "module.version" zorunlu.`);
+    return m;
+}
+/**
+ * Yönetici dışı bir istemcinin (schema-deployer) uygulayamayacağı bölümler — sunucudaki manifestUpgradeNeeds'in aynası.
+ * Yalnızca ÖNCEDEN UYARI içindir; karar sunucudadır (admin istemci hepsini uygulayabilir).
+ */
+export function adminOnlySections(m, opts) {
+    const out = [];
+    const has = (v) => Array.isArray(v) && v.length > 0;
+    if (has(m.scripts))
+        out.push('scripts');
+    if (has(m.automationRules))
+        out.push('automationRules');
+    if (has(m.dataSources))
+        out.push('dataSources');
+    if (has(m.interpages))
+        out.push('interpages');
+    if (opts.seedData && has(m.seedData))
+        out.push('seedData');
+    if (m.rbac && (has(m.rbac.capabilities) || has(m.rbac.roles)))
+        out.push('rbac');
+    if (has(m.uiExtensions))
+        out.push('uiExtensions');
+    return out;
+}
+const PENDING = new Set(['create', 'alter', 'drop']);
+/** Uygulanacak (kalıcı) değişiklikler: none/kept_local sayılmaz; veri içeren alanın silinmesi sunucuda atlanır. */
+export function pendingChanges(diffs) {
+    return diffs.filter((d) => PENDING.has(d.action) && !(d.action === 'drop' && d.hasData));
+}
+export function typeChanges(diffs) {
+    return diffs.filter((d) => d.resourceType === 'field' && d.action === 'alter');
+}
+const ACTION_LABEL = {
+    create: '+ ekle', alter: '~ değiştir', drop: '- sil', none: '= aynı', kept_local: '= yerel kalır',
+};
+export function renderDiff(out, result, opts = {}) {
+    const lines = [];
+    const pending = pendingChanges(result.diffs);
+    if (pending.length > 0) {
+        lines.push(out.paint('yellow', out.paint('bold', '⚠  DİKKAT: ŞEMA DEĞİŞİKLİĞİ UYGULAMANIN TAMAMINI ETKİLER')));
+        lines.push(out.paint('yellow', `Bu işlem tek bir çalışma alanını değil, ${opts.appHost ? `"${opts.appHost}" ` : ''}uygulamasındaki TÜM çalışma alanlarını etkiler.`));
+        lines.push('');
+    }
+    const shown = result.diffs.filter((d) => d.action !== 'none');
+    if (shown.length === 0) {
+        lines.push('Değişiklik yok: uygulamadaki modül manifestle aynı.');
+    }
+    else {
+        const rows = shown.map((d) => {
+            const label = ACTION_LABEL[d.action] ?? d.action;
+            const colored = d.action === 'create' ? out.paint('green', label)
+                : d.action === 'drop' ? out.paint('red', label)
+                    : d.action === 'alter' ? out.paint('yellow', label) : out.paint('dim', label);
+            const detail = d.action === 'drop' && d.hasData ? 'veri içerdiği için ATLANACAK' : (d.details || d.warning || '');
+            return [d.resourceType, d.slug, colored, detail];
+        });
+        lines.push(renderTable(out, ['TÜR', 'AD', 'İŞLEM', 'AYRINTI'], rows));
+        const count = (a) => shown.filter((d) => d.action === a).length;
+        lines.push('');
+        lines.push(`Özet: ${count('create')} eklenecek, ${count('alter')} değişecek, ${count('drop')} silinecek` +
+            (count('kept_local') ? `, ${count('kept_local')} yerel özelleştirme korunacak` : '') + '.');
+    }
+    for (const e of result.errors ?? [])
+        lines.push(out.paint('red', `Hata: ${e}`));
+    return lines.join('\n');
+}
+export class SchemaClient {
+    o;
+    constructor(o) {
+        this.o = o;
+    }
+    headers(extra = {}) {
+        return {
+            Authorization: `Bearer ${this.o.token}`,
+            'X-Tenant-ID': this.o.workspaceId,
+            'X-Enformik-CLI-Version': this.o.version,
+            ...extra,
+        };
+    }
+    /** slug → modül kimliği. 404: modül kurulu değil (ilk kurulumu bir yönetici yapar). */
+    async resolveModule(slug) {
+        const res = await request(joinUrl(this.o.appUrl, `/api/module-by-slug/${encodeURIComponent(slug)}`), {
+            headers: this.headers(), retries: 2, fetchImpl: this.o.fetchImpl,
+        });
+        try {
+            ensureOk(res);
+        }
+        catch (e) {
+            throw describeSchemaError(e, { slug });
+        }
+        const j = res.json;
+        return { id: j.id, name: j.name, version: j.version };
+    }
+    async diff(moduleId, manifestJson, opts) {
+        const res = await request(joinUrl(this.o.appUrl, `/api/modules/${moduleId}/diff${opts.seedData ? '?seed_data=true' : ''}`), {
+            method: 'POST', headers: this.headers({ 'Content-Type': 'application/json' }), body: manifestJson, retries: 1, timeoutMs: 120_000, fetchImpl: this.o.fetchImpl,
+        });
+        try {
+            ensureOk(res);
+        }
+        catch (e) {
+            throw describeSchemaError(e, {});
+        }
+        return normalizeDiff(res.json);
+    }
+    async upgrade(moduleId, manifestJson, opts) {
+        // retries: 0 — uygulama tekrar edilmemeli (ağ hatasında durumu `diff` ile kontrol edin).
+        const res = await request(joinUrl(this.o.appUrl, `/api/modules/${moduleId}/upgrade${opts.seedData ? '?seed_data=true' : ''}`), {
+            method: 'POST', headers: this.headers({ 'Content-Type': 'application/json' }), body: manifestJson, timeoutMs: 300_000, fetchImpl: this.o.fetchImpl,
+        });
+        try {
+            ensureOk(res);
+        }
+        catch (e) {
+            throw describeSchemaError(e, {});
+        }
+        return normalizeDiff(res.json);
+    }
+}
+function normalizeDiff(j) {
+    const o = (j ?? {});
+    return { moduleId: o.moduleId ?? '', diffs: Array.isArray(o.diffs) ? o.diffs : [], errors: Array.isArray(o.errors) ? o.errors : [] };
+}
+/** Sunucu hatalarını (özellikle yetki sınırlarını) kullanıcıya anlaşılır biçimde çevirir. */
+export function describeSchemaError(e, ctx) {
+    if (!(e instanceof ApiError))
+        return e;
+    const body = (e.body ?? {});
+    switch (e.code) {
+        case 'manifest_requires_admin':
+            return new CliError(`Bu manifest, istemcinizin rolünü aşan bölümler içeriyor: ${(body.sections ?? []).join(', ')}.\n` +
+                'Bu bölümleri (betik, otomasyon, yetki tanımı vb.) bir yönetici uygulamalıdır; bunları manifestten çıkarın ya da yönetici rolündeki bir istemciyle çalıştırın.', 1, e.code, e.body);
+        case 'type_change_requires_admin':
+            return new CliError(`Alan türü değişikliği veriyi dönüştürebilir ve yalnızca yönetici tarafından uygulanır: ${(body.fields ?? []).join(', ')}.`, 1, e.code, e.body);
+        case 'breaking_change_blocked':
+            return new CliError(`${e.message}`, 1, e.code, e.body);
+        case 'module_not_found':
+            return new CliError(`"${ctx.slug ?? 'modül'}" slug'lı bir modül bu uygulamada kurulu değil. Modülün ilk kurulumunu (içe aktarma) bir yönetici bir kez yapmalıdır; sonraki yükseltmeleri bu CLI yapar.`, 1, e.code);
+        case 'payment_required':
+            return new CliError('Uygulamanın planı/ödeme durumu nedeniyle işlem engellendi (402). Konsoldan abonelik durumunu kontrol edin.', 1, e.code);
+    }
+    if (e.status === 401)
+        return new CliError('Kimlik reddedildi (401): belirteç geçersiz ya da istemci iptal edilmiş.', 1, 'unauthorized');
+    if (e.status === 403) {
+        return new CliError('Bu istemcinin rolü modül yükseltmeye yetmiyor (403). Konsolda rolü "Şema yükseltici" ya da "Yönetici" olan bir API istemcisi kullanın.' +
+            (body.required ? ` (gereken yetki: ${body.required})` : ''), 1, 'forbidden');
+    }
+    if (e.status === 404)
+        return new CliError(`Kayıt bulunamadı (404): ${e.message}`, 1, 'not_found');
+    return new CliError(`Sunucu hatası (HTTP ${e.status}): ${e.message}`, 1, e.code);
+}

package/dist/site.js

@@ -0,0 +1,129 @@
+import { execFileSync } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { ApiError, CliError } from './errors.js';
+import { ensureOk, joinUrl, request } from './http.js';
+// Web sitesi dağıtımı — makine uçları (/api/deploy/v1) istemcisi. Akış: init → PUT content → finalize → poll.
+// Sözleşme: docs/plans/DEVELOPER_PLATFORM_DEPLOY_DESIGN.md §3.4, §4.
+export const MAX_ARCHIVE_BYTES = 50 * 1024 * 1024;
+export class DeployClient {
+    o;
+    constructor(o) {
+        this.o = o;
+    }
+    url(path) { return joinUrl(this.o.consoleUrl, `/api/deploy/v1${path}`); }
+    headers(extra = {}) {
+        return { Authorization: `Bearer ${this.o.deployKey}`, 'X-Enformik-CLI-Version': this.o.version, ...extra };
+    }
+    async call(path, init) {
+        const res = await request(this.url(path), { ...init, headers: this.headers(init.headers), fetchImpl: this.o.fetchImpl });
+        try {
+            ensureOk(res);
+        }
+        catch (e) {
+            throw describeDeployError(e);
+        }
+        return (res.json ?? {});
+    }
+    getSite() { return this.call('/site', { retries: 2 }); }
+    async init(body, idempotencyKey) {
+        return this.call('/deployments', {
+            method: 'POST', headers: { 'Content-Type': 'application/json', 'Idempotency-Key': idempotencyKey },
+            body: JSON.stringify(body), retries: 2, // Idempotency-Key ile tekrar güvenli
+        });
+    }
+    async upload(id, zipPath) {
+        // Yeniden deneme yok: kısmi yükleme sonrası tekrar 409 (invalid_state) döner; kullanıcı komutu yeniden çalıştırır.
+        const data = readFileSync(zipPath);
+        await this.call(`/deployments/${id}/content`, { method: 'PUT', headers: { 'Content-Type': 'application/zip' }, body: data, timeoutMs: 600_000 });
+    }
+    finalize(id) {
+        return this.call(`/deployments/${id}/finalize`, { method: 'POST', retries: 2 });
+    }
+    async status(id) {
+        return (await this.call(`/deployments/${id}`, { retries: 2 })).deployment;
+    }
+}
+const TERMINAL = new Set(['live', 'failed', 'expired', 'superseded']);
+export const isTerminal = (s) => TERMINAL.has(s);
+/** Durum değiştikçe onStatus çağırarak terminal duruma kadar bekler. */
+export async function waitForDeployment(client, id, opts) {
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const now = opts.now ?? Date.now;
+    const start = now();
+    let last = '';
+    let interval = opts.intervalMs ?? 2000;
+    for (;;) {
+        const v = await client.status(id);
+        if (v.status !== last) {
+            last = v.status;
+            opts.onStatus?.(v.status);
+        }
+        if (isTerminal(v.status))
+            return v;
+        if (now() - start > opts.timeoutMs)
+            throw new CliError(`Zaman aşımı: dağıtım ${Math.round(opts.timeoutMs / 1000)} sn içinde tamamlanmadı (son durum: ${v.status}). Konsolun "Sürümler" sekmesinden izleyebilirsiniz.`);
+        await sleep(interval);
+        interval = Math.min(interval + 500, 5000);
+    }
+}
+export function sha256File(path) {
+    return createHash('sha256').update(readFileSync(path)).digest('hex');
+}
+/** CI'dan commit/dal/koşu bilgisi (isteğe bağlı; bulunamazsa boş). */
+export function collectMeta(env, cwd, git = (a) => gitCmd(cwd, a)) {
+    const meta = {};
+    const sha = env.GITHUB_SHA || env.CI_COMMIT_SHA || env.BITBUCKET_COMMIT || env.BUILD_VCS_NUMBER || git(['rev-parse', 'HEAD']);
+    if (sha)
+        meta.gitSha = sha;
+    const ref = env.GITHUB_REF_NAME || env.CI_COMMIT_REF_NAME || env.BITBUCKET_BRANCH || git(['rev-parse', '--abbrev-ref', 'HEAD']);
+    if (ref && ref !== 'HEAD')
+        meta.gitRef = ref;
+    if (env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY && env.GITHUB_RUN_ID)
+        meta.runUrl = `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID}`;
+    else if (env.CI_PIPELINE_URL)
+        meta.runUrl = env.CI_PIPELINE_URL;
+    return meta;
+}
+function gitCmd(cwd, args) {
+    try {
+        return execFileSync('git', args, { cwd, timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Idempotency-Key: CI'da koşu + deneme numarası (yeniden çalıştırma yeni anahtar alır, yoksa eski — belki başarısız —
+ * dağıtım "tekrar oynatılırdı"); yerelde her çalıştırma için rastgele.
+ */
+export function idempotencyKey(env, rand = randomUUID) {
+    if (env.GITHUB_RUN_ID)
+        return `gh-${env.GITHUB_RUN_ID}-${env.GITHUB_RUN_ATTEMPT ?? '1'}`.slice(0, 64);
+    if (env.CI_PIPELINE_ID)
+        return `gl-${env.CI_PIPELINE_ID}-${env.CI_JOB_ID ?? '0'}`.slice(0, 64);
+    return `cli-${rand()}`.slice(0, 64);
+}
+const HINTS = {
+    invalid_key: 'Dağıtım anahtarı geçersiz, iptal edilmiş ya da bu siteye ait değil. ENFORMIK_DEPLOY_KEY değerini kontrol edin.',
+    key_expired: 'Dağıtım anahtarının süresi dolmuş. Konsolda yeni bir anahtar oluşturup CI gizli değişkenini güncelleyin.',
+    rate_limited: 'Çok fazla geçersiz anahtar denemesi; biraz bekleyip yeniden deneyin.',
+    developer_site_disabled: 'Bu ortamda geliştirici sitesi etkin değil. Konsolda "Geliştirici sitesi" penceresinden etkinleştirin.',
+    environment_inactive: 'Web sitesi ortamı şu anda kullanılamıyor (ör. abonelik askıda).',
+    deploy_in_progress: 'Bu ortamda devam eden bir dağıtım var; bitmesini bekleyip yeniden deneyin.',
+    deploy_unavailable: 'Dağıtım altyapısı şu anda hazır değil; biraz sonra yeniden deneyin.',
+    deployment_expired: 'Yükleme süresi dolmuş; komutu yeniden çalıştırın.',
+    quota_exceeded: 'Arşiv izin verilen boyutu aşıyor (en çok 50 MB).',
+    size_mismatch: 'Yüklenen içerik bildirilen boyutla uyuşmuyor; komutu yeniden çalıştırın.',
+    checksum_mismatch: 'Yüklenen içeriğin sağlama toplamı uyuşmuyor (yükleme bozulmuş olabilir); komutu yeniden çalıştırın.',
+};
+export function describeDeployError(e) {
+    if (!(e instanceof ApiError))
+        return e;
+    const hint = e.code ? HINTS[e.code] : undefined;
+    const detail = e.body?.details;
+    let msg = hint ?? e.message ?? `HTTP ${e.status}`;
+    if (e.code === 'artifact_invalid' && Array.isArray(detail))
+        msg = `Arşiv geçerli değil: ${detail.map((d) => d.message).join('; ')}`;
+    return new CliError(msg, 1, e.code, e.body);
+}

package/dist/zip.js

@@ -0,0 +1,99 @@
+import { closeSync, openSync, readFileSync, writeSync } from 'node:fs';
+import { deflateRawSync } from 'node:zlib';
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+export function crc32(buf) {
+    let c = 0xffffffff;
+    for (let i = 0; i < buf.length; i++)
+        c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+function dosDateTime(d) {
+    const y = Math.max(1980, d.getFullYear());
+    return {
+        time: (d.getHours() << 11) | (d.getMinutes() << 5) | Math.floor(d.getSeconds() / 2),
+        date: ((y - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate(),
+    };
+}
+const MAX_ENTRIES = 0xffff;
+const MAX_U32 = 0xffffffff;
+/** Girdileri sıralı (deterministik) olarak outPath'e zipler. */
+export function writeZipFile(files, outPath) {
+    if (files.length > MAX_ENTRIES)
+        throw new Error(`Zip en fazla ${MAX_ENTRIES} girdi içerebilir.`);
+    const sorted = [...files].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const fd = openSync(outPath, 'w');
+    let offset = 0;
+    const central = [];
+    const write = (b) => { writeSync(fd, b); offset += b.length; };
+    try {
+        for (const f of sorted) {
+            const data = readFileSync(f.path);
+            if (data.length >= MAX_U32)
+                throw new Error(`Dosya çok büyük (zip64 desteklenmiyor): ${f.name}`);
+            const name = Buffer.from(f.name, 'utf8');
+            const deflated = deflateRawSync(data, { level: 6 });
+            const useDeflate = deflated.length < data.length;
+            const body = useDeflate ? deflated : data;
+            const method = useDeflate ? 8 : 0;
+            const crc = crc32(data);
+            const { time, date } = dosDateTime(f.mtime);
+            const localOffset = offset;
+            const local = Buffer.alloc(30);
+            local.writeUInt32LE(0x04034b50, 0);
+            local.writeUInt16LE(20, 4); // gereken sürüm
+            local.writeUInt16LE(0x0800, 6); // bayrak: UTF-8 ad
+            local.writeUInt16LE(method, 8);
+            local.writeUInt16LE(time, 10);
+            local.writeUInt16LE(date, 12);
+            local.writeUInt32LE(crc, 14);
+            local.writeUInt32LE(body.length, 18);
+            local.writeUInt32LE(data.length, 22);
+            local.writeUInt16LE(name.length, 26);
+            local.writeUInt16LE(0, 28);
+            write(local);
+            write(name);
+            write(body);
+            const c = Buffer.alloc(46);
+            c.writeUInt32LE(0x02014b50, 0);
+            c.writeUInt16LE((3 << 8) | 20, 4); // üreten: Unix, sürüm 2.0
+            c.writeUInt16LE(20, 6);
+            c.writeUInt16LE(0x0800, 8);
+            c.writeUInt16LE(method, 10);
+            c.writeUInt16LE(time, 12);
+            c.writeUInt16LE(date, 14);
+            c.writeUInt32LE(crc, 16);
+            c.writeUInt32LE(body.length, 20);
+            c.writeUInt32LE(data.length, 24);
+            c.writeUInt16LE(name.length, 28);
+            c.writeUInt32LE(((0o100644 << 16) >>> 0), 38); // normal dosya, 0644
+            c.writeUInt32LE(localOffset, 42);
+            central.push(Buffer.concat([c, name]));
+        }
+        const cdStart = offset;
+        for (const c of central)
+            write(c);
+        const cdSize = offset - cdStart;
+        const end = Buffer.alloc(22);
+        end.writeUInt32LE(0x06054b50, 0);
+        end.writeUInt16LE(sorted.length, 8);
+        end.writeUInt16LE(sorted.length, 10);
+        end.writeUInt32LE(cdSize, 12);
+        end.writeUInt32LE(cdStart, 16);
+        write(end);
+        if (offset >= MAX_U32)
+            throw new Error('Zip 4 GB sınırını aşıyor.');
+        return { entries: sorted.length, bytes: offset };
+    }
+    finally {
+        closeSync(fd);
+    }
+}