@takimcizgisi/ajan 0.5.0

package/src/daemon/runner.ts

@@ -0,0 +1,261 @@
+/**
+ * Daemon çekirdeği: tek `AjanService`, seri işlem kuyruğu, olay yayını.
+ *
+ * Model belleği ve bağlam tek örnek üzerinden paylaşılır; bu yüzden modele
+ * dokunan istekler (chat, install, use-model, set-config) sıraya girer.
+ * Durum okuyan istekler (status, list) kuyruğu atlar.
+ */
+import { AjanService, type ServiceEvents } from "../service.js";
+import type { ChatHistoryItem } from "node-llama-cpp";
+import type { EventFrame, HistoryMessage, StatusReport } from "../protocol/messages.js";
+import { PROTOCOL_VERSION } from "../protocol/messages.js";
+import { buildGpuReport } from "./gpu.js";
+import { AJAN_VERSION } from "../version.js";
+
+type Listener = (event: EventFrame) => void;
+
+/** Modele dokunan işlemler bu listede sırayla çalışır. */
+type ExclusiveTask = () => Promise<void>;
+
+export class Runner {
+    private readonly service: AjanService;
+    private readonly listeners = new Set<Listener>();
+    private queue: Promise<void> = Promise.resolve();
+    private busy = false;
+
+    /** Sohbet dışı olayların varsayılan yayıncısı (model yükleme, durum) */
+    private readonly baseEvents: ServiceEvents;
+
+    /** Ajanın çalışma dizini (durum raporunda döner). */
+    readonly cwd: string;
+
+    constructor(cwd: string) {
+        this.cwd = cwd;
+        const events: ServiceEvents = {
+            onTextChunk: (text) => this.emit({ event: "text-chunk", text }),
+            onThinkingChunk: (text) => this.emit({ event: "thinking-chunk", text }),
+            onToolCall: (name, args) => this.emit({ event: "tool-call", name, args: (args ?? {}) as Record<string, unknown> }),
+            onToolResult: (name, ok, output) => this.emit({ event: "tool-result", name, ok, output }),
+            onStepStart: (step, maxSteps) => this.emit({ event: "step-start", step, maxSteps }),
+            onStepEnd: (step) => this.emit({ event: "step-end", step }),
+            // `updateEvents` birleştirdiği için sohbet bitince bu geri yüklenmezse
+            // `onError` bir sonraki hatada kapalı socket'e gider. Şimdiden tanımlı olmalı.
+            onError: (err) => this.emit({ event: "error", message: err.message }),
+            onModelLoadProgress: (pct) => this.emit({ event: "load-progress", pct }),
+            onModelLoadComplete: () => this.emit({ event: "load-complete" })
+        };
+        this.baseEvents = events;
+        this.service = new AjanService(events, cwd);
+    }
+
+    get instance(): AjanService {
+        return this.service;
+    }
+
+    subscribe(listener: Listener): () => void {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+
+    get clientCount(): number {
+        return this.listeners.size;
+    }
+
+    get isBusy(): boolean {
+        return this.busy;
+    }
+
+    private emit(event: EventFrame): void {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            } catch {
+                /* dinleyici hatası istemciyi düşürmemeli */
+            }
+        }
+    }
+
+    /** Modele dokunan işlemleri sıraya alır; işlem bitene kadar bekler. */
+    private exclusive<T>(task: () => Promise<T>): Promise<T> {
+        const run = this.queue.then(async () => {
+            this.busy = true;
+            try {
+                return await task();
+            } finally {
+                this.busy = false;
+            }
+        });
+        // Kuyruğun kendisi asla reddedilmesin; bir işlem hata verirse sonrakiler yine aksın.
+        this.queue = run.then(
+            () => undefined,
+            () => undefined
+        );
+        return run;
+    }
+
+    // ── İşlemler ──
+
+    /**
+     * Sohbet gönderir. Çıktı akışı yalnızca `target` alıcısına gider: motor
+     * paylaşılan, yanıt akışı değil. `target` verilmezse tüm bağlı istemcilere
+     * yayın yapılır (tek istemcili kullanımda aynı davranış).
+     */
+    async sendMessage(
+        text: string,
+        modelId?: string,
+        target?: Listener
+    ): Promise<{ ok: boolean; response?: string; steps?: number; error?: string }> {
+        return this.exclusive(async () => {
+            // Model yükleme ilerlemesi herkese açık: yükleme motor genelinde
+            // tek seferlik bir olaydır, sohbetten bağımsız.
+            const chatEvents: ServiceEvents = {
+                onTextChunk: (t) => this.to(target, { event: "text-chunk", text: t }),
+                onThinkingChunk: (t) => this.to(target, { event: "thinking-chunk", text: t }),
+                onToolCall: (name, args) =>
+                    this.to(target, { event: "tool-call", name, args: (args ?? {}) as Record<string, unknown> }),
+                onToolResult: (name, ok, output) => this.to(target, { event: "tool-result", name, ok, output }),
+                onStepStart: (step, maxSteps) => this.to(target, { event: "step-start", step, maxSteps }),
+                onStepEnd: (step) => this.to(target, { event: "step-end", step }),
+                onError: (err) => this.to(target, { event: "error", message: err.message }),
+                onModelLoadProgress: (pct) => this.emit({ event: "load-progress", pct }),
+                onModelLoadComplete: () => this.emit({ event: "load-complete" })
+            };
+            this.service.updateEvents(chatEvents);
+            try {
+                const result = await this.service.sendMessage(text, modelId);
+                if (!result.ok) this.to(target, { event: "error", message: result.error ?? "bilinmeyen hata" });
+                else this.to(target, { event: "complete", response: result.response ?? "", steps: result.steps ?? 0 });
+                return result;
+            } finally {
+                // Yayını eski hedefe döndür: istek bittiğinde olaylar kalıcı olarak
+                // tek istemciye bağlı kalmasın.
+                this.service.updateEvents(this.baseEvents);
+            }
+        });
+    }
+
+    private to(target: Listener | undefined, event: EventFrame): void {
+        if (target) target(event);
+        else this.emit(event);
+    }
+
+    setConfig(patch: Record<string, unknown>): Promise<void> {
+        return this.exclusive(() => this.service.setConfig(patch));
+    }
+
+    useModel(id: string): Promise<{ ok: boolean; error?: string }> {
+        return this.exclusive(() => this.service.useModel(id));
+    }
+
+    installModel(id: string): Promise<{ ok: boolean; error?: string }> {
+        return this.exclusive(() => this.service.installModel(id));
+    }
+
+    removeModel(id: string): Promise<{ ok: boolean; error?: string }> {
+        return this.exclusive(() => this.service.removeModel(id));
+    }
+
+    refreshModels(): Promise<{ ok: boolean; count?: number; error?: string }> {
+        return this.exclusive(() => this.service.refreshModels());
+    }
+
+    reset(): Promise<void> {
+        return this.exclusive(() => this.service.reset());
+    }
+
+    abort(): void {
+        this.service.abort();
+    }
+
+    listModels() {
+        return this.service.listModels();
+    }
+
+    listSessions() {
+        return this.service.listSessions();
+    }
+
+    loadSession(id: string) {
+        return this.service.loadSession(id);
+    }
+
+    saveSession(session: Parameters<AjanService["saveSession"]>[0]) {
+        return this.service.saveSession(session);
+    }
+
+    deleteSession(id: string) {
+        return this.service.deleteSession(id);
+    }
+
+    getHistory(): HistoryMessage[] {
+        return toHistoryMessages(this.service.getChatHistory());
+    }
+
+    setHistory(history: ChatHistoryItem[]): void {
+        this.service.setChatHistory(history);
+    }
+
+    async status(): Promise<StatusReport> {
+        const model = this.service.getModelInfo();
+        const config = this.service.getConfig();
+        return {
+            protocol: PROTOCOL_VERSION,
+            version: AJAN_VERSION,
+            modelId: config.modelId,
+            modelName: model?.name ?? config.modelId,
+            installed: model?.installed ?? false,
+            loading: false,
+            busy: this.busy,
+            cwd: this.cwd,
+            gpu: await buildGpuReport(this.service),
+            context: this.service.getContextStats(),
+            reasoning: this.service.getReasoningInfo(),
+            config,
+            clients: this.clientCount,
+            uptimeSec: Math.round(process.uptime())
+        };
+    }
+
+    async dispose(): Promise<void> {
+        await this.service.dispose();
+    }
+}
+
+/**
+ * node-llama-cpp geçmişini istemciye gönderilebilir sade biçime çevirir.
+ * Düşünme segmentleri ayrı `thought` mesajı olarak ayrılır; araç çağrıları
+ * `tool` türüne düşer.
+ */
+export function toHistoryMessages(history: ChatHistoryItem[]): HistoryMessage[] {
+    const out: HistoryMessage[] = [];
+    for (const item of history) {
+        if (item.type === "user") {
+            out.push({ kind: "user", text: textOf(item.text) });
+            continue;
+        }
+        if (item.type !== "model") continue;
+        let text = "";
+        let thought = "";
+        for (const part of item.response) {
+            if (typeof part === "string") {
+                text += part;
+                continue;
+            }
+            if (part.type === "segment") {
+                if (part.segmentType === "thought") thought += part.text;
+                else text += part.text;
+                continue;
+            }
+            if (part.type === "functionCall") {
+                out.push({ kind: "tool", text: part.name, name: part.name });
+            }
+        }
+        if (thought) out.push({ kind: "thought", text: thought });
+        if (text) out.push({ kind: "assistant", text });
+    }
+    return out;
+}
+
+function textOf(value: unknown): string {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}

package/src/daemon/server.ts

@@ -0,0 +1,231 @@
+/**
+ * IPC sunucusu: named pipe / unix socket üzerinden dinler, istekleri `Runner`'a
+ * yönlendirir, motor olaylarını tüm bağlı istemcilere yayar.
+ *
+ * Bağlantı başına ayrı oturum durumu tutulur; model ise tek ve paylaşılan.
+ */
+import { createServer, type Server, type Socket } from "node:net";
+import { existsSync, unlinkSync } from "node:fs";
+import { defaultSocketPath, send, serveChannel } from "../protocol/channel.js";
+import { isRequestFrame, type Result, type ServerFrame } from "../protocol/messages.js";
+import { AJAN_VERSION } from "../version.js";
+import { PROTOCOL_VERSION } from "../protocol/messages.js";
+import type { Runner } from "./runner.js";
+import { logger } from "../utils/paths.js";
+
+/** İstemcinin kopmasından kaynaklanan, loglanmaya değmeyen hatalar. */
+function isDisconnect(err: Error): boolean {
+    const code = (err as NodeJS.ErrnoException).code;
+    return code === "EPIPE" || code === "ECONNRESET" || code === "ERR_STREAM_DESTROYED";
+}
+
+export class DaemonServer {
+    private readonly server: Server;
+    private readonly sockets = new Set<Socket>();
+    private closing = false;
+
+    constructor(
+        private readonly runner: Runner,
+        private readonly socketPath: string = defaultSocketPath()
+    ) {
+        this.server = createServer((socket) => this.accept(socket));
+    }
+
+    get path(): string {
+        return this.socketPath;
+    }
+
+    get clientCount(): number {
+        return this.sockets.size;
+    }
+
+    /** Sunucuyu dinlemeye başlar; eski socket artığını temizler. */
+    listen(): Promise<void> {
+        // POSIX'te çökmüş bir daemon bırakırsa socket dosyası kalır ve
+        // "EADDRINUSE" verir; sahipsizse güvenle silinebilir.
+        if (process.platform !== "win32" && existsSync(this.socketPath)) {
+            try {
+                unlinkSync(this.socketPath);
+            } catch {
+                /* başka bir süreç kullanıyorsa dokunma */
+            }
+        }
+        return new Promise((resolve, reject) => {
+            this.server.once("error", reject);
+            this.server.listen(this.socketPath, () => {
+                this.server.removeListener("error", reject);
+                logger.info(`AJAN motoru dinliyor: ${this.socketPath}`);
+                resolve();
+            });
+        });
+    }
+
+    private accept(socket: Socket): void {
+        this.sockets.add(socket);
+        const write = (frame: ServerFrame) => {
+            if (socket.destroyed) return;
+            // İstemci kapanmak normaldir (kapanış yarışı, `close()` çağrısı).
+            // Yazma hatası kullanıcıyı rahatsız edecek gürültü yaratmasın; soket
+            // zaten `close` dinleyicisinde temizleniyor.
+            try {
+                send(socket, frame);
+            } catch {
+                /* bağlantı koptu */
+            }
+        };
+        // Olaylar tüm istemcilere gider: motor tek, sohbetler ayrı değil.
+        // (İleride oturum bazlı yönlendirme gerekiyorsa burada hedeflenir.)
+        const unsubscribe = this.runner.subscribe(write);
+
+        serveChannel(
+            socket,
+            (frame) => {
+                const valid = acceptFrame(frame);
+                if (!valid) {
+                    logger.warn("geçersiz istek zarfı yok sayıldı");
+                    return;
+                }
+                void this.dispatch(valid, write);
+            },
+            (err) => {
+                if (isDisconnect(err)) return; // EPIPE/ECONNRESET: normal kapanış
+                logger.warn(`kanal hatası: ${err.message}`);
+            }
+        );
+
+        socket.on("close", () => {
+            unsubscribe();
+            this.sockets.delete(socket);
+            logger.debug(`istemci ayrıldı (kalan: ${this.sockets.size})`);
+        });
+        socket.on("error", () => socket.destroy());
+        logger.debug(`istemci bağlandı (toplam: ${this.sockets.size})`);
+    }
+
+    private async dispatch(frame: { id: number; req: { type: string } & Record<string, unknown> }, write: (f: ServerFrame) => void): Promise<void> {
+        const id = frame.id;
+        const req = frame.req;
+        const reply = (ok: true, result: Result) => write({ id, ok, result });
+        const fail = (error: string) => write({ id, ok: false, error });
+
+        try {
+            switch (req.type) {
+                case "ping": {
+                    reply(true, { type: "pong", protocol: PROTOCOL_VERSION, version: AJAN_VERSION });
+                    break;
+                }
+                case "status":
+                    reply(true, { type: "status", status: await this.runner.status() });
+                    break;
+                case "set-config": {
+                    await this.runner.setConfig(req.patch as Record<string, unknown>);
+                    reply(true, { type: "config", config: this.runner.instance.getConfig() });
+                    break;
+                }
+                case "list-models": {
+                    const models = this.runner.listModels().map((m) => ({ ...m.model, path: m.path, installed: m.installed, active: m.active }));
+                    reply(true, { type: "models", models });
+                    break;
+                }
+                case "install-model": {
+                    const r = await this.runner.installModel(req.id as string);
+                    reply(true, { type: "model", id: String(req.id), ok: r.ok, error: r.error });
+                    break;
+                }
+                case "remove-model": {
+                    const r = await this.runner.removeModel(req.id as string);
+                    reply(true, { type: "model", id: String(req.id), ok: r.ok, error: r.error });
+                    break;
+                }
+                case "use-model": {
+                    const r = await this.runner.useModel(req.id as string);
+                    reply(true, { type: "model", id: String(req.id), ok: r.ok, error: r.error });
+                    break;
+                }
+                case "refresh-models": {
+                    const r = await this.runner.refreshModels();
+                    reply(true, { type: "models-refreshed", ok: r.ok, count: r.count ?? 0, error: r.error });
+                    break;
+                }
+                case "chat": {
+                    // Asıl yanıt akışla gelir (text-chunk/complete olayları).
+                    // Bu kanal yalnızca görevin bittiğini teyit eder; başarısızlık
+                    // durumunda hata zarfı döner, aksi halde istemci asılı kalırdı.
+                    // Sohbet çıktısı yalnızca soran bağlantıya gider (`write`),
+                    // diğer istemcilere sızmasın.
+                    const r = await this.runner.sendMessage(String(req.text ?? ""), req.modelId as string | undefined, write);
+                    if (!r.ok) fail(r.error ?? "görev başarısız");
+                    else reply(true, { type: "ok" });
+                    break;
+                }
+                case "abort":
+                    this.runner.abort();
+                    reply(true, { type: "ok" });
+                    break;
+                case "new-chat": {
+                    await this.runner.reset();
+                    reply(true, { type: "ok" });
+                    break;
+                }
+                case "get-history":
+                    reply(true, { type: "history", messages: this.runner.getHistory() });
+                    break;
+                case "list-sessions": {
+                    const sessions = await this.runner.listSessions();
+                    reply(true, {
+                        type: "sessions",
+                        sessions: sessions.map((s) => ({ id: s.id, title: s.title, updatedAt: s.updatedAt }))
+                    });
+                    break;
+                }
+                case "load-session": {
+                    const session = await this.runner.loadSession(String(req.id));
+                    reply(true, { type: "session", session, ok: session != null });
+                    break;
+                }
+                case "save-session": {
+                    await this.runner.saveSession(req.session as never);
+                    reply(true, { type: "ok" });
+                    break;
+                }
+                case "delete-session": {
+                    await this.runner.deleteSession(String(req.id));
+                    reply(true, { type: "ok" });
+                    break;
+                }
+                case "shutdown": {
+                    reply(true, { type: "shutdown", ok: true });
+                    void this.close();
+                    break;
+                }
+                default:
+                    fail(`bilinmeyen istek: ${String(req.type)}`);
+            }
+        } catch (err) {
+            fail((err as Error).message);
+        }
+    }
+
+    async close(): Promise<void> {
+        if (this.closing) return;
+        this.closing = true;
+        for (const socket of this.sockets) socket.end();
+        this.sockets.clear();
+        await new Promise<void>((resolve) => this.server.close(() => resolve()));
+        await this.runner.dispose();
+        if (process.platform !== "win32" && existsSync(this.socketPath)) {
+            try {
+                unlinkSync(this.socketPath);
+            } catch {
+                /* temizlik başarısız olsa da çıkışı engellememeli */
+            }
+        }
+    }
+}
+
+/** İstek zarfının gerçekten geçerli olduğunu doğrular; geçersizse null döner. */
+export function acceptFrame(value: unknown): { id: number; req: { type: string } & Record<string, unknown> } | null {
+    if (!isRequestFrame(value)) return null;
+    const f = value as { id: number; req: { type: string } & Record<string, unknown> };
+    return f;
+}