forge-openclaw-plugin 0.2.26 → 0.2.28

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

@@ -4,6 +4,9 @@ import { readEncryptedSecret, storeEncryptedSecret } from "../../repositories/ca
 function emitDiagnostic(logger, input) {
     logger?.(input);
 }
+function providerAllowsCredentiallessPrompt(provider) {
+    return provider === "mock";
+}
 export class LlmManager extends AbstractManager {
     secretsManager;
     name = "LlmManager";
@@ -74,7 +77,7 @@ export class LlmManager extends AbstractManager {
             throw new Error("Unsupported LLM provider.");
         }
         const apiKey = explicitApiKey?.trim() || (await this.readApiKey(profile.secretId));
-        if (!apiKey) {
+        if (!apiKey && !providerAllowsCredentiallessPrompt(profile.provider)) {
             emitDiagnostic(logger, {
                 level: "error",
                 message: "Wiki LLM connection test is missing an API key.",
@@ -90,7 +93,7 @@ export class LlmManager extends AbstractManager {
             throw new Error("Save an OpenAI API key first.");
         }
         const result = await provider.testConnection({
-            apiKey,
+            apiKey: apiKey ?? "mock",
             profile,
             logger
         });
@@ -114,11 +117,11 @@ export class LlmManager extends AbstractManager {
             throw new Error("This LLM provider does not support text prompt execution.");
         }
         const apiKey = input.explicitApiKey?.trim() || (await this.readApiKey(profile.secretId));
-        if (!apiKey) {
+        if (!apiKey && !providerAllowsCredentiallessPrompt(profile.provider)) {
             throw new Error("Missing provider credential for prompt execution.");
         }
         return await provider.runText({
-            apiKey,
+            apiKey: apiKey ?? "mock",
             profile,
             systemPrompt: input.systemPrompt,
             prompt: input.prompt,

package/dist/server/server/src/managers/platform/mock-workbench-provider.js

@@ -0,0 +1,149 @@
+function emit(logger, level, message, details) {
+    logger?.({ level, message, details });
+}
+function extractSection(prompt, label) {
+    const match = prompt.match(new RegExp(`${label}:\\n([\\s\\S]*?)(?:\\n\\n[A-Z][^\\n]*:|$)`));
+    return match?.[1]?.trim() ?? "";
+}
+function hasToolTranscript(prompt) {
+    return prompt.includes("Tool transcript:");
+}
+function hasConversationHistory(prompt) {
+    return prompt.includes("Conversation history:");
+}
+function resolveFixture(model) {
+    const normalized = model.trim().toLowerCase();
+    if (!normalized || normalized === "mock") {
+        return "mock-echo";
+    }
+    return normalized;
+}
+function buildEchoJson(prompt) {
+    const userInput = extractSection(prompt, "User input");
+    const linkedInputs = extractSection(prompt, "Linked inputs");
+    const answer = linkedInputs
+        ? `Mock consumed linked inputs${userInput ? ` and user input "${userInput}".` : "."}`
+        : userInput || "Mock workflow completed.";
+    return JSON.stringify({
+        answer,
+        summary: linkedInputs
+            ? `Mock consumed linked inputs and user input "${userInput || "none"}".`
+            : `Mock consumed user input "${userInput || "none"}".`,
+        linkedInputs: linkedInputs || null
+    });
+}
+export class MockWorkbenchProvider {
+    providerNames = ["mock"];
+    async compile(input) {
+        emit(input.logger, "info", "Running mock wiki compile.", {
+            model: input.profile.model
+        });
+        return {
+            title: input.input.titleHint || "Mock page",
+            summary: "Mock wiki compile output.",
+            markdown: input.input.rawText || "# Mock page",
+            tags: ["mock"],
+            entityProposals: [],
+            pageUpdateSuggestions: [],
+            articleCandidates: []
+        };
+    }
+    async testConnection(input) {
+        emit(input.logger, "info", "Testing mock workbench connection.", {
+            model: input.profile.model
+        });
+        return {
+            outputPreview: `Mock provider ready (${resolveFixture(input.profile.model)}).`
+        };
+    }
+    async runText(input) {
+        const fixture = resolveFixture(input.profile.model);
+        emit(input.logger, "debug", "Running mock workbench prompt.", {
+            fixture
+        });
+        if (fixture === "mock-fail") {
+            throw new Error("Mock provider forced a failure for this run.");
+        }
+        if (fixture === "mock-malformed") {
+            return { outputText: "{mock:" };
+        }
+        if (fixture === "mock-tool-search") {
+            if (!hasToolTranscript(input.prompt)) {
+                return {
+                    outputText: JSON.stringify({
+                        action: "tool",
+                        tool: "forge.search_entities",
+                        args: {
+                            query: "missed habits",
+                            entityTypes: ["habit"],
+                            limit: 6
+                        }
+                    })
+                };
+            }
+            return {
+                outputText: JSON.stringify({
+                    action: "final",
+                    text: JSON.stringify({
+                        answer: "Found missed habits and summarized them.",
+                        summary: "Found missed habits and summarized them.",
+                        missedHabits: [{ id: "habit_mock_1", title: "Morning mobility" }]
+                    })
+                })
+            };
+        }
+        if (fixture === "mock-tool-note") {
+            if (!hasToolTranscript(input.prompt)) {
+                return {
+                    outputText: JSON.stringify({
+                        action: "tool",
+                        tool: "forge.create_note",
+                        args: {
+                            title: "Mock note",
+                            summary: "Created by mock provider",
+                            markdown: "Mock workbench note"
+                        }
+                    })
+                };
+            }
+            return {
+                outputText: JSON.stringify({
+                    action: "final",
+                    text: JSON.stringify({
+                        answer: "Created a mock note.",
+                        summary: "Created a mock note.",
+                        noteStatus: "created"
+                    })
+                })
+            };
+        }
+        if (fixture === "mock-chat-memory") {
+            const userInput = extractSection(input.prompt, "User input");
+            return {
+                outputText: JSON.stringify({
+                    answer: hasConversationHistory(input.prompt)
+                        ? `I remember our earlier exchange and your latest message: ${userInput || "none"}.`
+                        : `Starting a fresh conversation with: ${userInput || "none"}.`,
+                    summary: hasConversationHistory(input.prompt)
+                        ? "Mock chat reused prior conversation history."
+                        : "Mock chat started fresh."
+                })
+            };
+        }
+        if (fixture === "mock-json") {
+            return {
+                outputText: JSON.stringify({
+                    answer: "Mock JSON output.",
+                    summary: "Mock JSON output.",
+                    payload: {
+                        ok: true,
+                        fixture
+                    }
+                })
+            };
+        }
+        return {
+            outputText: buildEchoJson(input.prompt)
+        };
+    }
+}

package/dist/server/server/src/managers/platform/secrets-manager.js

@@ -24,6 +24,23 @@ export class SecretsManager extends AbstractManager {
         }
         return timingSafeEqual(leftBuffer, rightBuffer);
     }
+    getCanonicalKeyPath() {
+        return path.join(this.rootDir, ".forge-secrets.key");
+    }
+    getLegacyKeyPath() {
+        return path.join(this.rootDir, "data", ".forge-secrets.key");
+    }
+    getPreferredKeyPath() {
+        const canonicalKeyPath = this.getCanonicalKeyPath();
+        if (existsSync(canonicalKeyPath)) {
+            return canonicalKeyPath;
+        }
+        const legacyKeyPath = this.getLegacyKeyPath();
+        if (existsSync(legacyKeyPath)) {
+            return legacyKeyPath;
+        }
+        return canonicalKeyPath;
+    }
     sealJson(value) {
         const iv = randomBytes(12);
         const cipher = createCipheriv("aes-256-gcm", this.getEncryptionKey(), iv);
@@ -49,7 +66,7 @@ export class SecretsManager extends AbstractManager {
         if (this.cachedKey) {
             return this.cachedKey;
         }
-        const keyPath = path.join(this.rootDir, "data", ".forge-secrets.key");
+        const keyPath = this.getPreferredKeyPath();
         mkdirSync(path.dirname(keyPath), { recursive: true });
         if (!existsSync(keyPath)) {
             writeFileSync(keyPath, randomBytes(32).toString("base64"), { encoding: "utf8", mode: 0o600 });

package/dist/server/server/src/managers/runtime.js

@@ -17,6 +17,12 @@ import { ExternalServiceManager } from "./platform/external-service-manager.js";
 import { SearchIndexManager } from "./platform/search-index-manager.js";
 import { LlmManager } from "./platform/llm-manager.js";
 import { OpenAiResponsesProvider } from "./platform/openai-responses-provider.js";
+import { MockWorkbenchProvider } from "./platform/mock-workbench-provider.js";
+function shouldEnableMockWorkbenchProvider(env = process.env) {
+    return (env.NODE_ENV === "test" ||
+        env.FORGE_ENABLE_DEV_MOCKS === "1" ||
+        env.FORGE_OPENCLAW_DEV === "1");
+}
 export function createManagerRuntime(options = {}) {
     const configuration = new ConfigurationManager();
     const runtimeConfig = configuration.readRuntimeConfig({ dataRoot: options.dataRoot });
@@ -40,6 +46,9 @@ export function createManagerRuntime(options = {}) {
     const searchIndex = new SearchIndexManager();
     const llm = new LlmManager(secrets);
     llm.register(new OpenAiResponsesProvider());
+    if (shouldEnableMockWorkbenchProvider()) {
+        llm.register(new MockWorkbenchProvider());
+    }
     return {
         configuration,
         secrets,