forge-openclaw-plugin 0.2.19 → 0.2.21

package/dist/server/managers/platform/background-job-manager.js

@@ -1,10 +1,146 @@
 import { AbstractManager } from "../base.js";
+import { recordDiagnosticLog } from "../../repositories/diagnostic-logs.js";
 export class BackgroundJobManager extends AbstractManager {
+    maxConcurrentJobs;
     name = "BackgroundJobManager";
+    queue = [];
+    active = new Set();
+    draining = false;
+    constructor(maxConcurrentJobs = 3) {
+        super();
+        this.maxConcurrentJobs = maxConcurrentJobs;
+    }
     start() {
         return;
     }
-    stop() {
-        return;
+    enqueue(input) {
+        if (this.has(input.id)) {
+            this.recordLifecycleLog("info", "background_job_enqueue_skipped", {
+                task: input,
+                message: `Skipped duplicate background job ${input.label}.`,
+                details: {
+                    queueDepth: this.queue.length,
+                    activeCount: this.active.size
+                },
+                functionName: "enqueue"
+            });
+            return;
+        }
+        this.queue.push(input);
+        this.recordLifecycleLog("info", "background_job_enqueued", {
+            task: input,
+            message: `Enqueued background job ${input.label}.`,
+            details: {
+                queueDepth: this.queue.length,
+                activeCount: this.active.size
+            },
+            functionName: "enqueue"
+        });
+        this.scheduleDrain();
+    }
+    isActive(jobId) {
+        return this.active.has(jobId);
+    }
+    has(jobId) {
+        return (this.active.has(jobId) || this.queue.some((task) => task.id === jobId));
+    }
+    async stop() {
+        this.draining = true;
+        while (this.active.size > 0) {
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
+    scheduleDrain() {
+        if (this.draining ||
+            this.queue.length === 0 ||
+            this.active.size >= this.maxConcurrentJobs) {
+            return;
+        }
+        queueMicrotask(() => {
+            void this.drainAvailable();
+        });
+    }
+    async drainAvailable() {
+        if (this.draining) {
+            return;
+        }
+        while (!this.draining &&
+            this.queue.length > 0 &&
+            this.active.size < this.maxConcurrentJobs) {
+            const next = this.queue.shift();
+            if (!next) {
+                return;
+            }
+            this.active.add(next.id);
+            void this.runTask(next);
+        }
+    }
+    async runTask(next) {
+        const startedAt = Date.now();
+        this.recordLifecycleLog("info", "background_job_started", {
+            task: next,
+            message: `Started background job ${next.label}.`,
+            details: {
+                queueDepth: this.queue.length,
+                activeCount: this.active.size,
+                maxConcurrentJobs: this.maxConcurrentJobs
+            },
+            functionName: "runTask"
+        });
+        try {
+            await next.handler();
+            this.recordLifecycleLog("info", "background_job_completed", {
+                task: next,
+                message: `Completed background job ${next.label}.`,
+                details: {
+                    durationMs: Date.now() - startedAt,
+                    queueDepth: this.queue.length,
+                    activeCount: this.active.size,
+                    maxConcurrentJobs: this.maxConcurrentJobs
+                },
+                functionName: "runTask"
+            });
+        }
+        catch (error) {
+            this.recordLifecycleLog("error", "background_job_failed", {
+                task: next,
+                message: `Background job failed for ${next.label}.`,
+                details: {
+                    durationMs: Date.now() - startedAt,
+                    queueDepth: this.queue.length,
+                    activeCount: this.active.size,
+                    maxConcurrentJobs: this.maxConcurrentJobs,
+                    error
+                },
+                functionName: "runTask"
+            });
+            console.error(`[${this.name}] background job failed for ${next.label}:`, error);
+        }
+        finally {
+            this.active.delete(next.id);
+            this.scheduleDrain();
+        }
+    }
+    recordLifecycleLog(level, eventKey, input) {
+        try {
+            recordDiagnosticLog({
+                level,
+                source: "system",
+                scope: "background_job",
+                eventKey,
+                message: input.message,
+                functionName: input.functionName,
+                entityType: "background_job",
+                entityId: input.task.id,
+                jobId: input.task.id,
+                details: {
+                    label: input.task.label,
+                    ...(input.details ?? {})
+                }
+            });
+        }
+        catch {
+            // Diagnostics should never block job execution.
+        }
     }
 }

package/dist/server/managers/platform/llm-manager.js

@@ -0,0 +1,126 @@
+import { AbstractManager } from "../base.js";
+import { readEncryptedSecret } from "../../repositories/calendar.js";
+function emitDiagnostic(logger, input) {
+    logger?.(input);
+}
+export class LlmManager extends AbstractManager {
+    secretsManager;
+    name = "LlmManager";
+    providers = new Map();
+    constructor(secretsManager) {
+        super();
+        this.secretsManager = secretsManager;
+    }
+    register(provider) {
+        for (const alias of provider.providerNames) {
+            this.providers.set(alias, provider);
+        }
+    }
+    async compileWikiIngest(profile, input, options = {}, logger) {
+        const provider = this.resolveProvider(profile.provider);
+        if (!provider) {
+            emitDiagnostic(logger, {
+                level: "error",
+                message: "Wiki ingest LLM provider is not supported.",
+                details: {
+                    scope: "wiki_llm",
+                    eventKey: "llm_provider_missing",
+                    provider: profile.provider,
+                    baseUrl: profile.baseUrl,
+                    model: profile.model
+                }
+            });
+            return null;
+        }
+        const apiKey = this.readApiKey(profile.secretId);
+        if (!apiKey) {
+            emitDiagnostic(logger, {
+                level: "error",
+                message: "Wiki ingest LLM profile is missing an API key.",
+                details: {
+                    scope: "wiki_llm",
+                    eventKey: "llm_api_key_missing",
+                    provider: profile.provider,
+                    baseUrl: profile.baseUrl,
+                    model: profile.model,
+                    secretId: profile.secretId ?? null
+                }
+            });
+            return null;
+        }
+        return provider.compile({
+            apiKey,
+            profile,
+            input,
+            resumeResponseId: options.resumeResponseId ?? null,
+            logger
+        });
+    }
+    async testWikiConnection(profile, explicitApiKey, logger) {
+        const provider = this.resolveProvider(profile.provider);
+        if (!provider) {
+            emitDiagnostic(logger, {
+                level: "error",
+                message: "Wiki LLM connection test requested an unsupported provider.",
+                details: {
+                    scope: "wiki_llm",
+                    eventKey: "llm_provider_missing",
+                    provider: profile.provider,
+                    baseUrl: profile.baseUrl,
+                    model: profile.model
+                }
+            });
+            throw new Error("Unsupported LLM provider.");
+        }
+        const apiKey = explicitApiKey?.trim() || this.readApiKey(profile.secretId);
+        if (!apiKey) {
+            emitDiagnostic(logger, {
+                level: "error",
+                message: "Wiki LLM connection test is missing an API key.",
+                details: {
+                    scope: "wiki_llm",
+                    eventKey: "llm_api_key_missing",
+                    provider: profile.provider,
+                    baseUrl: profile.baseUrl,
+                    model: profile.model,
+                    secretId: profile.secretId ?? null
+                }
+            });
+            throw new Error("Save an OpenAI API key first.");
+        }
+        const result = await provider.testConnection({
+            apiKey,
+            profile,
+            logger
+        });
+        return {
+            provider: profile.provider,
+            model: profile.model,
+            baseUrl: profile.baseUrl,
+            reasoningEffort: typeof profile.metadata.reasoningEffort === "string"
+                ? profile.metadata.reasoningEffort
+                : null,
+            verbosity: typeof profile.metadata.verbosity === "string"
+                ? profile.metadata.verbosity
+                : null,
+            usingStoredKey: !explicitApiKey?.trim(),
+            outputPreview: result.outputPreview
+        };
+    }
+    resolveProvider(providerName) {
+        return (this.providers.get(providerName) ??
+            this.providers.get("openai-responses") ??
+            null);
+    }
+    readApiKey(secretId) {
+        if (!secretId) {
+            return null;
+        }
+        const cipherText = readEncryptedSecret(secretId);
+        if (!cipherText) {
+            return null;
+        }
+        const payload = this.secretsManager.openJson(cipherText);
+        return payload.apiKey?.trim() || null;
+    }
+}