An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
import * as assert from "node:assert/strict";
import {readFileSync} from "node:fs";
import {test} from "node:test";
import {runInNewContext} from "node:vm";
import {ModuleKind, ScriptTarget, transpileModule} from "typescript";
import {flushSettingSaves, trackSettingSave} from "../../config/setting/pending";
import {mergeRecordByDottedPath} from "../../config/util/dotPath";
for (const type of ["global", "local", "pin"]) {
test(`reset flushes the latest delayed graph settings before acknowledging (${type})`, async () => {
const timers = new Map<number, () => void>();
const writes: Array<{type: string, conf: {dailyNote: boolean}}> = [];
let timerID = 0;
let release: () => void;
const request = new Promise<void>(resolve => { release = resolve; });
const exports = {} as typeof import("./Graph");
const code = transpileModule(readFileSync("src/layout/dock/Graph.ts", "utf8"), {
compilerOptions: {module: ModuleKind.CommonJS, target: ScriptTarget.ES2021},
}).outputText;
const runtimeWindow = {
siyuan: {config: {graph: {}}},
setTimeout: (callback: () => void) => { timers.set(++timerID, callback); return timerID; },
clearTimeout: (id: number) => timers.delete(id),
};
let requestStarted: () => void;
const started = new Promise<void>(resolve => { requestStarted = resolve; });
const configExports = {} as typeof import("../../config/util/configApi");
runInNewContext(transpileModule(readFileSync("src/config/util/configApi.ts", "utf8"), {
compilerOptions: {module: ModuleKind.CommonJS, target: ScriptTarget.ES2021},
}).outputText, {
exports: configExports, window: runtimeWindow,
require: (name: string) => {
if (name === "../../util/fetch") return {fetchSyncPost: (url: string, data: typeof writes[number]) => {
assert.equal(url, "/api/graph/setGraphConf");
writes.push(data);
requestStarted();
return request.then(() => ({code: 0}));
}};
if (name === "./dotPath") return {mergeRecordByDottedPath};
if (name === "../setting/pending") return {trackSettingSave};
if (name === "../setting/sync") return {
refreshSettingConfigAfter: async (namespace: string, save: () => Promise<boolean>) => {
assert.equal(namespace, "graph");
return save();
},
};
throw new Error("Unexpected config fixture module: " + name);
},
});
const unusedModules = new Set(["./panelSearch", "../Tab", "../util", "../tabUtil", "../../block/Panel",
"../../protyle/breadcrumb/action", "../../util/fetch", "../../editor/util",
"../../protyle/util/compatibility", "../../search/util", "../../util/noRelyPCFunction",
"../../editor", "../../util/pathName", "./graph/GraphEngine", "../../protyle/header/documentMenu",
"../../constants"]);
runInNewContext(code, {
exports, window: runtimeWindow,
require: (name: string) => {
if (name === "../Model") return {Model: class {}};
if (name === "../../config/util/configApi") return configExports;
assert.ok(unusedModules.has(name), "Unexpected graph fixture module: " + name);
return new Proxy({}, {get: (_target, key) => {
throw new Error(`Unexpected graph fixture dependency: ${name}.${String(key)}`);
}});
},
});
let conf = {dailyNote: false};
const graph = Object.assign(Object.create(exports.Graph.prototype), {
type, getGraphConf: () => conf, onGraph() {},
});
graph.updateGraphOptions();
conf = {dailyNote: true};
graph.updateGraphOptions();
assert.equal(writes.length, 0);
assert.equal(timers.size, 1);
graph.scheduleGraphSearch();
const resume = graph.suspendSettingsSaving();
assert.equal(timers.size, 0);
await started;
assert.equal(writes.length, 1);
assert.equal(writes[0].type, type === "global" ? "global" : "local");
assert.deepEqual(JSON.parse(JSON.stringify(writes[0].conf)), conf);
assert.notEqual(writes[0].conf, conf, "queued configuration is copied before saving");
graph.searchGraph();
assert.equal(writes.length, 1);
let flushed = false;
const flush = flushSettingSaves().then(() => { flushed = true; });
await Promise.resolve();
await Promise.resolve();
assert.equal(flushed, false);
release();
await flush;
graph.flushPendingSettings();
assert.equal(writes.length, 1);
let refreshed = false;
graph.searchGraph = () => { refreshed = true; };
resume();
assert.equal(refreshed, true);
assert.equal(graph.settingsSavingSuspended, false);
});
}
const createMenuGraph = (restricted = false) => {
const exports = {} as typeof import("./Graph");
const listeners = new Map<string, Set<() => void>>();
const requests: Array<{url: string, body: unknown}> = [];
const menus: Parameters<typeof import("../../protyle/header/documentMenu").openDocumentMenu>[0][] = [];
const positions: IPosition[] = [];
const engineOptions: import("./graph/types").IGraphEngineOptions[] = [];
let removedMenus = 0;
runInNewContext(transpileModule(readFileSync("src/layout/dock/Graph.ts", "utf8"), {
compilerOptions: {module: ModuleKind.CommonJS, target: ScriptTarget.ES2021},
}).outputText, {
exports, AbortController,
require: (name: string) => {
if (name === "../Model") { return {Model: class {}}; }
if (name === "./graph/GraphEngine") { return {GraphEngine: class {
constructor(_target: unknown, options: typeof engineOptions[number]) { engineOptions.push(options); }
}}; }
if (name === "../../constants") { return {Constants: {
CUSTOM_SY_SUBDOC_SORT_MODE: "custom-sy-subdoc-sort-mode", CUSTOM_SY_READONLY: "custom-sy-readonly"}}; }
if (name === "../../protyle/header/documentMenu") { return {
openDocumentMenu: (options: typeof menus[number]) => {
menus.push(options);
positions.push(options.position);
}}; }
if (name === "../../util/fetch") { return {
fetchSyncPost: (url: string, body: unknown) => {
requests.push({url, body});
if (url.endsWith("getBlockInfo")) {
return Promise.resolve({code: 0, data: restricted ? {publishAccessRequired: true} :
{box: "notebook", path: "/parent/doc.sy"}});
}
if (url.endsWith("getDocInfo")) {
return Promise.resolve({code: 0, data: {rootID: "doc", name: "Document", subFileCount: 2,
ial: {"custom-sy-subdoc-sort-mode": "0", "custom-sy-readonly": "true"}}});
}
throw new Error("Unexpected graph menu request: " + url);
}}; }
return {};
},
document: {
addEventListener: (name: string, listener: () => void) => {
if (!listeners.has(name)) { listeners.set(name, new Set()); }
listeners.get(name).add(listener);
},
removeEventListener: (name: string, listener: () => void) => listeners.get(name)?.delete(listener),
},
window: {siyuan: {menus: {menu: {remove() { removedMenus++; }}}, config: {editor: {readOnly: false}}}},
});
const graph = Object.assign(Object.create(exports.Graph.prototype), {
app: {}, menuRequestVersion: 0, graphElement: {isConnected: true, querySelectorAll: (): HTMLElement[] => []},
});
return {graph, listeners, requests, menus, positions, engineOptions, removedMenus: () => removedMenus};
};
test("graph interaction explicitly closes the shared menu", () => {
const {graph, engineOptions, removedMenus} = createMenuGraph();
graph.ensureGraphEngine();
engineOptions[0].onPointerDown();
assert.equal(removedMenus(), 1);
});
test("graph document menu uses current metadata independently of the document tree display limit", async () => {
const {graph, menus, positions, requests, listeners} = createMenuGraph();
const pending = graph.openGraphNodeMenu({node: {id: "doc", path: "/stale/doc.sy"}, x: 80, y: 100});
await pending;
assert.equal(menus.length, 1);
assert.equal(menus[0].path, "/parent/doc.sy");
assert.equal(menus[0].disabled, true);
assert.equal(menus[0].from, "graph");
assert.equal(menus[0].protyle, undefined);
assert.equal(menus[0].docInfo.name, "Document");
assert.equal(JSON.stringify(positions), '[{"x":80,"y":100}]');
assert.equal(requests.length, 2);
assert.equal(listeners.get("pointerdown").size, 0);
assert.equal(listeners.get("keydown").size, 0);
});
for (const event of ["pointerdown", "keydown"]) {
test(`graph menu requests are discarded after ${event}`, async () => {
const {graph, menus, listeners} = createMenuGraph();
const pending = graph.openGraphNodeMenu({node: {id: "doc"}, x: 0, y: 0});
listeners.get(event).forEach(listener => listener());
await pending;
assert.equal(menus.length, 0);
assert.equal(listeners.get(event).size, 0);
});
}
test("graph menu does not act on restricted document metadata", async () => {
const {graph, requests, menus} = createMenuGraph(true);
await graph.openGraphNodeMenu({node: {id: "doc"}, x: 0, y: 0});
assert.equal(menus.length, 0);
assert.equal(requests.length, 2);
});