@stechquick/studio-cli 4.0.3-2

package/dist/studio-cli/src/server/bridgeServer.js

@@ -0,0 +1,817 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeServer = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const wsRaw_1 = require("./wsRaw");
+const peer_1 = require("./peer");
+const serverInfo_1 = require("./serverInfo");
+const logger_1 = require("../util/logger");
+const pull_1 = require("../control/pull");
+const push_1 = require("../control/push");
+const state_1 = require("../util/state");
+const frontmatter_1 = require("../util/frontmatter");
+const modelRef_1 = require("../util/modelRef");
+const version_1 = require("../version");
+const protocolVersion_1 = require("../../../common/studioCli/protocolVersion");
+const PING_INTERVAL_MS = 20000;
+const PORT_RANGE_END = 7350;
+/**
+ * Lokal WebSocket server (santral). Tek bridge client (browser) + ileride kısa-ömürlü
+ * control client'lar. Port-range keşfi + `.studio/server.json` claim + tipli dispatch.
+ */
+class BridgeServer {
+    wss;
+    bridgeClient;
+    // AI test tarayıcısı (?cliRole=test) — SINK: event göndermez, yalnız syncModels alır.
+    testClient;
+    // Bu oturumda push'lanan gövdeler (id → item, push'lar arası merge). Test client sonradan
+    // bağlanınca / F5'te replay edilir — sync, bağlanma sırasından bağımsız çalışır.
+    lastSync = new Map();
+    // GET /render hedefi — primary hello'dan gelir, YALNIZ BELLEKTE tutulur (server.json'a yazılmaz:
+    // workspace dosyaları agent'a/git'e açıktır, oturum bilgisi diske inmez).
+    renderTarget;
+    claimedAppId;
+    pingTimer;
+    _pushInProgress = false;
+    // Push'un checkout ettiği (yeni yaratılan) model id'leri. studio.checkout → checkoutChangedHook
+    // echo'su reply'dan SONRA da gelebildiği için (_pushInProgress yetmez); bu id'lerin checkoutChanged'i
+    // id bazında, consume-once bastırılır → zamanlamadan bağımsız, manuel checkout'lar etkilenmez.
+    _expectedCheckoutEchoes = new Set();
+    _deferredModelCreated = [];
+    _deferredModelChanged = [];
+    host;
+    startPort;
+    port = 0; // gerçekte bağlanan port (start() doldurur)
+    rootDir;
+    constructor(options) {
+        this.host = options.host ?? "127.0.0.1";
+        this.startPort = options.port;
+        this.rootDir = options.rootDir;
+    }
+    async start() {
+        // Önceki (çökmüş) server'dan kalma claim'i temizle — bu fresh bir server.
+        //TODO: bunu burada yapmanin yan etkilerini dusun. 
+        (0, serverInfo_1.removeServerInfoSync)(this.rootDir);
+        await this.bind();
+        logger_1.logger.info(`bridge listening on ws://${this.host}:${this.port}`);
+        logger_1.logger.info("waiting for Studio web to connect…");
+    }
+    close() {
+        this.stopPing();
+        this.bridgeClient?.close(1001, "cli shutting down");
+        this.testClient?.close(1001, "cli shutting down");
+        this.wss?.close();
+        (0, serverInfo_1.removeServerInfoSync)(this.rootDir);
+    }
+    /** İlk boş portu bind et (startPort … PORT_RANGE_END). Hepsi doluysa hata. */
+    async bind() {
+        const end = Math.max(this.startPort, PORT_RANGE_END);
+        for (let p = this.startPort; p <= end; p++) {
+            const wss = new wsRaw_1.RawWebSocketServer({ host: this.host, port: p });
+            wss.onConnection((conn) => this.onConnection(conn));
+            wss.onRequest((req, res) => this.routeRequest(req, res));
+            try {
+                await wss.listen();
+                this.wss = wss;
+                this.port = p;
+                return;
+            }
+            catch (err) {
+                wss.close();
+                if (err.code === "EADDRINUSE") {
+                    logger_1.logger.debug(`port ${p} in use — trying next`);
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw new Error(`no free port in ${this.startPort}-${end}`);
+    }
+    // --- bağlantı yaşam döngüsü ---
+    onConnection(conn) {
+        const peer = new peer_1.Peer(conn);
+        peer.onEnvelope((env) => this.dispatch(peer, env));
+        peer.onClose(() => this.onPeerClose(peer));
+        logger_1.logger.debug("peer connected");
+    }
+    onPeerClose(peer) {
+        if (peer === this.bridgeClient) {
+            // F5/sayfa kapanması: client gider ama claim + server.json KALIR (reconnect için).
+            this.bridgeClient = undefined;
+            logger_1.logger.info("bridge client disconnected (claim kept for reconnect)");
+        }
+        else if (peer === this.testClient) {
+            this.testClient = undefined;
+            logger_1.logger.info("test client disconnected");
+        }
+        if (!this.bridgeClient && !this.testClient)
+            this.stopPing();
+    }
+    // --- dispatch ---
+    dispatch(peer, env) {
+        switch (env.type) {
+            case "whoAreYou":
+                /** Probe — yan etki YOK; mevcut durumu + protokol/sürümü bildirir (claim etmez).
+                 * Uyumluluk kontrolü UI'da bu cevaba göre yapılır (bkz. docs/PROTOCOL-VERSION-CHECK.md). */
+                peer.reply(env, "whoAreYouResult", { hasClient: this.bridgeClient?.isOpen ?? false, hasTestClient: this.testClient?.isOpen ?? false, appId: this.claimedAppId ?? null, protocol: protocolVersion_1.GENERATION, cliVersion: version_1.VERSION });
+                return;
+            case "hello":
+                this.onHello(peer, env);
+                return;
+            case "ping":
+                peer.reply(env, "pong", {});
+                return;
+            case "pong":
+                return;
+            case "bye":
+                // Yalnız PRIMARY'nin bye'ı server'ı kapatır; test client'ın gidişi slotu boşaltır.
+                if (peer === this.testClient) {
+                    logger_1.logger.info(`test client said bye (${env.payload.reason})`);
+                    this.testClient = undefined;
+                    peer.close(1000, "test client left");
+                    if (!this.bridgeClient)
+                        this.stopPing();
+                    return;
+                }
+                if (peer !== this.bridgeClient) {
+                    peer.close(1000, "bye");
+                    return;
+                }
+                logger_1.logger.info(`client said bye (${env.payload.reason}) — shutting down`);
+                this.close();
+                process.exit(0);
+            case "modelChanged":
+                if (!this.isPrimary(peer))
+                    return;
+                void this.handleModelChanged(env.payload);
+                return;
+            case "modelCreated":
+                if (!this.isPrimary(peer))
+                    return;
+                void this.handleModelCreated(env.payload);
+                return;
+            case "checkoutChanged":
+                if (!this.isPrimary(peer))
+                    return;
+                void this.handleCheckoutChanged(env.payload);
+                return;
+            case "modelDeleted":
+                if (!this.isPrimary(peer))
+                    return;
+                void this.handleModelDeleted(env.payload);
+                return;
+            default:
+                logger_1.logger.warn(`unhandled message type: ${env.type}`);
+        }
+    }
+    /** Dosya yazan event'ler yalnız primary'den kabul edilir (test SINK'tir; web tarafı zaten
+     *  göndermez — bu ikinci emniyet). */
+    isPrimary(peer) {
+        if (peer === this.bridgeClient)
+            return true;
+        logger_1.logger.debug("ignoring file-writing event from non-primary peer");
+        return false;
+    }
+    onHello(peer, env) {
+        const p = env.payload;
+        // Protokol uyumluluğu UI tarafında whoAreYou probe'unda çözülür; hello'ya gelindiyse taraflar
+        // zaten uyumludur (bkz. docs/PROTOCOL-VERSION-CHECK.md). Burada protokol kontrolü YOK.
+        if (p.role === "test") {
+            this.onHelloTest(peer, env);
+            return;
+        }
+        // Zaten canlı bir bridge client varsa (başka tab) → meşgul.
+        if (this.bridgeClient?.isOpen && this.bridgeClient !== peer) {
+            peer.reply(env, "helloAck", { cliVersion: version_1.VERSION }, { message: "bridge already in use", title: "Bridge busy" });
+            logger_1.logger.warn(`hello rejected — bridge already in use (app ${this.claimedAppId})`);
+            peer.close(1013, "bridge already in use");
+            return;
+        }
+        // Claim'li ve farklı app → bu server başka workspace'e ait.
+        if (this.claimedAppId !== undefined && this.claimedAppId !== p.appId) {
+            peer.reply(env, "helloAck", { cliVersion: version_1.VERSION }, { message: `server claimed by another app (${this.claimedAppId})`, title: "Wrong workspace" });
+            logger_1.logger.warn(`hello rejected — claimed by ${this.claimedAppId}, got ${p.appId}`);
+            peer.close(1008, "wrong workspace");
+            return;
+        }
+        const fresh = this.claimedAppId === undefined;
+        this.claimedAppId = p.appId;
+        this.bridgeClient = peer;
+        // Her primary hello'da tazele (reconnect'te origin/org değişmiş olabilir).
+        this.renderTarget = (p.organizationId && p.origin) ? { organizationId: p.organizationId, origin: p.origin } : undefined;
+        // Teşhis: /render'ın çalışıp çalışmayacağı bağlantı anında görünsün (eski UI build'i org/origin göndermez).
+        if (this.renderTarget)
+            logger_1.logger.info(`render check ready — ${this.renderTarget.origin}/studio/${this.renderTarget.organizationId}/${p.appId}`);
+        else
+            logger_1.logger.warn("render check unavailable — Studio did not send organizationId/origin (old UI build?)");
+        if (fresh) {
+            void this.claim(p.appId);
+            logger_1.logger.info(`hello — claimed app "${p.appName}" (${p.appId})`);
+        }
+        else {
+            logger_1.logger.info(`hello — reconnect to app "${p.appName}" (${p.appId})`);
+        }
+        peer.reply(env, "helloAck", { cliVersion: version_1.VERSION });
+        this.startPing();
+    }
+    /** Test rolü hello'su. Test client claim ETMEZ, server.json'a dokunmaz; yalnız mevcut claim'e
+     *  eklemlenir. Canlı primary ŞART DEĞİL — claim primary F5'inde de kalır (onPeerClose) ve
+     *  primary'siz test client zararsızdır (control komutları zaten 409 döner). */
+    onHelloTest(peer, env) {
+        const p = env.payload;
+        if (this.claimedAppId === undefined) {
+            peer.reply(env, "helloAck", { cliVersion: version_1.VERSION }, { message: "no primary claim yet — connect the main Studio tab first", title: "No primary" });
+            logger_1.logger.warn("test hello rejected — no primary claim yet");
+            peer.close(1013, "no primary claim");
+            return;
+        }
+        if (this.claimedAppId !== p.appId) {
+            peer.reply(env, "helloAck", { cliVersion: version_1.VERSION }, { message: `server claimed by another app (${this.claimedAppId})`, title: "Wrong workspace" });
+            logger_1.logger.warn(`test hello rejected — claimed by ${this.claimedAppId}, got ${p.appId}`);
+            peer.close(1008, "wrong workspace");
+            return;
+        }
+        if (this.testClient?.isOpen && this.testClient !== peer) {
+            peer.reply(env, "helloAck", { cliVersion: version_1.VERSION }, { message: "test slot already in use", title: "Test slot busy" });
+            logger_1.logger.warn("test hello rejected — test slot already in use");
+            peer.close(1013, "test slot busy");
+            return;
+        }
+        this.testClient = peer;
+        logger_1.logger.info(`hello — test client joined app "${p.appName}" (${p.appId})`);
+        peer.reply(env, "helloAck", { cliVersion: version_1.VERSION });
+        this.startPing();
+        // Test client push'lardan SONRA bağlanmış/F5 atmış olabilir → oturumun birikmiş gövdelerini gönder.
+        if (this.lastSync.size > 0)
+            void this.sendSyncModels("replay");
+    }
+    async claim(appId) {
+        try {
+            await (0, serverInfo_1.writeServerInfo)(this.rootDir, {
+                port: this.port,
+                pid: process.pid,
+                startedAt: new Date().toISOString(),
+                appId,
+            });
+        }
+        catch (err) {
+            logger_1.logger.error(`failed to write server.json: ${err.message}`);
+        }
+    }
+    // --- control kanalı (HTTP /control/<cmd>) — santral relay ---
+    // wsRaw'dan gelen WS-olmayan HTTP. Control isteğini sahiplen (true); gerisi false → 426.
+    routeRequest(req, res) {
+        // CORS preflight — browser'ın OPTIONS isteğini karşıla.
+        if (req.method === "OPTIONS") {
+            res.writeHead(204, this.corsHeaders());
+            res.end();
+            return true;
+        }
+        if (req.method === "POST" && req.url && req.url.startsWith("/control/")) {
+            const cmd = req.url.slice("/control/".length);
+            void this.handleControl(cmd, req, res);
+            return true;
+        }
+        // Render-check: agent Playwright ile bu sabit lokal URL'i açar; CLI primary tab'dan TAZE token
+        // isteyip Studio editör URL'ine 302 redirect eder. Agent token'ı hiç görmez/işlemez.
+        if (req.method === "GET" && req.url && req.url.split("?")[0] === "/render") {
+            void this.handleRenderRedirect(res);
+            return true;
+        }
+        return false;
+    }
+    /** `<origin>/studio/<org>/<app>?cliRole=test#token=<taze token>` adresine 302 redirect.
+     *  Token her istekte primary'den TALEPLE alınır (hello-anı token'ı ~1 saatte bayatlar; api.getToken()
+     *  MSAL'dan sessizce yeniler) ve YALNIZ fragment'te taşınır (query değil → access log/Referer'a
+     *  sızmaz; sunucuya hiç gitmez). Diske asla yazılmaz. Yanıtta CORS header'ı BİLEREK YOK — yabancı
+     *  bir sayfa fetch ile redirect zincirini okuyamasın; endpoint yalnız doğrudan navigasyon içindir.
+     *  `?cliRole=test` sayesinde tab açılır açılmaz test client olarak auto-connect olur. */
+    async handleRenderRedirect(res) {
+        if (!this.bridgeClient?.isOpen || this.claimedAppId === undefined) {
+            this.respondNoCors(res, 503, { error: "no authenticated Studio session — open Studio and connect the CLI first" });
+            return;
+        }
+        if (!this.renderTarget) {
+            this.respondNoCors(res, 503, { error: "missing organization/origin info — reconnect the Studio tab" });
+            return;
+        }
+        let token;
+        try {
+            token = (await this.bridgeClient.request("getToken", {})).token;
+        }
+        catch (err) {
+            this.respondNoCors(res, 502, { error: `could not obtain session token: ${err.message}` });
+            return;
+        }
+        if (!token) {
+            this.respondNoCors(res, 503, { error: "Studio session has no token — is the user logged in?" });
+            return;
+        }
+        const { origin, organizationId } = this.renderTarget;
+        const path = `/studio/${encodeURIComponent(organizationId)}/${encodeURIComponent(this.claimedAppId)}`;
+        const target = `${origin}${path}?cliRole=test#token=${encodeURIComponent(token)}`;
+        res.writeHead(302, { Location: target });
+        res.end();
+    }
+    respondNoCors(res, status, body) {
+        res.writeHead(status, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(body));
+    }
+    corsHeaders() {
+        return {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "POST, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type",
+        };
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = "";
+            req.on("data", (chunk) => { data += chunk.toString(); });
+            req.on("end", () => resolve(data));
+            req.on("error", reject);
+        });
+    }
+    // Control komutunu erit: gereken mesajı bridgeClient'a relay et, cevabı HTTP'ye dön.
+    async handleControl(cmd, req, res) {
+        if (!this.bridgeClient?.isOpen) {
+            this.respond(res, 409, { error: "studio not connected" });
+            return;
+        }
+        try {
+            switch (cmd) {
+                case "pull": {
+                    // browser pullResult (snapshot) ile reply eder → dosyaları SERVER yazar (+ state).
+                    // Yanıt: NDJSON stream — her model sonrası {"progress":x,"total":y}, sonda {"message":...}
+                    const snapshot = await this.bridgeClient.request("pull", {});
+                    const modelTotal = snapshot.models.length;
+                    res.writeHead(200, { "Content-Type": "application/x-ndjson", ...this.corsHeaders() });
+                    try {
+                        const { total, readOnly } = await (0, pull_1.pull)(this.rootDir, snapshot, (written) => {
+                            res.write(JSON.stringify({ progress: written, total: modelTotal }) + "\n");
+                        });
+                        res.end(JSON.stringify({ message: `pulled ${total} model(s)${readOnly > 0 ? ` (${readOnly} read-only)` : ""}` }) + "\n");
+                    }
+                    catch (err) {
+                        res.end(JSON.stringify({ error: err.message }) + "\n");
+                    }
+                    return;
+                }
+                case "push": {
+                    // rootDir'i tara → mevcut (models) + yeni (newModels) dosyaları topla → bulk relay → state güncelle.
+                    const state = (0, state_1.readState)(this.rootDir);
+                    const { models, newModels, skipped, deletedIds } = await (0, push_1.push)(this.rootDir, state);
+                    // NDJSON stream aç — client progress bar çizer (controlClient.ts readNdjsonStream).
+                    res.writeHead(200, { "Content-Type": "application/x-ndjson", ...this.corsHeaders() });
+                    // Her skipped dosya için bireysel satır yaz.
+                    for (const s of skipped) {
+                        const hint = s.reason === "readonly" ? "read-only (use startWorking to check out)" : "unsupported type";
+                        res.write(JSON.stringify({ skipped: `${s.localKey} — ${hint}` }) + "\n");
+                    }
+                    if (models.length === 0 && newModels.length === 0 && deletedIds.length === 0) {
+                        res.end(JSON.stringify({ message: `nothing to push` }) + "\n");
+                        return;
+                    }
+                    const total = models.length + newModels.length + deletedIds.length;
+                    // Push sırasında gelen modelChanged/modelCreated eventleri push'un kendi updateModel
+                    // çağrılarından kaynaklanır (echo). Deferred queue'ya al; push bitince işle.
+                    this._pushInProgress = true;
+                    this._expectedCheckoutEchoes.clear(); // önceki push'tan kalan (echo'su gelmemiş) id'leri temizle
+                    try {
+                        res.write(JSON.stringify({ progress: 0, total }) + "\n");
+                        const result = await this.bridgeClient.request("push", { models, newModels, deletedIds }, 60000);
+                        // Yeni yaratılan modeller push tarafından checkout edilir → checkoutChanged echo'su beklenir.
+                        // (Mevcut modeller rename/move/body'de checkout etmez.) Echo geç gelse de id ile bastırılır.
+                        for (const r of result.newModelResults ?? [])
+                            if (r.ok && r.id)
+                                this._expectedCheckoutEchoes.add(r.id);
+                        // Progress: her uygulanan öğe için tek satır (mevcut + yeni + silinen).
+                        let done = 0;
+                        const tick = () => res.write(JSON.stringify({ progress: ++done, total }) + "\n");
+                        const counts = { okBody: 0, okRenamed: 0, okMoved: 0, okBoth: 0, okDeleted: 0, okRefFiles: 0 };
+                        this.applyExistingResults(result.results ?? [], models, state, counts, tick);
+                        await this.applyNewModelResults(result.newModelResults ?? [], newModels, state, counts, tick);
+                        this.applyDeletedResults(result.deletedResults ?? [], state, counts, tick);
+                        counts.okRefFiles = await this.syncReferences(result.results ?? [], result.deletedResults ?? [], state, res);
+                        await (0, state_1.writeState)(this.rootDir, state);
+                        res.end(JSON.stringify({ message: this.buildPushSummary(counts, models, newModels, skipped) }) + "\n");
+                        // Test tabına yansıt — HTTP yanıtı kapandıktan sonra, best-effort (push'u asla bloklamaz;
+                        // hata da push'a sızmaz — res zaten kapandı, catch'e düşmemeli).
+                        try {
+                            this.afterPushSync(models, newModels, result);
+                        }
+                        catch (e) {
+                            logger_1.logger.warn(`test sync skipped: ${e.message}`);
+                        }
+                    }
+                    catch (err) {
+                        res.end(JSON.stringify({ error: err.message }) + "\n");
+                    }
+                    finally {
+                        this._pushInProgress = false;
+                        // Reply sonrası gelebilecek checkout echo'su _expectedCheckoutEchoes ile (id bazında) bastırılır.
+                        // Deferred echo eventlerini işle (push'un kendi kaynaklıları no-op olur).
+                        const deferredChanged = this._deferredModelChanged.splice(0);
+                        for (const d of deferredChanged)
+                            void this.handleModelChanged(d);
+                        const deferredCreated = this._deferredModelCreated.splice(0);
+                        for (const d of deferredCreated)
+                            void this.handleModelCreated(d);
+                    }
+                    return;
+                }
+                case "startWorking": {
+                    if (!this.bridgeClient?.isOpen) {
+                        this.respond(res, 409, { error: "studio not connected" });
+                        return;
+                    }
+                    let body;
+                    try {
+                        body = JSON.parse(await this.readBody(req));
+                    }
+                    catch {
+                        this.respond(res, 400, { error: "invalid request body" });
+                        return;
+                    }
+                    if (!body.modelId) {
+                        this.respond(res, 400, { error: "modelId required" });
+                        return;
+                    }
+                    const result = await this.bridgeClient.request("startWorking", { modelId: body.modelId });
+                    this.respond(res, 200, result);
+                    return;
+                }
+                case "convertToBlock": {
+                    if (!this.bridgeClient?.isOpen) {
+                        this.respond(res, 409, { error: "studio not connected" });
+                        return;
+                    }
+                    let body;
+                    try {
+                        body = JSON.parse(await this.readBody(req));
+                    }
+                    catch {
+                        this.respond(res, 400, { error: "invalid request body" });
+                        return;
+                    }
+                    if (!body.modelId) {
+                        this.respond(res, 400, { error: "modelId required" });
+                        return;
+                    }
+                    const result = await this.bridgeClient.request("convertToBlock", { modelId: body.modelId });
+                    this.respond(res, 200, result);
+                    return;
+                }
+                default:
+                    this.respond(res, 404, { error: `unknown control command: ${cmd}` });
+            }
+        }
+        catch (err) {
+            this.respond(res, 502, { error: err.message });
+        }
+    }
+    respond(res, status, body) {
+        res.writeHead(status, { "Content-Type": "application/json", ...this.corsHeaders() });
+        res.end(JSON.stringify(body));
+    }
+    // --- push sonuç işleme (handleControl "push" yardımcıları) ---
+    /** Mevcut modeller: bodyChanged'da state hash güncelle; rename/move sayaçları; her öğe için progress. */
+    applyExistingResults(results, models, state, counts, tick) {
+        for (const r of results) {
+            if (!r.ok) {
+                logger_1.logger.warn(`push ${r.id}: ${r.error ?? "failed"}`);
+                tick();
+                continue;
+            }
+            const pm = models.find(m => m.id === r.id);
+            if (pm?.bodyChanged) {
+                state[r.id] = (0, state_1.sha)(pm.model);
+                counts.okBody++;
+            }
+            if (r.renamed && r.moved)
+                counts.okBoth++;
+            else if (r.renamed)
+                counts.okRenamed++;
+            else if (r.moved)
+                counts.okMoved++;
+            tick();
+        }
+    }
+    /** Yeni dosyalar: yeni yaratılana frontmatter yaz, state hash hesapla; her öğe için progress. */
+    async applyNewModelResults(results, newModels, state, counts, tick) {
+        for (const r of results) {
+            if (!r.ok || !r.id || !r.key) {
+                logger_1.logger.warn(`push ${r.localKey}: ${r.error ?? "failed"}`);
+                tick();
+                continue;
+            }
+            const nm = newModels.find(m => m.localKey === r.localKey);
+            if (!nm) {
+                tick();
+                continue;
+            }
+            const absPath = (0, node_path_1.join)(this.rootDir, ...r.localKey.split("/"));
+            const isNewlyCreated = !nm.existingId || r.id !== nm.existingId;
+            if (isNewlyCreated) {
+                await (0, promises_1.writeFile)(absPath, (0, frontmatter_1.writeWithFrontmatter)({ id: r.id, ownerName: r.ownerName ?? "/" }, nm.body), "utf8");
+            }
+            const createdContent = await (0, promises_1.readFile)(absPath, "utf8");
+            const createdFm = (0, frontmatter_1.parseFrontmatter)(createdContent);
+            state[r.id] = (0, state_1.sha)(createdFm?.body ?? createdContent);
+            counts.okBody++;
+            tick();
+        }
+    }
+    /** Silinen modeller: state'ten çıkar; her öğe için progress. */
+    applyDeletedResults(results, state, counts, tick) {
+        for (const r of results) {
+            if (!r.ok) {
+                logger_1.logger.warn(`push delete ${r.id}: ${r.error ?? "failed"}`);
+                tick();
+                continue;
+            }
+            delete state[r.id];
+            counts.okDeleted++;
+            tick();
+        }
+    }
+    /** EPIC 13b — rename/move sonrası diğer dosyalardaki <<type:oldPath>> → <<type:newPath>> düzelt;
+     *  delete'te dangling referansları `skipped` satırıyla uyar. Düzeltilen dosya sayısı döner.
+     *  (Studio'da bağ id ile sabit; lokalde path ile olduğu için referans EDEN dosyalar bayatlar.) */
+    async syncReferences(results, deletedResults, state, res) {
+        const renames = results.flatMap(r => (r.ok && r.oldPath && r.newPath && r.oldPath !== r.newPath) ? [{ oldPath: r.oldPath, newPath: r.newPath }] : []);
+        const deletedPaths = deletedResults.flatMap(r => (r.ok && r.deletedPath) ? [r.deletedPath] : []);
+        if (renames.length === 0 && deletedPaths.length === 0)
+            return 0;
+        let okRefFiles = 0;
+        for (const abs of await walkDir(this.rootDir)) {
+            let content = await (0, promises_1.readFile)(abs, "utf8");
+            let changed = false;
+            for (const rn of renames) {
+                const rw = (0, modelRef_1.rewriteRefPath)(content, rn.oldPath, rn.newPath);
+                if (rw.count > 0) {
+                    content = rw.content;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                // Referans eden dosya checkout edilmemişse (0444) yazılamaz → geçici writable yap, sonra geri al.
+                const wasWritable = !!((await (0, promises_1.stat)(abs)).mode & 0o200);
+                if (!wasWritable)
+                    await (0, promises_1.chmod)(abs, 0o644);
+                await (0, promises_1.writeFile)(abs, content, "utf8");
+                if (!wasWritable)
+                    await (0, promises_1.chmod)(abs, 0o444);
+                const fm = (0, frontmatter_1.parseFrontmatter)(content);
+                if (fm)
+                    state[fm.meta.id] = (0, state_1.sha)(fm.body);
+                okRefFiles++;
+                logger_1.logger.info(`ref-sync: ${(0, node_path_1.relative)(this.rootDir, abs)}`);
+            }
+            for (const dp of deletedPaths) {
+                if ((0, modelRef_1.hasRefPath)(content, dp)) {
+                    res.write(JSON.stringify({ skipped: `${(0, node_path_1.relative)(this.rootDir, abs).replace(/\\/g, "/")} — references deleted '${dp}' (fix manually)` }) + "\n");
+                }
+            }
+        }
+        return okRefFiles;
+    }
+    /** push özet mesajı (son NDJSON satırı). */
+    buildPushSummary(counts, models, newModels, skipped) {
+        const parts = [];
+        const bodyTotal = models.filter(m => m.bodyChanged).length + newModels.length;
+        if (bodyTotal > 0)
+            parts.push(`pushed ${counts.okBody}/${bodyTotal} model(s)`);
+        if (counts.okBoth > 0)
+            parts.push(`${counts.okBoth} renamed and moved`);
+        if (counts.okRenamed > 0)
+            parts.push(`${counts.okRenamed} renamed`);
+        if (counts.okMoved > 0)
+            parts.push(`${counts.okMoved} moved`);
+        if (counts.okDeleted > 0)
+            parts.push(`${counts.okDeleted} deleted`);
+        if (counts.okRefFiles > 0)
+            parts.push(`refs updated in ${counts.okRefFiles} file(s)`);
+        if (parts.length === 0)
+            parts.push("nothing to push");
+        const readonlyCount = skipped.filter(s => s.reason === "readonly").length;
+        const unsupportedCount = skipped.filter(s => s.reason === "unsupported-type").length;
+        if (readonlyCount > 0)
+            parts.push(`${readonlyCount} read-only skipped`);
+        if (unsupportedCount > 0)
+            parts.push(`${unsupportedCount} unsupported type skipped`);
+        return parts.join(", ");
+    }
+    // --- test client sync (push edilen gövdelerin test tabına yansıtılması) ---
+    /** Push sonuçlarından sync item'larını çıkarır, lastSync'e merge eder ve (bağlıysa) test
+     *  client'a yollar. Primary push payload'ı ASLA replay edilmez — applyNewModel backend'de model
+     *  yaratır, replay double-create olur; bu yüzden FINAL id'lerle bu hafif mesaj gönderilir. */
+    afterPushSync(models, newModels, result) {
+        const items = [];
+        for (const r of result.results ?? []) {
+            if (!r.ok)
+                continue;
+            const pm = models.find(m => m.id === r.id);
+            if (!pm?.bodyChanged)
+                continue;
+            items.push({ id: pm.id, modelType: pm.modelType, body: pm.model, name: pm.newName, relDir: pm.relDir, isNew: false });
+        }
+        for (const r of result.newModelResults ?? []) {
+            if (!r.ok || !r.id)
+                continue; // primary'de create başarısızsa test'e HİÇ gitmez (hayalet model yok)
+            const nm = newModels.find(m => m.localKey === r.localKey);
+            if (!nm)
+                continue;
+            items.push({ id: r.id, modelType: nm.modelType, key: r.key, body: nm.body, name: r.name ?? nm.name, relDir: nm.relDir, isNew: !nm.existingId || r.id !== nm.existingId });
+        }
+        for (const it of items)
+            this.lastSync.set(it.id, it);
+        for (const d of result.deletedResults ?? [])
+            if (d.ok)
+                this.lastSync.delete(d.id);
+        // Gövdesiz rename/move/create/delete de test tabında refreshItems gerektirir.
+        const treeChanged = (result.results ?? []).some(r => r.ok && (r.renamed === true || r.moved === true))
+            || (result.newModelResults ?? []).some(r => r.ok)
+            || (result.deletedResults ?? []).some(r => r.ok);
+        if (this.testClient?.isOpen && (items.length > 0 || treeChanged)) {
+            void this.sendSyncModels("push", items, treeChanged);
+        }
+    }
+    /** syncModels'i test client'a yollar. replay → lastSync'ün tamamı (test hello/F5 sonrası).
+     *  Best-effort: hata yalnız loglanır; timeout 60s (handler refreshItems + editör açabilir). */
+    async sendSyncModels(reason, items, treeChanged = false) {
+        if (!this.testClient?.isOpen || this.claimedAppId === undefined)
+            return;
+        const models = reason === "replay" ? [...this.lastSync.values()] : (items ?? []);
+        if (models.length === 0 && !treeChanged)
+            return;
+        try {
+            const r = await this.testClient.request("syncModels", { appId: this.claimedAppId, reason, treeChanged, models }, 60000);
+            logger_1.logger.info(`test sync (${reason}): applied ${r.applied}, failed ${r.failed}`);
+            for (const e of r.errors ?? [])
+                logger_1.logger.warn(`test sync ${e.id}: ${e.error}`);
+        }
+        catch (err) {
+            logger_1.logger.warn(`test sync (${reason}) failed: ${err.message}`);
+        }
+    }
+    // --- web → local otomatik sync (modelChanged) ---
+    async handleModelChanged(payload) {
+        if (this._pushInProgress) {
+            this._deferredModelChanged.push(payload);
+            logger_1.logger.debug(`modelChanged: push in progress — deferring for id=${payload.modelId}`);
+            return;
+        }
+        const abs = await this.findFileById(payload.modelId);
+        if (!abs) {
+            logger_1.logger.debug(`modelChanged: no local file for id=${payload.modelId}`);
+            return;
+        }
+        const existing = await (0, promises_1.readFile)(abs, "utf8");
+        const fm = (0, frontmatter_1.parseFrontmatter)(existing);
+        if (!fm)
+            return;
+        // model="" → rename-only mesaj (body VMM'de yüklü değildi); body yazma atla
+        if (payload.model !== "") {
+            const ext = (0, node_path_1.extname)(abs).slice(1).toLowerCase();
+            const body = ext === "qjson" ? (0, pull_1.stripQJsonCompiledFields)(payload.model) : payload.model;
+            // Kullanıcı Studio'da kaydettiyse test replay'i (F5) bayat push gövdesine dönmesin.
+            const prev = this.lastSync.get(payload.modelId);
+            if (prev)
+                this.lastSync.set(payload.modelId, { ...prev, body });
+            const state = (0, state_1.readState)(this.rootDir);
+            // Push echo guard: hash state ile aynıysa (az önce pushladık) body yazmayı atla
+            if ((0, state_1.sha)(body) !== state[payload.modelId]) {
+                try {
+                    await (0, promises_1.chmod)(abs, 0o644);
+                }
+                catch { /* zaten yazılabilir veya dosya yok */ }
+                await (0, promises_1.writeFile)(abs, (0, frontmatter_1.writeWithFrontmatter)(fm.meta, body), "utf8");
+                state[payload.modelId] = (0, state_1.sha)(body);
+                await (0, state_1.writeState)(this.rootDir, state);
+                logger_1.logger.info(`auto-pulled: ${(0, node_path_1.relative)(this.rootDir, abs)}`);
+            }
+        }
+        // Rename ve move sırayla yapılır; currentAbs güncel yolu takip eder.
+        let currentAbs = abs;
+        if (payload.newName) {
+            const newAbs = (0, node_path_1.join)((0, node_path_1.dirname)(currentAbs), payload.newName + (0, node_path_1.extname)(currentAbs));
+            if (newAbs !== currentAbs) {
+                await (0, promises_1.rename)(currentAbs, newAbs);
+                logger_1.logger.info(`auto-renamed: ${(0, node_path_1.relative)(this.rootDir, currentAbs)} → ${(0, node_path_1.relative)(this.rootDir, newAbs)}`);
+                currentAbs = newAbs;
+            }
+        }
+        if (payload.newRelDir !== undefined) {
+            const currentRelDir = (0, node_path_1.relative)(this.rootDir, (0, node_path_1.dirname)(currentAbs)).replace(/\\/g, "/");
+            const normCurrentRelDir = currentRelDir === "." ? "" : currentRelDir;
+            if (payload.newRelDir !== normCurrentRelDir) {
+                const targetDir = payload.newRelDir
+                    ? (0, node_path_1.join)(this.rootDir, ...payload.newRelDir.split("/"))
+                    : this.rootDir;
+                const newAbs = (0, node_path_1.join)(targetDir, (0, node_path_1.basename)(currentAbs));
+                await (0, promises_1.mkdir)(targetDir, { recursive: true });
+                await (0, promises_1.rename)(currentAbs, newAbs);
+                logger_1.logger.info(`auto-moved: ${(0, node_path_1.relative)(this.rootDir, currentAbs)} → ${(0, node_path_1.relative)(this.rootDir, newAbs)}`);
+            }
+        }
+    }
+    // Studio'da yeni model yaratıldı → lokale tek dosya yaz (pull ile aynı writeModel mantığı).
+    // Echo guard: aynı ID'li dosya zaten varsa (push ile yaratıldıysa veya zaten pull'landıysa) atla.
+    // Push devam ederken gelen eventler deferred queue'ya alınır (frontmatter henüz yazılmadı).
+    async handleModelCreated(payload) {
+        if (this._pushInProgress) {
+            this._deferredModelCreated.push(payload);
+            logger_1.logger.debug(`modelCreated: push in progress — deferring for id=${payload.model.ID}`);
+            return;
+        }
+        const existing = await this.findFileById(payload.model.ID);
+        if (existing) {
+            logger_1.logger.debug(`modelCreated: file already exists for id=${payload.model.ID} — skipping (echo)`);
+            return;
+        }
+        const { hash } = await (0, pull_1.writeModel)(this.rootDir, payload.model, payload.readOnly);
+        if (hash !== undefined) {
+            const state = (0, state_1.readState)(this.rootDir);
+            state[payload.model.ID] = hash;
+            await (0, state_1.writeState)(this.rootDir, state);
+        }
+        logger_1.logger.info(`auto-pulled (new): ${payload.model.name}`);
+    }
+    async handleModelDeleted(payload) {
+        this.lastSync.delete(payload.modelId); // replay silinen modeli diriltmesin
+        const abs = await this.findFileById(payload.modelId);
+        if (!abs) {
+            logger_1.logger.debug(`modelDeleted: no local file for id=${payload.modelId}`);
+            return;
+        }
+        await (0, promises_1.unlink)(abs);
+        const state = (0, state_1.readState)(this.rootDir);
+        delete state[payload.modelId];
+        await (0, state_1.writeState)(this.rootDir, state);
+        logger_1.logger.info(`auto-deleted: ${(0, node_path_1.relative)(this.rootDir, abs)}`);
+    }
+    async handleCheckoutChanged(payload) {
+        // Push'un kendi checkout'undan kaynaklanan echo (yeni model yaratınca studio.checkout).
+        // Dosya push tarafından zaten doğru modda yazılıyor → log/chmod gereksiz, düşür.
+        // - Push sürerken: tümünü bastır.
+        // - Reply'dan sonra geç gelen echo: yalnız push'un checkout ettiği id'ler, consume-once.
+        // Yalnızca Studio'da manuel start/stop working log'lanır.
+        if (this._pushInProgress) {
+            logger_1.logger.debug(`checkoutChanged: push in progress — ignoring (echo) for id=${payload.modelId}`);
+            return;
+        }
+        if (this._expectedCheckoutEchoes.delete(payload.modelId)) {
+            logger_1.logger.debug(`checkoutChanged: expected push echo — ignoring for id=${payload.modelId}`);
+            return;
+        }
+        const abs = await this.findFileById(payload.modelId);
+        if (!abs) {
+            logger_1.logger.debug(`checkoutChanged: no local file for id=${payload.modelId}`);
+            return;
+        }
+        const mode = payload.checkedOutByMe ? 0o644 : 0o444;
+        await (0, promises_1.chmod)(abs, mode);
+        logger_1.logger.info(`checkout-changed: ${(0, node_path_1.relative)(this.rootDir, abs)} → ${payload.checkedOutByMe ? "editable (0644)" : "read-only (0444)"}`);
+    }
+    async findFileById(modelId) {
+        for (const abs of await walkDir(this.rootDir)) {
+            const content = await (0, promises_1.readFile)(abs, "utf8");
+            const fm = (0, frontmatter_1.parseFrontmatter)(content);
+            if (fm?.meta.id === modelId)
+                return abs;
+        }
+        return null;
+    }
+    // --- keepalive (bridge client'a) ---
+    startPing() {
+        this.stopPing();
+        this.pingTimer = setInterval(() => {
+            for (const p of [this.bridgeClient, this.testClient])
+                if (p?.isOpen)
+                    p.send("ping", {});
+        }, PING_INTERVAL_MS);
+    }
+    stopPing() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = undefined;
+        }
+    }
+}
+exports.BridgeServer = BridgeServer;
+async function walkDir(dir) {
+    const out = [];
+    for (const entry of await (0, promises_1.readdir)(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith("."))
+            continue;
+        const abs = (0, node_path_1.join)(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...(await walkDir(abs)));
+        else
+            out.push(abs);
+    }
+    return out;
+}
+//# sourceMappingURL=bridgeServer.js.map