277 lines
14 KiB
JavaScript
277 lines
14 KiB
JavaScript
"use strict";
|
|
const assert = require("node:assert/strict");
|
|
const fs = require("node:fs");
|
|
const os = require("node:os");
|
|
const path = require("node:path");
|
|
const { execFileSync } = require("node:child_process");
|
|
const test = require("node:test");
|
|
const {
|
|
createServer, loadAnchor, loadMap, loadNodeMap, loadSubjectRegistry, loadSubjectAliasMap, loadNavigationMap,
|
|
loadFileSnapshot, GitSnapshotStore, compileWarmEntry,
|
|
resolveSubjectId, compileNavigation, search, searchAll,
|
|
} = require("./server");
|
|
|
|
function warmRuntimeStatus(overrides = {}) {
|
|
return {
|
|
node: "JD-FD-PRIMARY",
|
|
persona_id: "ICE-P-ZY001",
|
|
runtime_id: "ZY-TCS-BRAIN-RUNTIME-0001",
|
|
phase: "RUNNING_COMPANION",
|
|
completed_cycles: 1,
|
|
receipt_id: "ZY-BRAIN-RUNTIME-TEST",
|
|
language_world_entry_bound: 100,
|
|
chu_he_han_jie_boundary_bound: 100,
|
|
persona_cycle_language_world_entry_bound: 100,
|
|
persona_cycle_chu_he_han_jie_boundary_bound: 100,
|
|
persona_brain_runtime_exists: 100,
|
|
living_ai_system_controller_running: 100,
|
|
machine_navigation_bound: 100,
|
|
language_world_route_first: 100,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
test("warm entry reuses only a fully verified resident companion", () => {
|
|
assert.equal(compileWarmEntry(warmRuntimeStatus()).status, "WARM_RESUME_READY");
|
|
assert.equal(
|
|
compileWarmEntry(warmRuntimeStatus({ persona_brain_runtime_exists: 0 })).status,
|
|
"FULL_CYCLE_REQUIRED",
|
|
);
|
|
assert.equal(
|
|
compileWarmEntry(warmRuntimeStatus({ phase: "RUNNING_CYCLE" })).status,
|
|
"FULL_CYCLE_REQUIRED",
|
|
);
|
|
});
|
|
|
|
test("canonical anchor binds every local map to one language-world entry", () => {
|
|
const snapshot = loadFileSnapshot();
|
|
assert.equal(snapshot.anchor.anchor_id, "GLW-PUBLIC-NAV-ANCHOR-001");
|
|
assert.equal(snapshot.anchor.entry_path.path_id, "LL-CMPN-0001");
|
|
assert.equal(snapshot.anchor.entry_path.world_node_id, "SYS-GLW-0001");
|
|
assert.equal(snapshot.anchor.entry_path.persona_id, "ICE-P-ZY001");
|
|
assert.equal(snapshot.anchor.entry_path.runtime_id, "ZY-TCS-BRAIN-RUNTIME-0001");
|
|
assert.equal(snapshot.navigation.map_id, loadAnchor().maps.navigation.id);
|
|
});
|
|
|
|
test("Git snapshot store follows main atomically and retains the last known-good snapshot", () => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), "guanghu-nav-"));
|
|
try {
|
|
execFileSync("git", ["init", "-q", "-b", "main", root]);
|
|
execFileSync("git", ["-C", root, "config", "user.name", "test"]);
|
|
execFileSync("git", ["-C", root, "config", "user.email", "test@example.invalid"]);
|
|
const declarations = {
|
|
repository: ["routing/repository-route-map.json", "FD-REPO-MAP-001"],
|
|
nodes: ["routing/server-node-map.json", "FD-NODE-MAP-001"],
|
|
subjects: ["identity/fifth-domain-subject-registry.json", "FD-SUBJECT-REGISTRY-001"],
|
|
aliases: ["identity/subject-id-alias-map.json", "FD-SUBJECT-ID-ALIAS-MAP-001"],
|
|
navigation: ["routing/ai-machine-navigation-map.json", "AI-MACHINE-NAV-001"],
|
|
};
|
|
fs.mkdirSync(path.join(root, "routing"), { recursive: true });
|
|
fs.mkdirSync(path.join(root, "identity"), { recursive: true });
|
|
const anchor = {
|
|
schema: "guanghu.public-navigation-anchor/v1",
|
|
anchor_id: "GLW-PUBLIC-NAV-ANCHOR-001",
|
|
version: "test.1",
|
|
repository_id: "REPO-012",
|
|
branch: "main",
|
|
entry_path: { path_id: "LL-CMPN-0001", world_node_id: "SYS-GLW-0001" },
|
|
maps: {},
|
|
};
|
|
for (const [key, [relative, id]] of Object.entries(declarations)) {
|
|
anchor.maps[key] = { path: relative, id, version: "1" };
|
|
const idKey = key === "subjects" ? "registry_id" : "map_id";
|
|
fs.writeFileSync(path.join(root, relative), JSON.stringify({ [idKey]: id, version: "1" }));
|
|
}
|
|
fs.writeFileSync(path.join(root, "routing/public-navigation-anchor.json"), JSON.stringify(anchor));
|
|
execFileSync("git", ["-C", root, "add", "."]);
|
|
execFileSync("git", ["-C", root, "commit", "-qm", "valid snapshot"]);
|
|
const store = new GitSnapshotStore(path.join(root, ".git"));
|
|
const first = store.get();
|
|
assert.equal(first.anchor.version, "test.1");
|
|
assert.equal(first.source_degraded, false);
|
|
anchor.maps.navigation.version = "2";
|
|
fs.writeFileSync(path.join(root, "routing/public-navigation-anchor.json"), JSON.stringify(anchor));
|
|
execFileSync("git", ["-C", root, "add", "."]);
|
|
execFileSync("git", ["-C", root, "commit", "-qm", "invalid snapshot"]);
|
|
const fallback = store.get();
|
|
assert.equal(fallback.source_commit, first.source_commit);
|
|
assert.equal(fallback.source_degraded, true);
|
|
assert.match(fallback.source_error, /snapshot_map_version_mismatch:navigation/);
|
|
} finally {
|
|
fs.rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("repository map exposes only the three current code-channel repositories", () => {
|
|
const map = loadMap();
|
|
const expectedCodes = ["REPO-012", "REPO-014", "REPO-015"];
|
|
assert.deepEqual(map.repositories.map(item => item.code), expectedCodes);
|
|
assert.equal(new Set(map.repositories.map(item => item.code)).size, expectedCodes.length);
|
|
for (const item of map.repositories) {
|
|
assert.match(item.primary.url, /^https:\/\/guanghulab\.com\/code\//);
|
|
}
|
|
assert.equal(map.historical_repositories.length, 11);
|
|
assert.ok(map.historical_repositories.slice(0, 8).every(item => item.state.includes("HISTORICAL")));
|
|
assert.deepEqual(
|
|
map.historical_repositories.slice(8).map(item => [item.code, item.state]),
|
|
[
|
|
["REPO-009", "CURRENT_PRIVATE_PERSONA_HISTORY_AND_DAILY_ROLE_MEMORY_PENDING_DEPLOYMENT"],
|
|
["REPO-010", "CURRENT_PRIVATE_PERSONA_HISTORY_AND_DAILY_ROLE_MEMORY_PENDING_DEPLOYMENT"],
|
|
["REPO-011", "CURRENT_PRIVATE_PERSONA_HISTORY_AND_DAILY_ROLE_MEMORY_PENDING_DEPLOYMENT"],
|
|
],
|
|
);
|
|
});
|
|
|
|
test("Chinese language-world query resolves the Fifth Domain primary", () => {
|
|
const results = search(loadMap(), "光湖语言世界 第五域");
|
|
assert.equal(results[0].code, "REPO-012");
|
|
assert.equal(results[0].state, "CURRENT_FIFTH_DOMAIN_ENTRY");
|
|
});
|
|
|
|
test("Chenglu legacy identity does not resolve as a current repository", () => {
|
|
const results = search(loadMap(), "澄路 常驻人格体 湖心频道");
|
|
assert.equal(results.length, 0);
|
|
});
|
|
|
|
test("Kezhou and Guideng legacy identities do not resolve as current repositories", () => {
|
|
assert.equal(search(loadMap(), "刻舟 湖心频道").length, 0);
|
|
assert.equal(search(loadMap(), "归灯 每日心跳").length, 0);
|
|
});
|
|
|
|
test("server node map binds Zhuyuan routes to the domestic primary", () => {
|
|
const map = loadNodeMap();
|
|
assert.equal(map.map_id, "FD-NODE-MAP-001");
|
|
assert.equal(map.default_node, "JD-FD-PRIMARY");
|
|
const node = map.nodes.find(item => item.node_id === "JD-FD-PRIMARY");
|
|
assert.ok(node.persona_systems.includes("ICE-P-ZY001"));
|
|
const loop = map.persona_routes.find(item => item.route_id === "ZY-OPS-LOOP-001");
|
|
assert.equal(loop.primary_node, "JD-FD-PRIMARY");
|
|
assert.match(loop.path, /zhuyuan-persona-system/);
|
|
const serialized = JSON.stringify(map);
|
|
assert.doesNotMatch(serialized, /ssh-(?:rsa|ed25519)\s+[A-Za-z0-9+/]/i);
|
|
assert.doesNotMatch(serialized, /"(?:password|token|private_key|ip)"\s*:/i);
|
|
assert.doesNotMatch(serialized, /\b(?:\d{1,3}\.){3}\d{1,3}\b/);
|
|
});
|
|
|
|
test("Zhuyuan Chinese query returns the numbered operation loop", () => {
|
|
const results = searchAll(loadMap(), loadNodeMap(), "铸渊 双向意识 思维逻辑链");
|
|
assert.equal(results[0].kind, "persona_route");
|
|
assert.equal(results[0].route_id, "ZY-OPS-LOOP-001");
|
|
});
|
|
|
|
test("legacy Zhuyuan ids canonicalize before navigation", () => {
|
|
const aliases = loadSubjectAliasMap();
|
|
for (const legacyId of ["ICE-GL-ZY001", "ICE-PZY-001"]) {
|
|
const resolved = resolveSubjectId(aliases, legacyId);
|
|
assert.equal(resolved.canonical_id, "ICE-P-ZY001");
|
|
assert.equal(resolved.redirected, true);
|
|
assert.equal(resolved.route_id, "FD-PERSONA-LOGIN-001");
|
|
}
|
|
assert.equal(resolveSubjectId(aliases, "ICE-P-ZY001").redirected, false);
|
|
});
|
|
|
|
test("human ids remain human and conflicted persona ids fail closed", () => {
|
|
const aliases = loadSubjectAliasMap();
|
|
assert.equal(resolveSubjectId(aliases, "ICE-GL∞").status, "NOT_FOUND_NO_GUESS");
|
|
assert.equal(resolveSubjectId(aliases, "ICE-PCA-001").status, "CONFLICT_REJECTED");
|
|
});
|
|
|
|
test("searching the old id returns the canonical subject", () => {
|
|
const results = searchAll(loadMap(), loadNodeMap(), "ICE-GL-ZY001", loadSubjectRegistry());
|
|
const subject = results.find(item => item.kind === "subject");
|
|
assert.equal(subject.id, "ICE-P-ZY001");
|
|
assert.ok(subject.legacy_ids.includes("ICE-GL-ZY001"));
|
|
});
|
|
|
|
test("machine navigator compiles an exact minimal Zhuyuan runtime bundle", () => {
|
|
const compiled = compileNavigation(
|
|
loadNavigationMap(),
|
|
"ICE-GL-ZY001",
|
|
"persona_restore",
|
|
"context_compacted,protocol_drift,context_compacted",
|
|
);
|
|
assert.equal(compiled.status, 200);
|
|
assert.equal(compiled.body.canonical_subject, "ICE-P-ZY001");
|
|
assert.equal(compiled.body.redirected, true);
|
|
assert.equal(compiled.body.runtime_entry.id, "ZY-TCS-BRAIN-RUNTIME-0001");
|
|
assert.deepEqual(compiled.body.explicit_signals, ["context_compacted", "protocol_drift"]);
|
|
assert.ok(compiled.body.always_load.some(item => item.id === "BS-TCS-SYSTEM-CONTROLLER-MAP-001"));
|
|
assert.equal(compiled.body.always_load[0].id, "GLW-CHJH-BOUNDARY-001");
|
|
assert.deepEqual(
|
|
compiled.body.execution_sequence.slice(0, 2),
|
|
["validate_language_world_entry", "bind_chu_he_han_jie_boundary"],
|
|
);
|
|
assert.ok(compiled.body.triggered_load.some(item => item.id === "BS-TCS-PROTOCOL-EVENT-TRIGGER-MAP-001"));
|
|
assert.equal(compiled.body.authority, "NONE_NAVIGATION_ONLY");
|
|
assert.ok(compiled.body.always_load.length < loadNavigationMap().routes.length);
|
|
});
|
|
|
|
test("machine navigator fails closed instead of guessing", () => {
|
|
assert.equal(compileNavigation(loadNavigationMap(), "some-ai", "persona_restore").body.error, "unknown_subject_no_guess");
|
|
assert.equal(compileNavigation(loadNavigationMap(), "ICE-P-ZY001", "please_guess").body.error, "unknown_intent_no_guess");
|
|
});
|
|
|
|
test("public endpoints are read-only and expose CORS", async () => {
|
|
const server = createServer({ runtimeStatusProvider: async () => warmRuntimeStatus() });
|
|
await new Promise(resolve => server.listen(0, "127.0.0.1", resolve));
|
|
const base = `http://127.0.0.1:${server.address().port}`;
|
|
try {
|
|
const response = await fetch(`${base}/v1/resolve?id=REPO-004`);
|
|
assert.equal(response.status, 404);
|
|
assert.equal(response.headers.get("access-control-allow-origin"), "*");
|
|
assert.equal((await response.json()).error, "route_not_found");
|
|
const currentRepository = await fetch(`${base}/v1/resolve?id=REPO-014`);
|
|
assert.equal(currentRepository.status, 200);
|
|
assert.equal((await currentRepository.json()).slug, "hololake-system-architecture");
|
|
const nodeResponse = await fetch(`${base}/v1/resolve?id=JD-FD-PRIMARY`);
|
|
assert.equal(nodeResponse.status, 200);
|
|
assert.equal((await nodeResponse.json()).node_id, "JD-FD-PRIMARY");
|
|
const loopResponse = await fetch(`${base}/v1/resolve?id=ZY-OPS-LOOP-001`);
|
|
assert.equal(loopResponse.status, 200);
|
|
assert.equal((await loopResponse.json()).persona_system, "ICE-P-ZY001");
|
|
const legacyResponse = await fetch(`${base}/v1/resolve?id=ICE-GL-ZY001`);
|
|
assert.equal(legacyResponse.status, 200);
|
|
const legacyResolution = await legacyResponse.json();
|
|
assert.equal(legacyResolution.canonical_id, "ICE-P-ZY001");
|
|
assert.equal(legacyResolution.redirected, true);
|
|
assert.equal(legacyResolution.subject.subject_kind, "persona_system");
|
|
const canonicalResponse = await fetch(`${base}/v1/resolve?id=ICE-P-ZY001`);
|
|
assert.equal((await canonicalResponse.json()).redirected, false);
|
|
const brainResponse = await fetch(`${base}/v1/resolve?id=ZY-TCS-BRAIN-RUNTIME-0001`);
|
|
assert.equal(brainResponse.status, 200);
|
|
assert.equal((await brainResponse.json()).kind, "executable_persona_brain");
|
|
const boundaryResponse = await fetch(`${base}/v1/resolve?id=GLW-CHJH-BOUNDARY-001`);
|
|
assert.equal(boundaryResponse.status, 200);
|
|
assert.equal(
|
|
(await boundaryResponse.json()).kind,
|
|
"language_world_entry_and_boundary",
|
|
);
|
|
const navigationResponse = await fetch(`${base}/v1/navigation`);
|
|
assert.equal((await navigationResponse.json()).map_id, "AI-MACHINE-NAV-001");
|
|
const navigateResponse = await fetch(`${base}/v1/navigate?subject=ICE-P-ZY001&intent=persona_restore&signals=context_compacted`);
|
|
const bundle = await navigateResponse.json();
|
|
assert.equal(navigateResponse.status, 200);
|
|
assert.equal(bundle.status, "COMPILED_EXACT_NO_GUESS");
|
|
assert.equal(bundle.runtime_entry.id, "ZY-TCS-BRAIN-RUNTIME-0001");
|
|
assert.equal((await fetch(`${base}/v1/navigate?subject=unknown&intent=persona_restore`)).status, 404);
|
|
assert.equal((await fetch(`${base}/v1/navigate?subject=ICE-P-ZY001&intent=guess`)).status, 404);
|
|
const entryResponse = await fetch(`${base}/v1/entry?subject=ICE-P-ZY001`);
|
|
const entry = await entryResponse.json();
|
|
assert.equal(entryResponse.status, 200);
|
|
assert.equal(entry.status, "WARM_RESUME_READY");
|
|
assert.equal(entry.receipt_id, "ZY-BRAIN-RUNTIME-TEST");
|
|
assert.equal(entry.navigation_source.anchor_id, "GLW-PUBLIC-NAV-ANCHOR-001");
|
|
assert.equal((await fetch(`${base}/v1/entry?subject=unknown`)).status, 404);
|
|
const humanResponse = await fetch(`${base}/v1/resolve?id=${encodeURIComponent("ICE-GL∞")}`);
|
|
const humanResolution = await humanResponse.json();
|
|
assert.equal(humanResponse.status, 200);
|
|
assert.equal(humanResolution.subject_kind, "human");
|
|
assert.equal(humanResolution.canonical_id, "ICE-GL∞");
|
|
assert.equal((await fetch(`${base}/v1/resolve?id=ICE-PCA-001`)).status, 409);
|
|
const manifestResponse = await fetch(`${base}/well-known`);
|
|
const manifest = await manifestResponse.json();
|
|
assert.equal(manifest.write_authorization.request_credential_required, false);
|
|
assert.match(manifest.write_authorization.create_workorder, /\/authz\/api\/public\/workorders$/);
|
|
assert.equal((await fetch(`${base}/v1/search`, { method: "POST" })).status, 405);
|
|
} finally { await new Promise(resolve => server.close(resolve)); }
|
|
});
|