@seele00/seele 0.1.63 → 0.1.64

package/server/dist/doctor.js

@@ -1,105 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,405 +0,0 @@
-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"] : [],
-    };
-}