@appaflytech/zeyrek-ai-mcp 0.0.4 → 0.0.6

package/dist/platform/refs.js

@@ -0,0 +1,104 @@
+import { PlatformApiError } from './errors.js';
+const guidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function isGuid(value) {
+    return guidPattern.test(value);
+}
+export class RefResolveError extends PlatformApiError {
+}
+/**
+ * Slug → id çözümü çağrı başına yapılır ve çağrılar arasında TAŞINMAZ: gateway stateless, N
+ * replika ile paylaşılan bir önbellek tutarsız olur. Belirsiz slug (aynı ad iki datasource'ta)
+ * sessizce "ilkini al" ile geçilmez — bu planın var oluş nedeni sessiz yanlışı azaltmaktı;
+ * adaylar listelenip `datasource/entity` biçimi istenir.
+ */
+export class RefResolver {
+    platform;
+    project;
+    environment;
+    resolved = [];
+    tree;
+    fieldsByEntity = new Map();
+    constructor(platform, project, environment) {
+        this.platform = platform;
+        this.project = project;
+        this.environment = environment;
+    }
+    async applicationId(ref) {
+        if (isGuid(ref))
+            return ref;
+        const projectPayload = await this.platform.org('GET', `/p/${this.platform.resolveProject(this.project)}`);
+        const applicationsPayload = await this.platform.org('GET', '/applications', { query: { projectId: String(projectPayload.data?.id ?? ''), pageLength: 100 } });
+        const applications = applicationsPayload.data ?? [];
+        const found = applications.find(application => application.slug === ref);
+        if (!found) {
+            throw new RefResolveError(`'${ref}' diye bir application yok. Mevcut slug'lar: ${applications.map(application => application.slug).join(', ') || '(yok)'}`);
+        }
+        this.resolved.push(`applicationId '${ref}' → ${found.id}`);
+        return found.id;
+    }
+    async entity(ref) {
+        const tree = await this.loadTree();
+        const flat = tree
+            .filter((datasource) => Boolean(datasource) && typeof datasource === 'object')
+            .flatMap(datasource => (Array.isArray(datasource.entities) ? datasource.entities : [])
+            .filter((entity) => Boolean(entity) && typeof entity === 'object' && typeof entity.id === 'string')
+            .map(entity => ({ datasource, entity })));
+        if (isGuid(ref)) {
+            const byId = flat.find(({ entity }) => entity.id.toLowerCase() === ref.toLowerCase());
+            if (!byId)
+                throw new RefResolveError(`'${ref}' id'li entity ağaçta yok.`);
+            return { entityId: byId.entity.id, datasourceId: byId.datasource.id, slug: byId.entity.slug };
+        }
+        const separator = ref.indexOf('/');
+        const [datasourcePart, entityPart] = separator === -1 ? [undefined, ref] : [ref.slice(0, separator), ref.slice(separator + 1)];
+        const matches = flat.filter(({ datasource, entity }) => entity.slug === entityPart && (datasourcePart === undefined || datasource.slug === datasourcePart || datasource.name === datasourcePart));
+        if (matches.length === 0) {
+            throw new RefResolveError(`'${ref}' diye bir entity yok. Mevcut slug'lar: ${flat.map(({ entity }) => entity.slug).join(', ') || '(yok)'}`);
+        }
+        if (matches.length > 1) {
+            throw new RefResolveError(`'${ref}' birden çok datasource'ta var: ${matches.map(({ datasource, entity }) => `${datasource.slug}/${entity.slug}`).join(', ')}. 'datasource/entity' biçimiyle verin.`);
+        }
+        const [{ datasource, entity }] = matches;
+        this.resolved.push(`entityId '${ref}' → ${entity.id}`);
+        return { entityId: entity.id, datasourceId: datasource.id, slug: entity.slug };
+    }
+    /**
+     * Entity'nin ham kaydı (alan listesi DIŞINDAKİ kök alanlar için: `localizationEntityId`,
+     * `localizationParentId`, `type`). `entityFields` ile aynı ucu çağırır ve aynı önbelleği
+     * kullanır — iki tur atmaz.
+     */
+    async entityRecord(ref) {
+        const cached = this.recordByEntity.get(ref.entityId);
+        if (cached)
+            return cached;
+        const payload = await this.platform.tenant('GET', this.project, `/entities/${ref.datasourceId}/${ref.entityId}`, { environment: this.environment });
+        const record = payload.data ?? {};
+        this.recordByEntity.set(ref.entityId, record);
+        return record;
+    }
+    async entityFields(ref) {
+        const cached = this.fieldsByEntity.get(ref.entityId);
+        if (cached)
+            return cached;
+        const payload = await this.platform.tenant('GET', this.project, `/entities/${ref.datasourceId}/${ref.entityId}`, { environment: this.environment });
+        const fields = (payload.data?.fields ?? [])
+            .filter(field => typeof field?.id === 'string' && field.id !== '' && typeof field.slug === 'string' && field.slug !== '')
+            .map(field => ({
+            id: String(field.id),
+            slug: String(field.slug),
+            relationType: String(field.relationType ?? 'none'),
+            relationId: field.relationId ?? null,
+            primaryKey: field.primaryKey === true
+        }));
+        this.fieldsByEntity.set(ref.entityId, fields);
+        return fields;
+    }
+    recordByEntity = new Map();
+    async loadTree() {
+        if (this.tree)
+            return this.tree;
+        const payload = await this.platform.tenant('GET', this.project, '/datasources/tree', { environment: this.environment });
+        this.tree = Array.isArray(payload) ? payload : (payload?.data ?? []);
+        return this.tree;
+    }
+}

package/dist/platform/responses.js

@@ -1,5 +1,6 @@
 import { logError, logStep } from '../observability/trace.js';
 import { PlatformApiError } from './errors.js';
+import { maskSecrets } from './secrets.js';
 export function prune(value) {
     if (Array.isArray(value))
         return value.map(prune);
@@ -127,11 +128,15 @@ function asStructured(payload) {
 }
 export function toolResult(payload, config) {
     const pruned = prune(payload);
-    const runtimeErrors = runtimeErrorSummary(pruned);
+    const { payload: safe, masked, tokenRefs } = maskSecrets(pruned);
+    const runtimeErrors = runtimeErrorSummary(safe);
     if (runtimeErrors.length > 0) {
         logStep('akış hatası ✕', `${runtimeErrors.length} adım hata ile bitti — platform HTTP 200 döndürdüğü için çağrı başarılı görünüyordu`, runtimeErrors);
     }
-    const { payload: bounded, truncated } = shrink(pruned, config.maxResponseBytes);
+    if (masked.length > 0) {
+        logStep('maskeleme', `${masked.length} gizli alan yanıttan çıkarıldı — değer *** ile değiştirildi, yolu gatewayMasked'de`, masked);
+    }
+    const { payload: bounded, truncated } = shrink(safe, config.maxResponseBytes);
     const structured = asStructured(bounded);
     if (truncated) {
         logStep('kırpma ✂', `yanıt ${config.maxResponseBytes} bayt sınırını aştı — en uzun liste yarıya indirilerek küçültüldü (MAX_RESPONSE_BYTES)`);
@@ -139,6 +144,8 @@ export function toolResult(payload, config) {
     const enriched = {
         ...structured,
         ...(runtimeErrors.length > 0 ? { runtimeErrors } : {}),
+        ...(masked.length > 0 ? { gatewayMasked: masked } : {}),
+        ...(Object.keys(tokenRefs).length > 0 ? { tokenRefs, tokenRefNote: "Maskelenen JWT'ler gateway içinde tutuldu; bu referansları page_screenshot / page_runtime_get 'asUser' alanına verebilirsiniz (15 dk geçerli). Jetonun kendisi yanıta ve günlüğe hiç girmez." } : {}),
         ...(truncated ? { truncated: true, truncationNote: 'Liste, yanıt boyutu sınırı nedeniyle kırpıldı; sayfalama ya da daha dar filtre kullanın.' } : {})
     };
     return {