@seele00/seele 0.1.60

package/server/dist/doctor.js

@@ -0,0 +1,105 @@
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import { loadConfig } from "./config/config.js";
+import { UserStore } from "./auth/users.js";
+import { getConversationStoreDiagnostics, initializeConversationStore, } from "./conversations/store.js";
+const config = loadConfig();
+const users = new UserStore(config.centerDbPath, {
+    username: config.authUsername,
+    password: config.authPassword,
+});
+let store = null;
+let initializationError = null;
+try {
+    initializeConversationStore({
+        centerDbPath: config.centerDbPath,
+        workspaceRoot: config.workspaceRoot,
+        defaultSandbox: config.defaultSandbox,
+        defaultOwnerId: users.listUsers().find((user) => user.role === "admin")?.id ?? "local-admin",
+    });
+    store = getConversationStoreDiagnostics();
+}
+catch (error) {
+    initializationError = error instanceof Error ? error.message : String(error);
+}
+const paths = {
+    seeleRoot: await checkPath(config.seeleRoot),
+    workspaceRoot: await checkPath(config.workspaceRoot),
+    webDistPath: await checkPath(config.webDistPath, { requireWrite: false }),
+};
+const centerDbOk = store !== null &&
+    store.centerSchemaVersion === store.expectedCenterSchemaVersion;
+const workspaceSchemasOk = store !== null && store.workspaceDatabases.every((workspace) => workspace.schemaVersion === store.expectedWorkspaceSchemaVersion);
+const pathsOk = Object.values(paths).every((check) => check.ok);
+const ok = initializationError === null && centerDbOk && workspaceSchemasOk && pathsOk;
+const report = {
+    ok,
+    config: {
+        seeleRoot: config.seeleRoot,
+        centerDbPath: config.centerDbPath,
+        workspaceRoot: config.workspaceRoot,
+        defaultSandbox: config.defaultSandbox,
+        defaultModel: config.defaultModel ?? null,
+        codexBin: config.codexBin ?? null,
+    },
+    checks: {
+        initialization: {
+            ok: initializationError === null,
+            error: initializationError,
+        },
+        centerDb: {
+            ok: centerDbOk,
+            schemaVersion: store?.centerSchemaVersion ?? null,
+            expected: store?.expectedCenterSchemaVersion ?? null,
+        },
+        workspaceSchemas: {
+            ok: workspaceSchemasOk,
+            expected: store?.expectedWorkspaceSchemaVersion ?? null,
+            workspaces: (store?.workspaceDatabases ?? []).map((workspace) => ({
+                id: workspace.id,
+                title: workspace.title,
+                schemaVersion: workspace.schemaVersion,
+                messages: workspace.messages,
+                events: workspace.events,
+                turns: workspace.turns,
+            })),
+        },
+        paths,
+    },
+    summary: {
+        workspaces: store?.workspaces ?? 0,
+        groups: store?.groups ?? 0,
+        activeConversations: store?.activeConversations ?? 0,
+    },
+};
+console.log(JSON.stringify(report, null, 2));
+process.exitCode = ok ? 0 : 1;
+async function checkPath(targetPath, options = {}) {
+    const requireWrite = options.requireWrite ?? true;
+    let readable = false;
+    let writable = requireWrite ? false : null;
+    let error = null;
+    try {
+        await fs.access(targetPath, fsConstants.R_OK);
+        readable = true;
+    }
+    catch (accessError) {
+        error = accessError instanceof Error ? accessError.message : String(accessError);
+    }
+    if (requireWrite) {
+        try {
+            await fs.access(targetPath, fsConstants.W_OK);
+            writable = true;
+        }
+        catch (accessError) {
+            error = accessError instanceof Error ? accessError.message : String(accessError);
+        }
+    }
+    return {
+        ok: readable && (writable ?? true),
+        path: targetPath,
+        readable,
+        writable,
+        error,
+    };
+}

package/server/dist/realtime/sse.js

@@ -0,0 +1,12 @@
+export function openSse(response) {
+    response.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+    });
+}
+export function sendSse(response, event, data) {
+    response.write(`event: ${event}\n`);
+    response.write(`data: ${JSON.stringify(data)}\n\n`);
+}

package/server/dist/runtime-worker/client.js

@@ -0,0 +1,405 @@
+import { fork } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+const WORKER_HARD_KILL_AFTER_MS = 5_000;
+const WORKER_STALE_AFTER_MS = 45_000;
+export class RuntimeWorkerClient {
+    handlers;
+    workers = new Map();
+    pendingThreadReads = new Map();
+    pendingThreadRebuilds = new Map();
+    pendingModelLists = new Map();
+    pendingRateLimitReads = new Map();
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    getDiagnostics() {
+        const now = Date.now();
+        const workers = [...this.workers.entries()]
+            .map(([turnId, entry]) => ({
+            turnId,
+            pid: entry.process.pid ?? null,
+            state: entry.state,
+            uptimeMs: Math.max(0, now - entry.startedAt),
+            eventCount: entry.eventCount,
+            lastMessageAt: formatTimestamp(entry.lastMessageAt),
+            lastEventAt: formatTimestamp(entry.lastEventAt),
+            lastHeartbeatAt: formatTimestamp(entry.lastHeartbeatAt),
+            stopRequestedAt: formatTimestamp(entry.stopRequestedAt),
+            stale: isWorkerStale(entry, now),
+        }))
+            .sort((left, right) => left.turnId.localeCompare(right.turnId));
+        return {
+            workerCount: this.workers.size,
+            workers,
+            turnIds: workers.map((worker) => worker.turnId),
+            staleWorkerCount: workers.filter((worker) => worker.stale).length,
+        };
+    }
+    startTurn(turnId, config, request) {
+        this.send(turnId, {
+            type: "turn.start",
+            payload: {
+                turnId,
+                config,
+                request,
+            },
+        });
+    }
+    stopTurn(turnId) {
+        const entry = this.workers.get(turnId);
+        if (entry) {
+            entry.state = "stopping";
+            entry.stopRequestedAt = Date.now();
+            this.scheduleHardKill(turnId, entry);
+        }
+        this.sendToExisting(turnId, {
+            type: "turn.stop",
+            payload: { turnId },
+        });
+    }
+    steerTurn(turnId, message) {
+        this.sendToExisting(turnId, {
+            type: "turn.steer",
+            payload: { turnId, message },
+        });
+    }
+    respondApproval(turnId, requestId, decision) {
+        this.sendToExisting(turnId, {
+            type: "turn.approval.respond",
+            payload: { turnId, requestId, decision },
+        });
+    }
+    readThread(config, request) {
+        const operationId = `thread-read:${randomUUID()}`;
+        return new Promise((resolve, reject) => {
+            this.pendingThreadReads.set(operationId, { resolve, reject });
+            this.send(operationId, {
+                type: "thread.read",
+                payload: {
+                    operationId,
+                    config,
+                    request,
+                },
+            });
+        });
+    }
+    rebuildThread(config, request, injectedItems) {
+        const operationId = `thread-rebuild:${randomUUID()}`;
+        return new Promise((resolve, reject) => {
+            this.pendingThreadRebuilds.set(operationId, { resolve, reject });
+            this.send(operationId, {
+                type: "thread.rebuild",
+                payload: {
+                    operationId,
+                    config,
+                    request,
+                    injectedItems,
+                },
+            });
+        });
+    }
+    listModels(config) {
+        const operationId = `models-list:${randomUUID()}`;
+        return new Promise((resolve, reject) => {
+            this.pendingModelLists.set(operationId, { resolve, reject });
+            this.send(operationId, {
+                type: "runtime.models.list",
+                payload: { operationId, config },
+            });
+        });
+    }
+    readRateLimits(config) {
+        const operationId = `rate-limits-read:${randomUUID()}`;
+        return new Promise((resolve, reject) => {
+            this.pendingRateLimitReads.set(operationId, { resolve, reject });
+            this.send(operationId, {
+                type: "runtime.rate_limits.read",
+                payload: { operationId, config },
+            });
+        });
+    }
+    send(turnId, message) {
+        const entry = this.ensureWorker(turnId);
+        this.sendToEntry(turnId, entry, message);
+        if (message.type === "turn.start" ||
+            message.type === "thread.read" ||
+            message.type === "thread.rebuild" ||
+            message.type === "runtime.models.list" ||
+            message.type === "runtime.rate_limits.read") {
+            entry.state = "running";
+        }
+    }
+    sendToExisting(turnId, message) {
+        const entry = this.workers.get(turnId);
+        if (!entry) {
+            throw new Error(`runtime worker not found: ${turnId}`);
+        }
+        this.sendToEntry(turnId, entry, message);
+    }
+    sendToEntry(turnId, entry, message) {
+        if (!entry.process.connected) {
+            throw new Error(`runtime worker is not connected: ${turnId}`);
+        }
+        entry.process.send(message);
+    }
+    ensureWorker(turnId) {
+        const existing = this.workers.get(turnId);
+        if (existing?.process.connected) {
+            return existing;
+        }
+        const workerEntry = resolveWorkerEntry();
+        const worker = fork(workerEntry.path, [], {
+            execArgv: workerEntry.execArgv,
+            stdio: ["ignore", "inherit", "inherit", "ipc"],
+        });
+        const entry = {
+            process: worker,
+            startedAt: Date.now(),
+            state: "starting",
+            hardKillTimer: null,
+            eventCount: 0,
+            lastMessageAt: null,
+            lastEventAt: null,
+            lastHeartbeatAt: null,
+            stopRequestedAt: null,
+        };
+        this.workers.set(turnId, entry);
+        worker.on("message", (message) => {
+            this.handleWorkerMessage(message);
+        });
+        worker.on("exit", (code, signal) => {
+            if (this.workers.get(turnId)?.process === worker) {
+                const state = this.workers.get(turnId)?.state ?? "failed";
+                this.workers.delete(turnId);
+                this.clearHardKill(entry);
+                this.rejectPendingOperation(turnId, new Error(`runtime worker exited: code=${code} signal=${signal}`));
+                if (!isRuntimeOperationId(turnId) &&
+                    state !== "completed" &&
+                    state !== "failed" &&
+                    state !== "stopping") {
+                    this.handlers.onFailed({
+                        turnId,
+                        message: `runtime worker exited: code=${code} signal=${signal}`,
+                    });
+                }
+            }
+        });
+        worker.on("error", (error) => {
+            if (this.workers.get(turnId)?.process === worker) {
+                entry.state = "failed";
+                this.workers.delete(turnId);
+                this.clearHardKill(entry);
+                this.rejectPendingOperation(turnId, error);
+                if (!isRuntimeOperationId(turnId)) {
+                    this.handlers.onFailed({
+                        turnId,
+                        message: error.message,
+                    });
+                }
+            }
+        });
+        return entry;
+    }
+    handleWorkerMessage(message) {
+        this.touchWorkerMessage(message);
+        if (message.type === "worker.ready") {
+            const entry = this.workers.get(message.turnId);
+            if (entry && entry.state === "starting") {
+                entry.state = "running";
+            }
+            this.handlers.onEvent({
+                turnId: message.turnId,
+                event: "runtime.worker_ready",
+                data: {},
+            });
+            return;
+        }
+        if (message.type === "worker.heartbeat") {
+            const entry = this.workers.get(message.turnId);
+            if (entry) {
+                entry.lastHeartbeatAt = Date.now();
+            }
+            return;
+        }
+        if (message.type === "turn.event") {
+            const entry = this.workers.get(message.turnId);
+            if (entry) {
+                entry.eventCount += 1;
+                entry.lastEventAt = Date.now();
+            }
+            this.handlers.onEvent(message);
+            return;
+        }
+        if (message.type === "turn.completed") {
+            const entry = this.workers.get(message.turnId);
+            if (entry) {
+                entry.state = "completed";
+            }
+            this.forgetWorker(message.turnId);
+            this.handlers.onCompleted(message);
+            return;
+        }
+        if (message.type === "turn.failed") {
+            const entry = this.workers.get(message.turnId);
+            if (entry) {
+                entry.state = "failed";
+            }
+            this.forgetWorker(message.turnId);
+            this.handlers.onFailed(message);
+            return;
+        }
+        if (message.type === "turn.worker_error") {
+            if (message.turnId) {
+                this.handlers.onEvent({
+                    turnId: message.turnId,
+                    event: "runtime.worker_error",
+                    data: { message: message.message },
+                });
+            }
+        }
+        if (message.type === "thread.read.completed") {
+            const pending = this.pendingThreadReads.get(message.operationId);
+            this.pendingThreadReads.delete(message.operationId);
+            this.forgetWorker(message.operationId);
+            pending?.resolve(message.result);
+            return;
+        }
+        if (message.type === "thread.rebuild.completed") {
+            const pending = this.pendingThreadRebuilds.get(message.operationId);
+            this.pendingThreadRebuilds.delete(message.operationId);
+            this.forgetWorker(message.operationId);
+            pending?.resolve(message.result);
+            return;
+        }
+        if (message.type === "runtime.models.list.completed") {
+            const pending = this.pendingModelLists.get(message.operationId);
+            this.pendingModelLists.delete(message.operationId);
+            this.forgetWorker(message.operationId);
+            pending?.resolve(message.result);
+            return;
+        }
+        if (message.type === "runtime.rate_limits.read.completed") {
+            const pending = this.pendingRateLimitReads.get(message.operationId);
+            this.pendingRateLimitReads.delete(message.operationId);
+            this.forgetWorker(message.operationId);
+            pending?.resolve(message.result);
+            return;
+        }
+        if (message.type === "runtime.operation_failed") {
+            const error = new Error(message.message);
+            const readPending = this.pendingThreadReads.get(message.operationId);
+            if (readPending) {
+                this.pendingThreadReads.delete(message.operationId);
+                this.forgetWorker(message.operationId);
+                readPending.reject(error);
+                return;
+            }
+            const rebuildPending = this.pendingThreadRebuilds.get(message.operationId);
+            if (rebuildPending) {
+                this.pendingThreadRebuilds.delete(message.operationId);
+                this.forgetWorker(message.operationId);
+                rebuildPending.reject(error);
+                return;
+            }
+            const modelListPending = this.pendingModelLists.get(message.operationId);
+            if (modelListPending) {
+                this.pendingModelLists.delete(message.operationId);
+                this.forgetWorker(message.operationId);
+                modelListPending.reject(error);
+                return;
+            }
+            const rateLimitPending = this.pendingRateLimitReads.get(message.operationId);
+            if (rateLimitPending) {
+                this.pendingRateLimitReads.delete(message.operationId);
+                this.forgetWorker(message.operationId);
+                rateLimitPending.reject(error);
+            }
+        }
+    }
+    forgetWorker(turnId) {
+        const entry = this.workers.get(turnId);
+        if (entry) {
+            this.clearHardKill(entry);
+        }
+        this.workers.delete(turnId);
+    }
+    rejectPendingOperation(operationId, error) {
+        const readPending = this.pendingThreadReads.get(operationId);
+        if (readPending) {
+            this.pendingThreadReads.delete(operationId);
+            readPending.reject(error);
+        }
+        const rebuildPending = this.pendingThreadRebuilds.get(operationId);
+        if (rebuildPending) {
+            this.pendingThreadRebuilds.delete(operationId);
+            rebuildPending.reject(error);
+        }
+        const modelListPending = this.pendingModelLists.get(operationId);
+        if (modelListPending) {
+            this.pendingModelLists.delete(operationId);
+            modelListPending.reject(error);
+        }
+        const rateLimitPending = this.pendingRateLimitReads.get(operationId);
+        if (rateLimitPending) {
+            this.pendingRateLimitReads.delete(operationId);
+            rateLimitPending.reject(error);
+        }
+    }
+    scheduleHardKill(turnId, entry) {
+        if (entry.hardKillTimer) {
+            return;
+        }
+        entry.hardKillTimer = setTimeout(() => {
+            if (this.workers.get(turnId) !== entry) {
+                return;
+            }
+            this.handlers.onEvent({
+                turnId,
+                event: "runtime.worker_hard_kill",
+                data: { timeoutMs: WORKER_HARD_KILL_AFTER_MS },
+            });
+            entry.process.kill("SIGKILL");
+        }, WORKER_HARD_KILL_AFTER_MS);
+        entry.hardKillTimer.unref?.();
+    }
+    clearHardKill(entry) {
+        if (entry.hardKillTimer) {
+            clearTimeout(entry.hardKillTimer);
+            entry.hardKillTimer = null;
+        }
+    }
+    touchWorkerMessage(message) {
+        if (!("turnId" in message) || !message.turnId) {
+            return;
+        }
+        const entry = this.workers.get(message.turnId);
+        if (entry) {
+            entry.lastMessageAt = Date.now();
+        }
+    }
+}
+function isWorkerStale(entry, now) {
+    if (entry.state === "stopping") {
+        return false;
+    }
+    const lastSignal = Math.max(entry.startedAt, entry.lastMessageAt ?? 0, entry.lastEventAt ?? 0, entry.lastHeartbeatAt ?? 0);
+    return now - lastSignal > WORKER_STALE_AFTER_MS;
+}
+function isRuntimeOperationId(value) {
+    return (value.startsWith("thread-read:") ||
+        value.startsWith("thread-rebuild:") ||
+        value.startsWith("models-list:") ||
+        value.startsWith("rate-limits-read:"));
+}
+function formatTimestamp(value) {
+    return value === null ? null : new Date(value).toISOString();
+}
+function resolveWorkerEntry() {
+    const currentPath = fileURLToPath(import.meta.url);
+    const isTypeScriptRuntime = currentPath.endsWith(".ts");
+    return {
+        path: fileURLToPath(new URL(`./process.${isTypeScriptRuntime ? "ts" : "js"}`, import.meta.url)),
+        execArgv: isTypeScriptRuntime ? ["--import", "tsx"] : [],
+    };
+}