@appaflytech/zeyrek-ai-mcp 0.0.1

package/dist/tools/datasources.js

@@ -0,0 +1,82 @@
+import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const connectionInput = {
+    name: z.string().min(1),
+    description: z.string().optional(),
+    dbName: z.string().optional(),
+    type: z.string().describe('DatasourceType (ör. Postgres); datasource_resources tool\'u geçerli tipleri listeler'),
+    host: z.string().optional(),
+    port: z.number().int().optional(),
+    properties: z.record(z.unknown()).optional(),
+    connectionOptions: z.record(z.string()).optional()
+};
+export function registerDatasourceTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('datasource_list', {
+        title: 'Datasource listele',
+        description: 'Projedeki datasource\'ları listeler; tree=true entity ağacıyla birlikte döner.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            tree: z.boolean().optional(),
+            searchTerm: z.string().optional(),
+            type: z.string().optional(),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, tree, ...query }) => platform.tenant('GET', project, tree ? '/datasources/tree' : '/datasources', { environment, query })));
+    server.registerTool('datasource_get', {
+        title: 'Datasource getir',
+        description: 'Tek datasource\'u id ile getirir.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/datasources/${id}`, { environment })));
+    server.registerTool('datasource_create', {
+        title: 'Datasource oluştur',
+        description: 'Projeye yeni datasource ekler; önce datasource_test_connection ile bağlantıyı doğrulamak iyi pratiktir.',
+        inputSchema: { project: projectParam, environment: environmentParam, ...connectionInput },
+        annotations: writes
+    }, handle(config, ({ project, environment, ...body }) => platform.tenant('POST', project, '/datasources', { environment, body })));
+    server.registerTool('datasource_update', {
+        title: 'Datasource güncelle',
+        description: 'Datasource bağlantı bilgilerini günceller.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, ...connectionInput },
+        annotations: updates
+    }, handle(config, ({ project, environment, id, ...body }) => platform.tenant('PUT', project, `/datasources/${id}`, { environment, body })));
+    server.registerTool('datasource_delete', {
+        title: 'Datasource sil',
+        description: 'Datasource\'u siler; altındaki entity tanımları da etkilenir.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/datasources/${id}`, { environment })));
+    server.registerTool('datasource_test_connection', {
+        title: 'Bağlantıyı test et',
+        description: "Kayıtlı datasource için 'id', kaydedilmemiş bağlantı için type/host/port alanlarını verin.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid.optional(),
+            type: z.string().optional(),
+            host: z.string().optional(),
+            port: z.number().int().optional(),
+            properties: z.record(z.unknown()).optional(),
+            connectionOptions: z.record(z.string()).optional()
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id, ...body }) => id
+        ? platform.tenant('POST', project, `/datasources/${id}/test-connection`, { environment })
+        : platform.tenant('POST', project, '/datasources/test-connection', { environment, body })));
+    server.registerTool('datasource_resources', {
+        title: 'Datasource tiplerini listele',
+        description: 'Platformun desteklediği datasource tiplerini ve yapılandırma bilgilerini döner.',
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/datasources/resources', { environment })));
+    server.registerTool('datasource_configuration_options', {
+        title: 'Yapılandırma seçenekleri',
+        description: 'Kayıtlı datasource\'un tipine özel yapılandırma seçeneklerini döner.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/datasources/${id}/configuration-options`, { environment })));
+}

package/dist/tools/dependencies.js

@@ -0,0 +1,17 @@
+import { guid, projectParam, environmentParam, readOnly } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+export function registerDependencyTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('dependency_graph', {
+        title: 'Bağımlılık grafiği',
+        description: "Herhangi bir modül kaydının 'kim buna bağımlı' grafiğini döner. Silmeden önce çağırın — entity_dependencies/workflow_dependencies'in genel hâli (query, view, dto, microservice vb. için).",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            module: z.string().describe('Modül adı: entity | field | microservice | workflow | query | view | dataTransferObject vb. (platform Module enum değeri)'),
+            id: guid
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, module, id }) => platform.tenant('GET', project, `/dependencies/${module}/${id}`, { environment })));
+}

package/dist/tools/deployments.js

@@ -0,0 +1,17 @@
+import { guid, readOnly, writes } from './common.js';
+import { handle } from '../platform/responses.js';
+export function registerDeploymentTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('deployment_start', {
+        title: 'Deployment başlat',
+        description: 'Projeyi kaynak environment\'tan hedef environment\'a deploy eder. Asenkron bir saga\'dır: sonuç bu yanıtta bitmez, deployment_status ile izleyin. Environment id\'lerini project_get çıktısından alın.',
+        inputSchema: { projectId: guid, sourceEnvironmentId: guid, targetEnvironmentId: guid },
+        annotations: writes
+    }, handle(config, ({ projectId, ...body }) => platform.org('POST', `/deployments/${projectId}/deploy`, { body })));
+    server.registerTool('deployment_status', {
+        title: 'Deployment durumu',
+        description: 'Projenin son deployment durumunu döner.',
+        inputSchema: { projectId: guid },
+        annotations: readOnly
+    }, handle(config, ({ projectId }) => platform.org('GET', `/deployments/${projectId}`)));
+}

package/dist/tools/dtos.js

@@ -0,0 +1,54 @@
+import { guid, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+export function registerDtoTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('dto_list', {
+        title: 'DTO listele',
+        description: "DataTransferObject'leri listeler. Workflow/automation'a returnDtoId atamadan önce mevcut DTO'ları buradan arayın — platform entity başına DTO'lar üretir, çoğu zaman yenisini yazmak gerekmez.",
+        inputSchema: { project: projectParam, environment: environmentParam, searchTerm: z.string().optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, ...query }) => platform.tenant('GET', project, '/datatransferobjects', { environment, query })));
+    server.registerTool('dto_get', {
+        title: 'DTO getir',
+        description: 'Tek DTO tanımını alan ağacıyla getirir; dto_create için en iyi gövde şablonudur.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/datatransferobjects/${id}`, { environment })));
+    server.registerTool('dto_scheme', {
+        title: 'DTO şeması',
+        description: "DTO'nun çözülmüş şemasını (alan sözlüğü) döner — workflow input./returnDto alanlarını doğrulamak için kullanın.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/datatransferobjects/${id}/scheme`, { environment })));
+    server.registerTool('dto_create', {
+        title: 'DTO oluştur',
+        description: "Yeni DataTransferObject tanımlar (definition = CreateDataTransferObjectCommand). Workflow'un parameterDtoId/returnDtoId sözleşmeleri buradan çıkar; şablon için dto_get kullanın.",
+        inputSchema: { project: projectParam, environment: environmentParam, definition: definitionParam },
+        annotations: writes
+    }, handle(config, ({ project, environment, definition }) => platform.tenant('POST', project, '/datatransferobjects', { environment, body: definition })));
+    server.registerTool('dto_update', {
+        title: 'DTO güncelle',
+        description: 'DTO tanımını günceller (definition = UpdateDataTransferObjectCommand); mevcut hâli dto_get ile alın.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, definition: definitionParam },
+        annotations: updates
+    }, handle(config, ({ project, environment, id, definition }) => platform.tenant('PUT', project, `/datatransferobjects/${id}`, { environment, body: definition })));
+    server.registerTool('dto_clone', {
+        title: 'DTO klonla',
+        description: "DTO'nun kopyasını oluşturur.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: writes
+    }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/datatransferobjects/${id}/clone`, { environment })));
+    server.registerTool('dto_sync_primitives', {
+        title: 'İlkel DTO tiplerini senkronla',
+        description: "Platformun ilkel (primitive) DTO tanımlarını projeye yeniden yazar; DTO listesinde temel tipler eksikse çalıştırılır. Bakım işidir.",
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: updates
+    }, handle(config, ({ project, environment }) => platform.tenant('POST', project, '/datatransferobjects/sync-primitives', { environment })));
+    server.registerTool('dto_delete', {
+        title: 'DTO sil',
+        description: "DTO'yu siler; workflow/query'lerde referans varsa platform reddeder.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/datatransferobjects/${id}`, { environment })));
+}

package/dist/tools/entities.js

@@ -0,0 +1,166 @@
+import { guid, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
+import { splitJunctionFields, withNormalization } from '../knowledge/normalize.js';
+import { entityOutline, resolvePart } from '../knowledge/outlines.js';
+import { isJunctionField, policyRules } from '../knowledge/rules.js';
+import { handle } from '../platform/responses.js';
+import fastJsonPatch from 'fast-json-patch';
+import { z } from 'zod';
+const policyOverrideParam = z.boolean().optional()
+    .describe('true: politika block bulgularını warn\'a indirir (bilinçli istisna; yanıtta işaretlenir)');
+const patchOperationsParam = z.array(z.record(z.unknown())).min(1)
+    .describe("RFC 6902 JSON Patch işlemleri; path'leri view:'outline'/'part' ile keşfedin");
+function preserveApplicationBinding(definition) {
+    if (Array.isArray(definition.applicationIds))
+        return;
+    const applications = Array.isArray(definition.applications) ? definition.applications : [];
+    const applicationIds = applications
+        .map(entry => (entry && typeof entry === 'object' ? entry.applicationId : undefined))
+        .filter((applicationId) => typeof applicationId === 'string');
+    if (applicationIds.length > 0)
+        definition.applicationIds = applicationIds;
+}
+export function registerEntityTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('entity_list', {
+        title: 'Entity listele',
+        description: "Datasource altındaki entity'leri listeler. DİKKAT: applicationId verirseniz platformun HAZIR entity'leri (users, roles, user_roles, permissions, role_permissions, audit_trails) listede GÖRÜNMEZ — seed onlara application bağı açmaz. Kimlik tablosunu görmek için applicationId vermeden çağırın; ayrıntı platform_guide('entity') §'Hazır entity'ler'. (files/folders her hâlükârda gizlidir.)",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            datasourceId: guid,
+            searchTerm: z.string().optional(),
+            hasPrimaryKey: z.boolean().optional(),
+            applicationId: guid.optional().describe("Verilirse yalnız bu application'a bağlı entity'ler döner; platformun hazır entity'leri (users/roles/…) bağsız olduğu için elenir"),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, datasourceId, ...query }) => platform.tenant('GET', project, `/entities/${datasourceId}`, { environment, query })));
+    server.registerTool('entity_get', {
+        title: 'Entity getir',
+        description: "Entity'yi alan tanımlarıyla getirir. Çok alanlı entity'de önce view:'outline' (alan listesi), sonra view:'part' ile tek alan çekin.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            datasourceId: guid,
+            id: guid,
+            view: z.enum(['full', 'outline', 'part']).optional().describe('varsayılan full'),
+            part: z.string().optional().describe("view:'part' için yol, ör. fields[slug=email] veya indexes[0]")
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, datasourceId, id, view, part }) => {
+        const payload = await platform.tenant('GET', project, `/entities/${datasourceId}/${id}`, { environment });
+        const definition = (payload?.data ?? payload);
+        if (view === 'outline')
+            return entityOutline(definition);
+        if (view === 'part') {
+            if (!part)
+                throw new Error("view:'part' için 'part' parametresi zorunlu.");
+            return { part, value: resolvePart(definition, part) };
+        }
+        return payload;
+    }));
+    server.registerTool('entity_create', {
+        title: 'Entity oluştur',
+        description: "Datasource altında yeni entity oluşturur (definition = CreateEntityCommand: name, fields[], applicationIds, ...). İlişkiler ve alan tipi kararı için platform_guide('entity') okuyun. Gövde politika kontrolünden geçer. applicationIds create'te platformca bağlanır (CreateEntityCommandHandler entityApplications'ı Entity ctor'una geçirir); satır uçları bu bağa İHTİYAÇ DUYMAZ — bağ yalnız Studio'nun application'a göre entity listesini ve bağımlılık sorgularını etkiler.",
+        inputSchema: { project: projectParam, environment: environmentParam, datasourceId: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, datasourceId, definition, policyOverride }) => {
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'entity', definition, { operation: 'create' }, policyOverride));
+        const { base, deferred } = splitJunctionFields(definition, isJunctionField);
+        const payload = await platform.tenant('POST', project, `/entities/${datasourceId}`, { environment, body: base });
+        if (deferred.length === 0)
+            return attachFindings(payload, findings);
+        const created = (payload?.data ?? payload);
+        const createdId = String(created?.id ?? '');
+        if (!createdId) {
+            throw new Error(`Entity kuruldu ama id okunamadı; m2m alanları (${deferred.map(field => field.slug ?? field.name).join(', ')}) eklenmedi — entity_get ile kaydı bulup entity_patch ile ekleyin.`);
+        }
+        const current = await platform.tenant('GET', project, `/entities/${datasourceId}/${createdId}`, { environment });
+        const full = structuredClone((current?.data ?? current));
+        full.fields = [...(Array.isArray(full.fields) ? full.fields : []), ...deferred];
+        preserveApplicationBinding(full);
+        const updated = await platform.tenant('PUT', project, `/entities/${createdId}`, { environment, body: full });
+        const note = `m2m/çoklu alanlar (${deferred.map(field => field.slug ?? field.name).join(', ')}) ayrı bir güncelleme turunda eklendi: create yolu junction kaydını açar ama fiziksel tabloyu kurmaz (platform bug'ı P-01), update yolu kurar.`;
+        return attachFindings(withNormalization(updated, [note]), findings);
+    }));
+    server.registerTool('entity_create_discovered', {
+        title: 'Keşfedilen entity\'leri içe al',
+        description: 'entity_discover çıktısından seçilen tabloları toplu entity olarak içe alır. definition = CreateDiscoveredEntitiesCommand gövdesi.',
+        inputSchema: { project: projectParam, environment: environmentParam, datasourceId: guid, definition: definitionParam },
+        annotations: writes
+    }, handle(config, ({ project, environment, datasourceId, definition }) => platform.tenant('POST', project, `/entities/${datasourceId}/discovered`, { environment, body: definition })));
+    server.registerTool('entity_update', {
+        title: 'Entity güncelle',
+        description: 'Entity tanımını günceller (tam gövde). Hedefli değişiklik için entity_patch tercih edin. Gövde politika kontrolünden geçer.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, definition, policyOverride }) => {
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'entity', definition, { operation: 'update' }, policyOverride));
+        const payload = await platform.tenant('PUT', project, `/entities/${id}`, { environment, body: definition });
+        return attachFindings(payload, findings);
+    }));
+    server.registerTool('entity_patch', {
+        title: 'Entity\'ye patch uygula',
+        description: "Tam gövdeyi bağlama almadan hedefli değişiklik: gateway mevcut tanımı çeker, JSON Patch uygular, politika kontrolünden geçirir, geri yazar. Yanıt outline özetidir. GET 'applications' döner ama UpdateEntityCommand 'applicationIds' okur; gateway bu çeviriyi kendisi yapar, yoksa her patch application bağını sessizce siler.",
+        inputSchema: { project: projectParam, environment: environmentParam, datasourceId: guid, id: guid, operations: patchOperationsParam, policyOverride: policyOverrideParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, datasourceId, id, operations, policyOverride }) => {
+        const current = await platform.tenant('GET', project, `/entities/${datasourceId}/${id}`, { environment });
+        const definition = structuredClone((current?.data ?? current));
+        const patched = fastJsonPatch.applyPatch(definition, operations, true, false).newDocument;
+        preserveApplicationBinding(patched);
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'entity', patched, { operation: 'update' }, policyOverride));
+        await platform.tenant('PUT', project, `/entities/${id}`, { environment, body: patched });
+        return attachFindings({ applied: operations.length, outline: entityOutline(patched) }, findings);
+    }));
+    server.registerTool('entity_delete', {
+        title: 'Entity sil',
+        description: 'Entity tanımını siler; önce entity_dependencies ile bağımlılıklarını kontrol edin.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/entities/${id}`, { environment })));
+    server.registerTool('entity_clone', {
+        title: 'Entity klonla',
+        description: 'Entity\'nin kopyasını oluşturur.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: writes
+    }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/entities/${id}/clone`, { environment })));
+    server.registerTool('entity_discover', {
+        title: 'Dış şemadan entity keşfet',
+        description: 'Datasource\'un bağlı olduğu veritabanındaki tabloları entity adayı olarak listeler.',
+        inputSchema: { project: projectParam, environment: environmentParam, datasourceId: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, datasourceId }) => platform.tenant('GET', project, `/entities/${datasourceId}/discover`, { environment })));
+    server.registerTool('entity_relation_tree', {
+        title: 'İlişki ağacı',
+        description: 'Entity\'nin ilişki ağacını döner; mode: simple | full.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            mode: z.enum(['simple', 'full']).optional(),
+            parentEntityId: guid.optional()
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id, ...query }) => platform.tenant('GET', project, `/entities/${id}/tree`, { environment, query })));
+    server.registerTool('entity_dependencies', {
+        title: 'Entity bağımlılıkları',
+        description: 'Entity\'ye bağımlı microservice/workflow/page kayıtlarının grafiğini döner.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/entities/${id}/dependencies`, { environment })));
+    server.registerTool('entity_audit_trails', {
+        title: 'Audit kayıtları',
+        description: 'Entity\'nin satır bazlı audit trail kayıtlarını listeler (audit trail açık olmalı).',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            entityId: guid,
+            rowId: z.string().optional(),
+            userId: z.string().optional(),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, entityId, ...query }) => platform.tenant('GET', project, `/entities/${entityId}/audit-trails`, { environment, query })));
+}

package/dist/tools/files.js

@@ -0,0 +1,138 @@
+import { guid, projectParam, environmentParam, pagingParams, readOnly, updates, destructive, writes } from './common.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { handle } from '../platform/responses.js';
+import { readFile, writeFile } from 'node:fs/promises';
+import { basename, extname, resolve } from 'node:path';
+import { z } from 'zod';
+const maxInlineBytes = 8 * 1024 * 1024;
+const maxUploadBytes = 50 * 1024 * 1024;
+const forbiddenNameChars = `\\|!#~$%&/=?»«@£§€{};'<>,`;
+const mimeTypes = {
+    '.css': 'text/css',
+    '.csv': 'text/csv',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.gif': 'image/gif',
+    '.htm': 'text/html',
+    '.html': 'text/html',
+    '.ico': 'image/x-icon',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.js': 'text/javascript',
+    '.json': 'application/json',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.svg': 'image/svg+xml',
+    '.txt': 'text/plain',
+    '.webp': 'image/webp',
+    '.woff2': 'font/woff2',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.xml': 'application/xml',
+    '.zip': 'application/zip'
+};
+export function registerFileTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('file_list', {
+        title: 'Dosyaları listele',
+        description: 'Projedeki dosya kayıtlarını listeler (metadata; içerik değil). İçerik aktarımı için file_upload / file_download kullanın.',
+        inputSchema: { project: projectParam, environment: environmentParam, searchTerm: z.string().optional(), folderId: guid.optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, ...query }) => platform.tenant('GET', project, '/files', { environment, query })));
+    server.registerTool('file_get', {
+        title: 'Dosya bilgisi getir',
+        description: 'Tek dosyanın metadata kaydını getirir (ad, boyut, yol; içerik değil). İçerik için file_download.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/files/${id}`, { environment })));
+    server.registerTool('file_upload', {
+        title: 'Dosya yükle',
+        description: "Dosyayı projenin depolamasına yükler ve FileDto (id + serve adresleri) döner. İçerik iki yoldan verilir: `path` — gateway sürecinin okuyabildiği yerel yol (büyük dosyalar için tercih edilir, içerik model bağlamına girmez), ya da `content` — base64 (8 MB'a kadar) + `filename`. Platform sınırı 50 MB; dosya adı \\|!#~$%&/=?»«@£§€{};'<>, karakterlerini içeremez. Yüklenen dosya sayfada `image`/`file-viewer` komponentiyle gösterilir ya da satır alanına yol olarak yazılır.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            path: z.string().min(1).optional().describe("Gateway sürecinin okuyabildiği yerel dosya yolu; `content` ile birlikte verilmez"),
+            content: z.string().min(1).optional().describe('Base64 kodlanmış dosya içeriği; `filename` ile birlikte zorunludur'),
+            filename: z.string().min(1).optional().describe("`content` ile zorunlu; `path` verildiğinde dosya adını ezer"),
+            contentType: z.string().min(1).optional().describe('Belirtilmezse uzantıdan çözülür, bilinmeyen uzantıda application/octet-stream'),
+            folderId: guid.optional().describe('Hedef klasör (folder_list); boşsa kök')
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, path, content, filename, contentType, folderId }) => {
+        if (!path === !content) {
+            throw new PlatformApiError("file_upload: `path` ya da `content` parametrelerinden tam olarak biri verilmeli — `path` gateway'in okuyabildiği yerel dosya, `content` base64 içerik (`filename` ile).");
+        }
+        let bytes;
+        let name;
+        if (path) {
+            const absolute = resolve(path);
+            try {
+                bytes = await readFile(absolute);
+            }
+            catch (error) {
+                throw new PlatformApiError(`file_upload: dosya okunamadı — ${absolute} (${error instanceof Error ? error.message : String(error)}). Yol gateway sürecinin çalıştığı makineye göre çözülür.`);
+            }
+            name = filename ?? basename(absolute);
+        }
+        else {
+            if (!filename)
+                throw new PlatformApiError('file_upload: `content` verildiğinde `filename` zorunludur.');
+            bytes = Buffer.from(content, 'base64');
+            if (bytes.byteLength === 0)
+                throw new PlatformApiError('file_upload: `content` geçerli base64 değil ya da boş.');
+            if (bytes.byteLength > maxInlineBytes) {
+                throw new PlatformApiError(`file_upload: base64 içerik ${maxInlineBytes} bayt sınırını aşıyor (${bytes.byteLength} B). Büyük dosyalar için \`path\` kullanın.`);
+            }
+            name = filename;
+        }
+        if (bytes.byteLength > maxUploadBytes) {
+            throw new PlatformApiError(`file_upload: dosya ${maxUploadBytes} bayt platform sınırını aşıyor (${bytes.byteLength} B).`);
+        }
+        const offendingChar = [...forbiddenNameChars].find(character => name.includes(character));
+        if (offendingChar) {
+            throw new PlatformApiError(`file_upload: dosya adı '${offendingChar}' karakterini içeriyor; platform doğrulaması bunu reddeder. Yasak karakterler: ${forbiddenNameChars}`);
+        }
+        const resolvedType = contentType ?? mimeTypes[extname(name).toLowerCase()] ?? 'application/octet-stream';
+        const multipart = folderId
+            ? [{ name: 'FolderId', value: folderId }, { name: 'File', filename: name, contentType: resolvedType, content: bytes }]
+            : [{ name: 'File', filename: name, contentType: resolvedType, content: bytes }];
+        return platform.tenant('POST', project, '/files/upload', { environment, multipart });
+    }));
+    server.registerTool('file_download', {
+        title: 'Dosya indir',
+        description: "Dosyanın içeriğini indirir ve `outPath` ile verilen yerel yola yazar; dönen gövde yalnız özet (yol, boyut, tip) — ikili içerik model bağlamına girmez. Yol gateway sürecinin çalıştığı makineye göre çözülür.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            outPath: z.string().min(1).describe('İçeriğin yazılacağı yerel dosya yolu')
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, id, outPath }) => {
+        const payload = await platform.tenant('GET', project, `/files/${id}/download`, { environment, expectBinary: true });
+        const absolute = resolve(outPath);
+        try {
+            await writeFile(absolute, payload.bytes);
+        }
+        catch (error) {
+            throw new PlatformApiError(`file_download: dosya yazılamadı — ${absolute} (${error instanceof Error ? error.message : String(error)}).`);
+        }
+        return { path: absolute, sizeBytes: payload.bytes.byteLength, contentType: payload.contentType };
+    }));
+    server.registerTool('file_rename', {
+        title: 'Dosyayı yeniden adlandır',
+        description: 'Dosya kaydının adını değiştirir (içerik aktarımı gerekmez).',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, name: z.string().min(1) },
+        annotations: updates
+    }, handle(config, ({ project, environment, id, name }) => platform.tenant('PATCH', project, `/files/${id}/rename`, { environment, body: { name } })));
+    server.registerTool('file_delete', {
+        title: 'Dosya sil',
+        description: 'Dosya kaydını siler.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/files/${id}`, { environment })));
+}