mirror of
https://github.com/openclaw/openclaw.git
synced 2026-05-17 10:40:45 +00:00
526 lines
17 KiB
TypeScript
526 lines
17 KiB
TypeScript
import fs from "node:fs/promises";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { describe, expect, it } from "vitest";
|
|
import { resolveAgentWorkspaceDir } from "../../agents/agent-scope-config.js";
|
|
import type { OpenClawConfig } from "../../config/config.js";
|
|
import { resolveMemoryBackendConfig } from "./backend-config.js";
|
|
import { isQmdScopeAllowed } from "./qmd-scope.js";
|
|
|
|
type QmdPathFixture = {
|
|
path: string;
|
|
name?: string;
|
|
pattern?: string;
|
|
};
|
|
|
|
const resolveComparablePath = (value: string, workspaceDir = "/workspace/root"): string =>
|
|
path.isAbsolute(value) ? path.resolve(value) : path.resolve(workspaceDir, value);
|
|
|
|
function resolveCollectionNamesForAgent(cfg: OpenClawConfig, agentId: string): Set<string> {
|
|
return new Set(
|
|
(resolveMemoryBackendConfig({ cfg, agentId }).qmd?.collections ?? []).map(
|
|
(collection) => collection.name,
|
|
),
|
|
);
|
|
}
|
|
|
|
function resolveCustomCollectionPathsForAgent(cfg: OpenClawConfig, agentId: string): string[] {
|
|
return (resolveMemoryBackendConfig({ cfg, agentId }).qmd?.collections ?? [])
|
|
.filter((collection) => collection.kind === "custom")
|
|
.map((collection) => collection.path);
|
|
}
|
|
|
|
function qmdMultiAgentConfig(paths: QmdPathFixture[]) {
|
|
return {
|
|
agents: {
|
|
defaults: { workspace: "/workspace/root" },
|
|
list: [
|
|
{ id: "main", default: true, workspace: "/workspace/root" },
|
|
{ id: "dev", workspace: "/workspace/dev" },
|
|
],
|
|
},
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
includeDefaultMemory: true,
|
|
paths,
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
}
|
|
|
|
describe("resolveMemoryBackendConfig", () => {
|
|
it("defaults to builtin backend when config missing", () => {
|
|
const cfg = { agents: { defaults: { workspace: "/tmp/memory-test" } } } as OpenClawConfig;
|
|
const resolved = resolveMemoryBackendConfig({ cfg, agentId: "main" });
|
|
expect(resolved.backend).toBe("builtin");
|
|
expect(resolved.citations).toBe("auto");
|
|
expect(resolved.qmd).toBeUndefined();
|
|
});
|
|
|
|
it("resolves qmd backend with default collections", () => {
|
|
const cfg = {
|
|
agents: { defaults: { workspace: "/tmp/memory-test" } },
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {},
|
|
},
|
|
} as OpenClawConfig;
|
|
const resolved = resolveMemoryBackendConfig({ cfg, agentId: "main" });
|
|
expect(resolved.backend).toBe("qmd");
|
|
expect(resolved.qmd?.collections.length).toBe(2);
|
|
expect(resolved.qmd?.command).toBe("qmd");
|
|
expect(resolved.qmd?.searchMode).toBe("search");
|
|
expect(resolved.qmd?.update.intervalMs).toBeGreaterThan(0);
|
|
expect(resolved.qmd?.update.waitForBootSync).toBe(false);
|
|
expect(resolved.qmd?.update.commandTimeoutMs).toBe(30_000);
|
|
expect(resolved.qmd?.update.updateTimeoutMs).toBe(120_000);
|
|
expect(resolved.qmd?.update.embedTimeoutMs).toBe(120_000);
|
|
const names = new Set((resolved.qmd?.collections ?? []).map((collection) => collection.name));
|
|
expect(names.has("memory-root-main")).toBe(true);
|
|
expect(names.has("memory-dir-main")).toBe(true);
|
|
});
|
|
|
|
it("allows direct and channel sessions in the default qmd scope", () => {
|
|
const cfg = {
|
|
agents: { defaults: { workspace: "/tmp/memory-test" } },
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {},
|
|
},
|
|
} as OpenClawConfig;
|
|
const resolved = resolveMemoryBackendConfig({ cfg, agentId: "main" });
|
|
|
|
expect(isQmdScopeAllowed(resolved.qmd?.scope, "agent:main:discord:direct:user-123")).toBe(true);
|
|
expect(isQmdScopeAllowed(resolved.qmd?.scope, "agent:main:discord:channel:chan-123")).toBe(
|
|
true,
|
|
);
|
|
expect(isQmdScopeAllowed(resolved.qmd?.scope, "agent:main:discord:group:group-123")).toBe(
|
|
false,
|
|
);
|
|
});
|
|
|
|
it("parses quoted qmd command paths", () => {
|
|
const cfg = {
|
|
agents: { defaults: { workspace: "/tmp/memory-test" } },
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
command: '"/Applications/QMD Tools/qmd" --flag',
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const resolved = resolveMemoryBackendConfig({ cfg, agentId: "main" });
|
|
expect(resolved.qmd?.command).toBe("/Applications/QMD Tools/qmd");
|
|
});
|
|
|
|
it("preserves explicit homebrew qmd paths for service environments", () => {
|
|
const cfg = {
|
|
agents: { defaults: { workspace: "/tmp/memory-test" } },
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
command: "/opt/homebrew/bin/qmd",
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const resolved = resolveMemoryBackendConfig({ cfg, agentId: "main" });
|
|
expect(resolved.qmd?.command).toBe("/opt/homebrew/bin/qmd");
|
|
});
|
|
|
|
it("resolves custom paths relative to workspace", () => {
|
|
const cfg = {
|
|
agents: {
|
|
defaults: { workspace: "/workspace/root" },
|
|
list: [{ id: "main", workspace: "/workspace/root" }],
|
|
},
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
paths: [
|
|
{
|
|
path: "notes",
|
|
name: "custom-notes",
|
|
pattern: "**/*.md",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const resolved = resolveMemoryBackendConfig({ cfg, agentId: "main" });
|
|
const custom = resolved.qmd?.collections.find((c) => c.name.startsWith("custom-notes"));
|
|
expect(custom).toBeDefined();
|
|
const workspaceRoot = resolveAgentWorkspaceDir(cfg, "main");
|
|
expect(custom?.path).toBe(path.resolve(workspaceRoot, "notes"));
|
|
});
|
|
|
|
it("scopes qmd collection names per agent", () => {
|
|
const cfg = qmdMultiAgentConfig([{ path: "notes", name: "workspace", pattern: "**/*.md" }]);
|
|
const mainNames = resolveCollectionNamesForAgent(cfg, "main");
|
|
const devNames = resolveCollectionNamesForAgent(cfg, "dev");
|
|
expect(mainNames.has("memory-dir-main")).toBe(true);
|
|
expect(devNames.has("memory-dir-dev")).toBe(true);
|
|
expect(mainNames.has("workspace-main")).toBe(true);
|
|
expect(devNames.has("workspace-dev")).toBe(true);
|
|
});
|
|
|
|
it("merges default and per-agent qmd extra collections", () => {
|
|
const cfg = {
|
|
agents: {
|
|
defaults: {
|
|
workspace: "/workspace/root",
|
|
memorySearch: {
|
|
qmd: {
|
|
extraCollections: [
|
|
{
|
|
path: "/shared/team-notes",
|
|
name: "team-notes",
|
|
pattern: "**/*.md",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
list: [
|
|
{
|
|
id: "main",
|
|
default: true,
|
|
workspace: "/workspace/root",
|
|
memorySearch: {
|
|
qmd: {
|
|
extraCollections: [
|
|
{
|
|
path: "notes",
|
|
name: "notes",
|
|
pattern: "**/*.md",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
includeDefaultMemory: false,
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const names = resolveCollectionNamesForAgent(cfg, "main");
|
|
expect(names.has("team-notes")).toBe(true);
|
|
expect(names.has("notes-main")).toBe(true);
|
|
});
|
|
|
|
it("preserves explicit custom collection names for paths outside the workspace", () => {
|
|
const cfg = qmdMultiAgentConfig([
|
|
{ path: "/shared/notion-mirror", name: "notion-mirror", pattern: "**/*.md" },
|
|
]);
|
|
const mainNames = resolveCollectionNamesForAgent(cfg, "main");
|
|
const devNames = resolveCollectionNamesForAgent(cfg, "dev");
|
|
expect(mainNames.has("memory-dir-main")).toBe(true);
|
|
expect(devNames.has("memory-dir-dev")).toBe(true);
|
|
expect(mainNames.has("notion-mirror")).toBe(true);
|
|
expect(devNames.has("notion-mirror")).toBe(true);
|
|
});
|
|
|
|
it("keeps symlinked workspace paths agent-scoped when deciding custom collection names", async () => {
|
|
const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), "qmd-backend-config-"));
|
|
const workspaceDir = path.join(tmpRoot, "workspace");
|
|
const workspaceAliasDir = path.join(tmpRoot, "workspace-alias");
|
|
try {
|
|
await fs.mkdir(workspaceDir, { recursive: true });
|
|
await fs.symlink(workspaceDir, workspaceAliasDir);
|
|
const cfg = {
|
|
agents: {
|
|
defaults: { workspace: workspaceDir },
|
|
list: [{ id: "main", default: true, workspace: workspaceDir }],
|
|
},
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
includeDefaultMemory: false,
|
|
paths: [{ path: workspaceAliasDir, name: "workspace", pattern: "**/*.md" }],
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const names = resolveCollectionNamesForAgent(cfg, "main");
|
|
expect(names.has("workspace-main")).toBe(true);
|
|
expect(names.has("workspace")).toBe(false);
|
|
} finally {
|
|
await fs.rm(tmpRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("keeps unresolved child paths under a symlinked workspace agent-scoped", async () => {
|
|
const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), "qmd-backend-config-"));
|
|
const realRootDir = path.join(tmpRoot, "real-root");
|
|
const aliasRootDir = path.join(tmpRoot, "alias-root");
|
|
const workspaceDir = path.join(realRootDir, "workspace");
|
|
const workspaceAliasDir = path.join(aliasRootDir, "workspace");
|
|
try {
|
|
await fs.mkdir(workspaceDir, { recursive: true });
|
|
await fs.symlink(realRootDir, aliasRootDir);
|
|
const cfg = {
|
|
agents: {
|
|
defaults: { workspace: workspaceDir },
|
|
list: [{ id: "main", default: true, workspace: workspaceDir }],
|
|
},
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
includeDefaultMemory: false,
|
|
paths: [
|
|
{ path: path.join(workspaceAliasDir, "notes"), name: "notes", pattern: "**/*.md" },
|
|
],
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const names = resolveCollectionNamesForAgent(cfg, "main");
|
|
expect(names.has("notes-main")).toBe(true);
|
|
expect(names.has("notes")).toBe(false);
|
|
} finally {
|
|
await fs.rm(tmpRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("resolves qmd update timeout overrides", () => {
|
|
const cfg = {
|
|
agents: { defaults: { workspace: "/tmp/memory-test" } },
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
update: {
|
|
waitForBootSync: true,
|
|
commandTimeoutMs: 12_000,
|
|
updateTimeoutMs: 480_000,
|
|
embedTimeoutMs: 360_000,
|
|
},
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const resolved = resolveMemoryBackendConfig({ cfg, agentId: "main" });
|
|
expect(resolved.qmd?.update.waitForBootSync).toBe(true);
|
|
expect(resolved.qmd?.update.commandTimeoutMs).toBe(12_000);
|
|
expect(resolved.qmd?.update.updateTimeoutMs).toBe(480_000);
|
|
expect(resolved.qmd?.update.embedTimeoutMs).toBe(360_000);
|
|
});
|
|
|
|
it("resolves qmd search mode override", () => {
|
|
const cfg = {
|
|
agents: { defaults: { workspace: "/tmp/memory-test" } },
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
searchMode: "vsearch",
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const resolved = resolveMemoryBackendConfig({ cfg, agentId: "main" });
|
|
expect(resolved.qmd?.searchMode).toBe("vsearch");
|
|
});
|
|
|
|
it("resolves qmd mcporter search tool override", () => {
|
|
const cfg = {
|
|
agents: { defaults: { workspace: "/tmp/memory-test" } },
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
searchMode: "query",
|
|
searchTool: " hybrid_search ",
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const resolved = resolveMemoryBackendConfig({ cfg, agentId: "main" });
|
|
expect(resolved.qmd?.searchMode).toBe("query");
|
|
expect(resolved.qmd?.searchTool).toBe("hybrid_search");
|
|
});
|
|
});
|
|
|
|
describe("memorySearch.extraPaths integration", () => {
|
|
it("maps agents.defaults.memorySearch.extraPaths to QMD collections", () => {
|
|
const cfg = {
|
|
memory: { backend: "qmd" },
|
|
agents: {
|
|
defaults: {
|
|
workspace: "/workspace/root",
|
|
memorySearch: {
|
|
extraPaths: ["/home/user/docs", "/home/user/vault"],
|
|
},
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const result = resolveMemoryBackendConfig({ cfg, agentId: "test-agent" });
|
|
expect(result.backend).toBe("qmd");
|
|
const customCollections = (result.qmd?.collections ?? []).filter(
|
|
(collection) => collection.kind === "custom",
|
|
);
|
|
expect(customCollections.length).toBeGreaterThanOrEqual(2);
|
|
expect(customCollections.map((collection) => collection.path)).toEqual(
|
|
expect.arrayContaining([
|
|
resolveComparablePath("/home/user/docs"),
|
|
resolveComparablePath("/home/user/vault"),
|
|
]),
|
|
);
|
|
});
|
|
|
|
it("merges default and per-agent memorySearch.extraPaths for QMD collections", () => {
|
|
const cfg = {
|
|
memory: { backend: "qmd" },
|
|
agents: {
|
|
defaults: {
|
|
workspace: "/workspace/root",
|
|
memorySearch: {
|
|
extraPaths: ["/default/path"],
|
|
},
|
|
},
|
|
list: [
|
|
{
|
|
id: "my-agent",
|
|
memorySearch: {
|
|
extraPaths: ["/agent/specific/path"],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
} as OpenClawConfig;
|
|
const result = resolveMemoryBackendConfig({ cfg, agentId: "my-agent" });
|
|
expect(result.backend).toBe("qmd");
|
|
const paths = resolveCustomCollectionPathsForAgent(cfg, "my-agent");
|
|
expect(paths).toContain(resolveComparablePath("/agent/specific/path"));
|
|
expect(paths).toContain(resolveComparablePath("/default/path"));
|
|
});
|
|
|
|
it("falls back to defaults when agent has no overrides", () => {
|
|
const cfg = {
|
|
memory: { backend: "qmd" },
|
|
agents: {
|
|
defaults: {
|
|
workspace: "/workspace/root",
|
|
memorySearch: {
|
|
extraPaths: ["/default/path"],
|
|
},
|
|
},
|
|
list: [
|
|
{
|
|
id: "other-agent",
|
|
memorySearch: {
|
|
extraPaths: ["/other/path"],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
} as OpenClawConfig;
|
|
const result = resolveMemoryBackendConfig({ cfg, agentId: "my-agent" });
|
|
expect(result.backend).toBe("qmd");
|
|
const paths = resolveCustomCollectionPathsForAgent(cfg, "my-agent");
|
|
expect(paths).toContain(resolveComparablePath("/default/path"));
|
|
});
|
|
|
|
it("deduplicates merged memorySearch.extraPaths for QMD collections", () => {
|
|
const cfg = {
|
|
memory: { backend: "qmd" },
|
|
agents: {
|
|
defaults: {
|
|
workspace: "/workspace/root",
|
|
memorySearch: {
|
|
extraPaths: ["/shared/path", " /shared/path "],
|
|
},
|
|
},
|
|
list: [
|
|
{
|
|
id: "my-agent",
|
|
memorySearch: {
|
|
extraPaths: ["/shared/path", "/agent-only"],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
} as OpenClawConfig;
|
|
|
|
const paths = resolveCustomCollectionPathsForAgent(cfg, "my-agent");
|
|
|
|
expect(
|
|
paths.filter((collectionPath) => collectionPath === resolveComparablePath("/shared/path")),
|
|
).toHaveLength(1);
|
|
expect(paths).toContain(resolveComparablePath("/agent-only"));
|
|
});
|
|
|
|
it("keeps unnamed extra paths agent-scoped even when they resolve outside the workspace", () => {
|
|
const cfg = {
|
|
memory: { backend: "qmd" },
|
|
agents: {
|
|
defaults: {
|
|
workspace: "/workspace/root",
|
|
memorySearch: {
|
|
extraPaths: ["/shared/path"],
|
|
},
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
const result = resolveMemoryBackendConfig({ cfg, agentId: "my-agent" });
|
|
const customCollections = (result.qmd?.collections ?? []).filter(
|
|
(collection) => collection.kind === "custom",
|
|
);
|
|
expect(customCollections.map((collection) => collection.name)).toContain("custom-1-my-agent");
|
|
});
|
|
|
|
it("matches per-agent memorySearch.extraPaths using normalized agent ids", () => {
|
|
const cfg = {
|
|
memory: { backend: "qmd" },
|
|
agents: {
|
|
defaults: {
|
|
workspace: "/workspace/root",
|
|
},
|
|
list: [
|
|
{
|
|
id: "My-Agent",
|
|
memorySearch: {
|
|
extraPaths: ["/agent/mixed-case"],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
} as OpenClawConfig;
|
|
|
|
const result = resolveMemoryBackendConfig({ cfg, agentId: "my-agent" });
|
|
const customCollections = (result.qmd?.collections ?? []).filter(
|
|
(collection) => collection.kind === "custom",
|
|
);
|
|
|
|
expect(customCollections.map((collection) => collection.path)).toContain(
|
|
resolveComparablePath("/agent/mixed-case"),
|
|
);
|
|
});
|
|
|
|
it("deduplicates identical roots shared by memory.qmd.paths and memorySearch.extraPaths", () => {
|
|
const cfg = {
|
|
memory: {
|
|
backend: "qmd",
|
|
qmd: {
|
|
paths: [{ path: "docs", pattern: "**/*.md", name: "workspace-docs" }],
|
|
},
|
|
},
|
|
agents: {
|
|
defaults: {
|
|
workspace: "/workspace/root",
|
|
memorySearch: {
|
|
extraPaths: ["./docs"],
|
|
},
|
|
},
|
|
},
|
|
} as OpenClawConfig;
|
|
|
|
const result = resolveMemoryBackendConfig({ cfg, agentId: "main" });
|
|
const customCollections = (result.qmd?.collections ?? []).filter(
|
|
(collection) => collection.kind === "custom",
|
|
);
|
|
const docsCollections = customCollections.filter(
|
|
(collection) =>
|
|
collection.path === resolveComparablePath("./docs") && collection.pattern === "**/*.md",
|
|
);
|
|
|
|
expect(docsCollections).toHaveLength(1);
|
|
});
|
|
});
|