@appaflytech/zeyrek-ai-mcp 0.0.36 → 0.0.40

package/dist/platform/secrets.js

@@ -1,22 +1,79 @@
 /**
  * Desen `trace.ts`'in eski kopyasından DARALTILDI: `pass` parçası `passed`/`bypass` gibi
  * anahtarları da yakalıyordu. Günlükte zararsızdı, tool yanıtında veri kaybı olurdu.
+ *
+ * `cookie` yalnız TAM ad olarak eşleşir (g-01, 37 S-24): paketli şemalarda `StepRuleDto.cookieKey`
+ * çerezin ADINI taşır; parça eşleşmesi onu `***` yapıp workflow_get → update turunu bozardı (GW-001).
+ * `setcookie` de bilinçli dışarıda: workflow adım tipinin adıdır, sır değildir.
  */
-export const secretKeyPattern = /password|passwd|secret|token|authorization|api[-_]?key|credential|connection[-_]?string/i;
+export const secretKeyPattern = /password|passwd|secret|token|authorization|api[-_]?key|credential|connection[-_]?string|^cookies?$/i;
+/**
+ * Sırrın DEĞERİNİ değil adını, yerini ya da türünü taşıyan anahtarlar: `credentialRef`, `tokenUrl`,
+ * `apiKeyHeader`, `secretFields`, `credentialKind`. Maskelenirlerse süreç tanımındaki
+ * `connector.credentialRef` get → update turunda `***` olarak geri yazılır ve düğüm kasayı bulamaz
+ * (BPM-017, Faz 8 incelemesi). Yalnız yanıt maskesinde uygulanır; günlük maskesi (`trace.ts`) geniş kalır.
+ */
+export const secretNameKeyPattern = /(ref|refs|url|uri|header|fields|kind|name|names|id|ids)$/i;
 import { looksLikeJwt, rememberToken } from './tokenVault.js';
 const maskedValue = '***';
 const maxPaths = 20;
 const maxDepth = 12;
+/**
+ * Ad/değer çiftinde `value`'nun yerine geçen ad (g-01, 37 S-24). Debug girdisi isteğin başlık ve
+ * çerezlerini `{ expression: 'Authorization', value: 'Bearer …', source, member }` olarak yazar; sırrın
+ * adı anahtarda değil kardeş alanda durduğu için anahtar kuralı hiçbirini görmüyordu.
+ *
+ * `type` ya da `order` taşıyan satır platform TANIMIDIR — `StepQueryParameterDto {name,value,type}`,
+ * `StepCustomParameterDto {name,value,order}`, `QueryParameter {name,type,value}`: değer bağlama
+ * ifadesidir (`input.token`), maskelenirse get → update turunda `***` geri yazılır (GW-001).
+ * `expression` + `value` hiçbir paketli şemada geçmez, o yüzden bu ayrımın dışındadır.
+ */
+export function secretPairName(record) {
+    if (!('value' in record))
+        return undefined;
+    if (typeof record.expression === 'string')
+        return record.expression;
+    if ('type' in record || 'order' in record)
+        return undefined;
+    if (typeof record.name === 'string')
+        return record.name;
+    return typeof record.key === 'string' ? record.key : undefined;
+}
+/**
+ * Anahtarsız string yapraktaki kimlik (g-01): `eyJ…` ile başlayan JWT ve `Bearer <jeton>`.
+ * `maskSecretText`'ten DAR: o konsol metni içindir ve her üç parçalı noktalı adı JWT sayar —
+ * yanıtta `organization.something.localhost` gibi bir adı körleştirirdi. Bearer'dan sonra en az
+ * 16 karakter aranır; rehber metnindeki "Bearer olarak" maskelenmez.
+ */
+export function maskSecretLeaf(text) {
+    return text
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]{16,}/gi, `Bearer ${maskedValue}`)
+        .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g, maskedValue);
+}
 function walk(value, path, masked, refs, depth) {
     if (depth > maxDepth)
         return value;
+    if (typeof value === 'string') {
+        const safe = maskSecretLeaf(value);
+        if (safe === value)
+            return value;
+        if (masked.length < maxPaths)
+            masked.push(path);
+        if (looksLikeJwt(value) && Object.keys(refs).length < maxPaths)
+            refs[path] = rememberToken(value);
+        return safe;
+    }
     if (Array.isArray(value))
         return value.map((entry, index) => walk(entry, `${path}[${index}]`, masked, refs, depth + 1));
     if (value && typeof value === 'object') {
         const result = {};
+        const pairName = secretPairName(value);
         for (const [key, entry] of Object.entries(value)) {
             const child = path === '' ? key : `${path}.${key}`;
-            if (secretKeyPattern.test(key) && entry !== null && entry !== undefined && entry !== '') {
+            const name = key === 'value' && pairName !== undefined ? pairName : key;
+            // Boole değer sır taşıyamaz: `hasExpoAccessToken: true` maskelenince ajan token'ın kayıtlı
+            // olup olmadığını öğrenemiyordu (push bildirimleri g-01, 2026-10-02; GW-001 ailesi).
+            if (secretKeyPattern.test(name) && !secretNameKeyPattern.test(name) && typeof entry !== 'boolean' && entry !== null && entry !== undefined && entry !== '') {
                 if (masked.length < maxPaths)
                     masked.push(child);
                 // Maskelenen değer bir JWT ise kimlik testinin yolu kapanmasın: jeton kasada tutulur ve
@@ -38,3 +95,12 @@ export function maskSecrets(payload) {
     const tokenRefs = {};
     return { payload: walk(payload, '', masked, tokenRefs, 0), masked, tokenRefs };
 }
+/**
+ * Serbest METİNDEKİ kimlik parçaları (konsol satırı, hata yığını): JWT biçimli dize ve `Bearer …`.
+ * `maskSecrets` anahtar adına bakar; tarayıcı konsolu anahtarsız düz metin taşır (g-06).
+ */
+export function maskSecretText(text) {
+    return text
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, `Bearer ${maskedValue}`)
+        .replace(/\b[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, maskedValue);
+}

package/dist/platform/strictArguments.js

@@ -1,5 +1,11 @@
 import { z } from 'zod';
 import { diagnosticsParam, runWithDiagnostics } from './diagnostics.js';
+import { applyArgumentAliases, closestArgument, runWithArgumentNotes } from './argumentAliases.js';
+import { BODY_FILE_ARGUMENTS, bodyFileParam, loadBodyFile } from './bodyFile.js';
+import { PlatformApiError } from './errors.js';
+import { logError } from '../observability/trace.js';
+/** Doğrulanmış argümanlara takılan çeviri notları (`ArgumentNotes`); JSON'a ve platform isteğine girmez. */
+const ARGUMENT_NOTES = Symbol('argumentNotes');
 /**
  * `writes`/`updates` açıklamalı ama KAYIT yazmayan tool'lar: çalıştırma, önizleme, dışa aktarma, indirme,
  * bağlantı testi. Yanıtlarında yazma tanılaması (silentlyDropped) yoktur; parametre yalnız tool listesini
@@ -25,25 +31,75 @@ function isRawShape(value) {
  * olmayan bir sorgu kusuruna yönlendirdi. Tek tek tool'lara alan eklemek sınıfı kapatmaz; sessizlik
  * burada, SDK'ya şema verilmeden önce kaldırılır.
  */
-export function rejectUnknownArguments(server) {
+export function rejectUnknownArguments(server, platform) {
     const registerTool = server.registerTool.bind(server);
+    // Zorunlu gövde argümanı `bodyFile` açıkken şemada isteğe bağlı yayınlanır (yoksa şemaya uyan istemci
+    // gövdeyi satır içinde yollamak zorunda kalır ve `bodyFile` "birlikte verilemez" ile reddedilirdi);
+    // zorunluluk dosya okunduktan sonra burada denetlenir.
+    const requiredBodies = new Map();
+    // g-07/g-08: `bodyFile` ve takma ad tablosu SDK'nın strict doğrulamasından ÖNCE koşmalı — sonra
+    // koşsa yanlış ad zaten reddedilmiş, dosyadan gelen gövde doğrulanmamış olur. SDK doğrulamayı
+    // `validateToolInput` içinde yapar; çeviri orada uygulanır ve notlar doğrulanmış argümanlara
+    // sembol anahtarla takılır.
+    if (platform) {
+        const validator = server;
+        const validate = validator.validateToolInput.bind(server);
+        validator.validateToolInput = async (tool, args, name) => {
+            try {
+                const loaded = await loadBodyFile(name, args, platform.config);
+                const requiredBody = requiredBodies.get(name);
+                if (requiredBody && loaded.args?.[requiredBody] === undefined) {
+                    throw new PlatformApiError(`${name}: '${requiredBody}' zorunlu — satır içinde ya da bodyFile ile (.json dosyası) verin. İstek gönderilmedi.`, 400);
+                }
+                const { args: aliased, applied } = await applyArgumentAliases(name, loaded.args, { platform, shape: tool.inputSchema?.shape ?? {} });
+                const parsed = await validate(tool, aliased, name);
+                const notes = { aliasesApplied: applied, ...(loaded.note ? { bodyFile: loaded.note } : {}) };
+                return (applied.length > 0 || loaded.note) && parsed && typeof parsed === 'object' ? Object.assign(parsed, { [ARGUMENT_NOTES]: notes }) : parsed;
+            }
+            catch (error) {
+                // Doğrulamadan önceki çeviri (dosya, takma ad) `handle`'ın dışında koşar: hata burada günlüğe yazılır.
+                if (error instanceof PlatformApiError)
+                    logError(error);
+                throw error;
+            }
+        };
+    }
     server.registerTool = ((name, config, callback) => {
         if (!isRawShape(config.inputSchema))
             return registerTool(name, config, callback);
-        // Yazma tool'ları tanılama kipini alır; parametre handler'a ULAŞMAZ (gövdeyi `...rest` ile
-        // platforma geçiren tool'larda sızardı), yalnız toolResult'ın okuduğu bağlama konur.
-        const writesDiagnostics = config.annotations?.readOnlyHint === false && config.annotations.destructiveHint !== true && !NON_WRITING_TOOLS.has(name);
-        const shape = writesDiagnostics ? { ...config.inputSchema, diagnostics: diagnosticsParam } : config.inputSchema;
-        const run = writesDiagnostics
-            ? ((args, extra) => {
-                const { diagnostics, ...rest } = args ?? {};
-                return runWithDiagnostics(diagnostics === 'full' ? 'full' : 'compact', () => callback(rest, extra));
-            })
-            : callback;
+        // Tanılama notları her tool'da compact döner (g-08: okuma ve çalıştırma yanıtında da 8 not +
+        // "N not daha"). `diagnostics` parametresi yalnız kayıt yazan tool'lara, microservice_execute'a ve
+        // *_preview'a açılır — ötekilerde tool listesini büyütmesin diye varsayılan kullanılır. Parametre
+        // handler'a ULAŞMAZ (gövdeyi `...rest` ile platforma geçiren tool'larda sızardı), yalnız
+        // toolResult'ın okuduğu bağlama konur.
+        const writesRecords = config.annotations?.readOnlyHint === false && config.annotations.destructiveHint !== true && !NON_WRITING_TOOLS.has(name);
+        const exposesDiagnostics = writesRecords || name === 'microservice_execute' || name.endsWith('_preview');
+        const bodyArgument = BODY_FILE_ARGUMENTS[name];
+        const bodySchema = bodyArgument ? config.inputSchema[bodyArgument] : undefined;
+        if (bodyArgument && bodySchema && !bodySchema.isOptional())
+            requiredBodies.set(name, bodyArgument);
+        const shape = {
+            ...config.inputSchema,
+            ...(bodyArgument && bodySchema ? { [bodyArgument]: bodySchema.optional(), bodyFile: bodyFileParam(bodyArgument) } : {}),
+            ...(exposesDiagnostics ? { diagnostics: diagnosticsParam } : {})
+        };
+        const invoke = (args, extra) => {
+            const { diagnostics, ...rest } = exposesDiagnostics ? args ?? {} : { ...args, diagnostics: undefined };
+            return runWithDiagnostics(diagnostics === 'full' ? 'full' : 'compact', () => callback(exposesDiagnostics ? rest : args, extra), exposesDiagnostics);
+        };
+        const run = (args, extra) => {
+            const { [ARGUMENT_NOTES]: notes, ...rest } = args ?? {};
+            return runWithArgumentNotes(notes ?? { aliasesApplied: [] }, () => invoke(rest, extra));
+        };
         const accepted = Object.keys(shape).join(', ');
+        const suggestions = (keys) => keys
+            .map(key => ({ key, near: closestArgument(key, Object.keys(shape)) }))
+            .filter(entry => entry.near !== undefined)
+            .map(entry => ` '${entry.key}' → '${entry.near}' mi demek istediniz?`)
+            .join('');
         const inputSchema = z.object(shape, {
             errorMap: (issue, context) => issue.code === 'unrecognized_keys'
-                ? { message: `${name} şu üst düzey argümanları tanımıyor: ${issue.keys.map(key => `'${key}'`).join(', ')}. Tanınmayan alan sessizce yok sayılmaz — çağrı hiç gönderilmedi. Bu tool'un okuduğu alanlar: ${accepted}.` }
+                ? { message: `${name} şu üst düzey argümanları tanımıyor: ${issue.keys.map(key => `'${key}'`).join(', ')}. Tanınmayan alan sessizce yok sayılmaz — çağrı hiç gönderilmedi. Bu tool'un okuduğu alanlar: ${accepted}.${suggestions(issue.keys)}` }
                 : { message: context.defaultError }
         }).strict();
         return registerTool(name, { ...config, inputSchema }, run);

package/dist/platform/tokenVault.js

@@ -1,5 +1,8 @@
 import { PlatformApiError } from './errors.js';
 import { randomBytes } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { logStep } from '../observability/trace.js';
 /**
  * `page_screenshot`/`page_runtime_get` açıklaması "jetonu uygulamanın kendi giriş ucundan alın
  * (`microservice_execute`)" diyor, ama gizli alan maskesi `access_token`'ı `***` yapıyor ve o yol
@@ -9,10 +12,19 @@ import { randomBytes } from 'node:crypto';
  * Kasa bu çelişkiyi jetonu bağlama HİÇ sokmadan çözer: maskelenen JWT gateway sürecinde tutulur,
  * yanıta yalnız kısa ömürlü bir referans (`tok_…`) döner ve kimlik isteyen tool'lar referansı
  * çözer. Jeton ne yanıtta ne günlükte açık görünür.
+ *
+ * g-09 (`plans/mobil-plantcare-acigi`, K9): kasa süreç sınırını aşar. `.env` `MCP_STATE_DIR`
+ * verilmişse kayıtlar `token-vault.json`'a (0600) yazılır ve süreç açılışta onu okur; süre
+ * `MCP_TOKEN_TTL_MINUTES`'tan gelir (verilmezse eski 15 dk). Dosya YALNIZ lokal hedefte yazılır —
+ * uzak bir org'un jetonu diske inmez. Test kullanıcısının (`asUser: 'test:<ad>'`) jetonu da burada,
+ * etiketiyle tutulur; aynı kullanıcı TTL boyunca yeniden giriş yapmaz.
  */
-const ttlMs = 15 * 60 * 1000;
+const legacyTtlMinutes = 15;
 const maxEntries = 64;
 const vault = new Map();
+let ttlMs = legacyTtlMinutes * 60 * 1000;
+let vaultFile;
+let warnedRemote = false;
 export const tokenRefPattern = /^tok_[0-9a-f]{16}$/;
 /** Üç base64url parçalı JWT — parola ya da API anahtarı bu şekle uymaz. */
 export function looksLikeJwt(value) {
@@ -30,29 +42,132 @@ function sweep(now) {
         vault.delete(oldest.value);
     }
 }
-export function rememberToken(token) {
+function isLocalTarget(baseUrl) {
+    try {
+        const host = new URL(baseUrl).hostname;
+        return host === 'localhost' || host === '127.0.0.1' || host === '[::1]' || host.endsWith('.localhost');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Aynı dosyayı birden çok gateway süreci paylaşır (her Claude Code oturumu kendi stdio sürecini açar).
+ * Yazma "son yazan kazanır" olursa bir sürecin kaydı ötekinin yazmasıyla silinirdi: yazmadan önce ve
+ * bellekte olmayan referans istenince dosya okunur, süresi dolmamış yabancı kayıtlar belleğe katılır.
+ */
+function mergeFromFile() {
+    if (!vaultFile)
+        return;
+    try {
+        const stored = JSON.parse(readFileSync(vaultFile, 'utf8'));
+        const now = Date.now();
+        for (const [ref, entry] of Object.entries(stored.entries ?? {})) {
+            if (!vault.has(ref) && tokenRefPattern.test(ref) && typeof entry.token === 'string' && typeof entry.expires === 'number' && entry.expires > now) {
+                vault.set(ref, { token: entry.token, expires: entry.expires, ...(typeof entry.label === 'string' ? { label: entry.label } : {}) });
+            }
+        }
+    }
+    catch {
+        // dosya yok ya da okunamadı: bellekteki kasa geçerli
+    }
+}
+function persist() {
+    if (!vaultFile)
+        return;
+    mergeFromFile();
+    sweep(Date.now());
+    try {
+        const temporary = `${vaultFile}.${process.pid}.tmp`;
+        mkdirSync(dirname(vaultFile), { recursive: true, mode: 0o700 });
+        writeFileSync(temporary, JSON.stringify({ entries: Object.fromEntries(vault) }), { mode: 0o600 });
+        renameSync(temporary, vaultFile);
+    }
+    catch (error) {
+        logStep('jeton kasası ✕', `kasa dosyası yazılamadı (${vaultFile}) — jetonlar bu süreçte bellekte kalır`, [error instanceof Error ? error.message : String(error)]);
+    }
+}
+/**
+ * Süreç açılışında bir kez çağrılır (`index.ts`); testler yeniden başlamayı `clearTokenVault` +
+ * bu çağrıyla benzetir. Dosyadaki süresi dolmuş kayıtlar yüklenmez ve dosya onlarsız yeniden yazılır.
+ */
+export function configureTokenVault(config) {
+    ttlMs = (config.tokenTtlMinutes ?? legacyTtlMinutes) * 60 * 1000;
+    vaultFile = undefined;
+    if (!config.stateDirectory)
+        return;
+    if (!isLocalTarget(config.orgApiBaseUrl)) {
+        if (!warnedRemote) {
+            warnedRemote = true;
+            logStep('jeton kasası', `ORG_API_BASE_URL lokal değil — kasa dosyaya YAZILMAZ, jetonlar yalnız süreç belleğinde tutulur (MCP_STATE_DIR yok sayıldı)`);
+        }
+        return;
+    }
+    vaultFile = join(config.stateDirectory, 'token-vault.json');
+    persist();
+}
+/** Kasanın geçerli ömrü (dakika) — yanıt notları sabit bir süre yazmasın. */
+export const tokenTtlMinutes = () => Math.round(ttlMs / 60000);
+export function rememberToken(token, label) {
     const now = Date.now();
     sweep(now);
     for (const [ref, entry] of vault) {
         if (entry.token === token) {
             entry.expires = now + ttlMs;
+            if (label !== undefined)
+                entry.label = label;
+            persist();
             return ref;
         }
     }
     const ref = `tok_${randomBytes(8).toString('hex')}`;
-    vault.set(ref, { token, expires: now + ttlMs });
+    vault.set(ref, { token, expires: now + ttlMs, ...(label !== undefined ? { label } : {}) });
+    persist();
     return ref;
 }
 export function resolveToken(reference) {
+    if (!vault.has(reference))
+        mergeFromFile();
     const entry = vault.get(reference);
     if (!entry)
         return undefined;
     if (entry.expires <= Date.now()) {
         vault.delete(reference);
+        persist();
         return undefined;
     }
     return entry.token;
 }
+/**
+ * Jetonun kendi süresi (`exp`) kasanın TTL'inden kısa olabilir: uygulamanın jetonu 15 dk yaşarken kasa
+ * 60 dk tutuyordu ve süresi dolmuş jetonla çekilen kare sessizce çıkış yapmış sayfayı gösterirdi.
+ * 30 sn pay bırakılır; `exp` okunamayan jeton geçerli sayılır (karar uygulamanındır).
+ */
+const jwtExpired = (token) => {
+    try {
+        const payload = JSON.parse(Buffer.from(token.split('.')[1] ?? '', 'base64url').toString('utf8'));
+        return typeof payload.exp === 'number' && payload.exp * 1000 <= Date.now() + 30_000;
+    }
+    catch {
+        return false;
+    }
+};
+function labeledToken(label) {
+    const find = () => {
+        const now = Date.now();
+        for (const entry of vault.values()) {
+            if (entry.label === label && entry.expires > now && !jwtExpired(entry.token))
+                return entry.token;
+        }
+        return undefined;
+    };
+    const found = find();
+    if (found || !vaultFile)
+        return found;
+    mergeFromFile();
+    return find();
+}
+/** Bellekteki kasayı boşaltır (süreç yeniden başlamasının benzetimi); dosyaya dokunmaz. */
 export function clearTokenVault() {
     vault.clear();
 }
@@ -66,8 +181,76 @@ export function resolveIdentityToken(value) {
         return value;
     const token = resolveToken(value);
     if (token === undefined) {
-        throw new PlatformApiError(`'${value}' referansı geçersiz ya da süresi dolmuş (15 dk). Uygulamanın giriş ucunu microservice_execute ile yeniden çağırıp yanıttaki tokenRefs değerini kullanın.`, 400);
+        throw new PlatformApiError(`'${value}' referansı geçersiz ya da süresi dolmuş (${Math.round(ttlMs / 60000)} dk). Tercih edilen yol asUser: 'test:<ad>' — gateway kök .env'deki test kullanıcısıyla kendisi giriş yapar. Yoksa uygulamanın giriş ucunu microservice_execute ile yeniden çağırıp yanıttaki tokenRefs değerini kullanın.`, 400);
+    }
+    return token;
+}
+/**
+ * Giriş yanıtındaki erişim jetonu: yanıt birden çok JWT taşıyabilir (erişim + yenileme). Anahtarı
+ * `access` içeren önce, sonra `refresh` içermeyen, en son ilk bulunan — yenileme jetonuyla istek atmak
+ * her uçta 401 demekti.
+ */
+function accessJwt(value) {
+    const found = [];
+    const collect = (node, key, depth) => {
+        if (depth > 12)
+            return;
+        if (looksLikeJwt(node)) {
+            found.push({ key, token: node });
+            return;
+        }
+        if (Array.isArray(node))
+            node.forEach(entry => collect(entry, key, depth + 1));
+        else if (node && typeof node === 'object')
+            Object.entries(node).forEach(([name, entry]) => collect(entry, name, depth + 1));
+    };
+    collect(value, '', 0);
+    return (found.find(entry => /access/i.test(entry.key)) ?? found.find(entry => !/refresh/i.test(entry.key)) ?? found[0])?.token;
+}
+/**
+ * g-09: `asUser` üç şekil alır — ham JWT, `tok_…` referansı ve `test:<ad>`. Üçüncüsünde gateway kök
+ * `.env`'deki `MCP_TEST_USER_<AD>` satırının tarif ettiği giriş ucunu (uygulamanın kendi uç'u)
+ * anonim çağırır, yanıttaki ilk JWT'yi kasaya etiketiyle koyar ve TTL boyunca yeniden kullanır.
+ * Parola ne yanıta, ne günlüğe (`hideRequestBody`), ne hata metnine girer; satırın değeri hiçbir
+ * mesajda gösterilmez. AI `.env`'i düzenlemez: tanımsız kullanıcı, insanın ekleyeceği değişkenin
+ * adıyla reddedilir.
+ */
+export async function resolveIdentity(value, platform, project, environment) {
+    if (value === undefined || !value.startsWith('test:'))
+        return resolveIdentityToken(value);
+    const name = value.slice('test:'.length).trim().toLowerCase();
+    const variable = `MCP_TEST_USER_${name.toUpperCase()}`;
+    const label = `test:${name}@${platform.resolveProject(project)}/${environment ?? platform.config.defaultEnvironment}`;
+    const cached = labeledToken(label);
+    if (cached)
+        return cached;
+    const raw = platform.config.testUsers[name];
+    if (!raw) {
+        const defined = Object.keys(platform.config.testUsers);
+        throw new PlatformApiError(`Test kullanıcısı '${name}' tanımlı değil. Kök .env'e insan ekler: ${variable}={"application":"<uygulama slug>","microservice":"<giriş ucu slug>","body":{…giriş gövdesi…}} (biçim: docs/ortam.md §Test kullanıcıları); gateway yeniden başlatılır. AI .env'i düzenlemez. Tanımlı olanlar: ${defined.length > 0 ? defined.join(', ') : '(yok)'}.`, 400);
+    }
+    let login;
+    try {
+        login = JSON.parse(raw);
+    }
+    catch {
+        throw new PlatformApiError(`${variable} JSON olarak okunamadı (değer gösterilmez). Biçim: {"application":"…","microservice":"…","body":{…}} — docs/ortam.md §Test kullanıcıları.`, 400);
+    }
+    if (typeof login.application !== 'string' || typeof login.microservice !== 'string') {
+        throw new PlatformApiError(`${variable} 'application' ve 'microservice' alanlarını taşımalı (değer gösterilmez) — docs/ortam.md §Test kullanıcıları.`, 400);
+    }
+    const endpoint = `${login.application}/${login.microservice}`;
+    const response = await platform.tenantRaw(typeof login.method === 'string' ? login.method : 'POST', project, `/m/${endpoint}`, {
+        environment,
+        body: login.body,
+        anonymous: true,
+        hideRequestBody: true
+    });
+    const token = accessJwt(response.body);
+    if (!token) {
+        throw new PlatformApiError(`Test kullanıcısı '${name}' girişi jeton döndürmedi: ${endpoint} HTTP ${response.httpStatus}. Kök .env'deki ${variable} satırını (uç ve gövde) ve kullanıcının uygulamada var olduğunu kontrol edin; gövde ve kimlik bilgisi gösterilmez.`, 400);
     }
+    rememberToken(token, label);
     return token;
 }
 /**