pi-vault-mind 0.14.2 → 0.16.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +293 -0
- package/README.md +5 -5
- package/agents/broadcaster.agent.md +2 -2
- package/agents/heavy-lifter.agent.md +1 -1
- package/agents/main.agent.md +29 -0
- package/agents/manager.agent.md +1 -1
- package/agents/miner.agent.md +1 -1
- package/dist/packages/obsidian/src/client.js +331 -0
- package/dist/packages/obsidian/src/types.js +1 -0
- package/dist/src/activity.d.ts +49 -0
- package/dist/src/activity.js +175 -0
- package/dist/src/agent-bus/Agent.d.ts +9 -1
- package/dist/src/agent-bus/Agent.js +18 -2
- package/dist/src/agent-bus/index.d.ts +5 -5
- package/dist/src/agent-bus/index.js +1 -1
- package/dist/src/agent-queue.js +12 -3
- package/dist/src/agents/BroadcasterAgent.d.ts +1 -1
- package/dist/src/agents/BroadcasterAgent.js +2 -2
- package/dist/src/agents/HeavyLifterAgent.d.ts +1 -1
- package/dist/src/agents/HeavyLifterAgent.js +2 -2
- package/dist/src/agents/ManagerAgent.js +1 -1
- package/dist/src/agents/MinerAgent.d.ts +1 -1
- package/dist/src/agents/MinerAgent.js +2 -2
- package/dist/src/agents/index.d.ts +2 -2
- package/dist/src/agents/index.js +2 -2
- package/dist/src/auth.d.ts +17 -15
- package/dist/src/auth.js +26 -37
- package/dist/src/autosync.js +2 -2
- package/dist/src/commands.d.ts +2 -19
- package/dist/src/commands.js +301 -231
- package/dist/src/config-keys.d.ts +16 -0
- package/dist/src/config-keys.js +45 -0
- package/dist/src/discover-schema.js +4 -4
- package/dist/src/edits.d.ts +21 -0
- package/dist/src/edits.js +75 -0
- package/dist/src/embedding-probe.d.ts +34 -0
- package/dist/src/embedding-probe.js +142 -0
- package/dist/src/embedding-providers.d.ts +133 -0
- package/dist/src/embedding-providers.js +173 -0
- package/dist/src/embedding-secrets.d.ts +38 -0
- package/dist/src/embedding-secrets.js +291 -0
- package/dist/src/engine.d.ts +6 -0
- package/dist/src/engine.js +78 -6
- package/dist/src/events.js +7 -10
- package/dist/src/extension-packages.d.ts +9 -0
- package/dist/src/extension-packages.js +14 -0
- package/dist/src/git.d.ts +19 -0
- package/dist/src/git.js +78 -0
- package/dist/src/graph.d.ts +2 -1
- package/dist/src/graph.js +47 -13
- package/dist/src/identities-config.d.ts +6 -0
- package/dist/src/identities-config.js +39 -0
- package/dist/src/identity-injector.js +1 -1
- package/dist/src/index.js +9 -26
- package/dist/src/lance.d.ts +9 -0
- package/dist/src/lance.js +143 -203
- package/dist/src/modal-client.d.ts +16 -0
- package/dist/src/modal-client.js +16 -0
- package/dist/src/modal-config.d.ts +37 -14
- package/dist/src/modal-config.js +59 -32
- package/dist/src/model-router.d.ts +27 -0
- package/dist/src/model-router.js +67 -0
- package/dist/src/models.d.ts +42 -0
- package/dist/src/models.js +78 -0
- package/dist/src/personalize.js +17 -3
- package/dist/src/scaffold.d.ts +48 -0
- package/dist/src/scaffold.js +246 -0
- package/dist/src/server.d.ts +47 -4
- package/dist/src/server.js +988 -221
- package/dist/src/session-search.d.ts +63 -0
- package/dist/src/session-search.js +379 -0
- package/dist/src/settings-ui.d.ts +2 -2
- package/dist/src/settings-ui.js +76 -135
- package/dist/src/sync.d.ts +3 -3
- package/dist/src/sync.js +19 -15
- package/dist/src/tool-catalog.d.ts +18 -0
- package/dist/src/tool-catalog.js +232 -0
- package/dist/src/tools/marksman.js +1 -1
- package/dist/src/tools.js +111 -65
- package/dist/src/types.d.ts +127 -71
- package/dist/src/utils.d.ts +57 -6
- package/dist/src/utils.js +114 -28
- package/dist/src/vault-tools.d.ts +34 -0
- package/dist/src/vault-tools.js +99 -0
- package/dist/src/vault-writer.js +4 -1
- package/dist/src/vm-handlers.js +140 -43
- package/dist/src/watcher.js +9 -9
- package/dist/test/activity-tool.test.js +54 -0
- package/dist/test/agent-bus/Agent.test.js +174 -0
- package/dist/test/agent-bus/AgentLoader.test.js +180 -0
- package/dist/test/agent-bus/AgentRegistry.test.js +86 -0
- package/dist/test/agent-bus/LLMProvider.test.js +162 -0
- package/dist/test/agent-bus/TaskQueue.test.js +256 -0
- package/dist/test/agent-dispatch-context.test.js +73 -0
- package/dist/test/agent-queue.test.js +1 -1
- package/dist/test/agents/Agents.test.js +282 -0
- package/dist/test/auth.test.js +57 -56
- package/dist/test/bridge-identity.test.js +34 -3
- package/dist/test/classify-search-mode.test.js +51 -0
- package/dist/test/commands.test.js +410 -0
- package/dist/test/config-merge.test.js +98 -0
- package/dist/test/context-capture.test.js +56 -0
- package/dist/test/discover-schema.test.js +8 -5
- package/dist/test/dispatch.test.js +45 -91
- package/dist/test/edits.test.js +144 -0
- package/dist/test/embedding-probe.test.js +424 -0
- package/dist/test/embedding-providers.test.js +157 -0
- package/dist/test/embedding-secrets.test.js +210 -0
- package/dist/test/engine-identity.test.js +1 -1
- package/dist/test/events.test.js +675 -0
- package/dist/test/git-bridge.test.js +160 -0
- package/dist/test/graph.test.js +464 -0
- package/dist/test/helpers/server.js +81 -0
- package/dist/test/identity-injector.test.js +197 -0
- package/dist/test/index.test.js +5 -7
- package/dist/test/lance-modal.test.js +67 -2
- package/dist/test/lance.test.js +429 -0
- package/dist/test/modal-client.test.js +1 -1
- package/dist/test/modal-config.test.js +92 -79
- package/dist/test/model-readiness.test.js +122 -0
- package/dist/test/model-router.test.js +99 -0
- package/dist/test/obsidian-client.test.js +42 -0
- package/dist/test/personalize.test.js +1 -1
- package/dist/test/rest-models.test.js +153 -0
- package/dist/test/rest-queue.test.js +135 -87
- package/dist/test/rest-setup.test.js +625 -115
- package/dist/test/rest-vm.test.js +355 -94
- package/dist/test/server-cors.test.js +48 -0
- package/dist/test/server-ws.test.js +61 -34
- package/dist/test/session-crud.test.js +323 -0
- package/dist/test/session-search.test.js +139 -0
- package/dist/test/settings-ui.test.js +113 -4
- package/dist/test/sync.test.js +12 -12
- package/dist/test/tombstone.test.js +8 -10
- package/dist/test/tool-catalog.test.js +86 -0
- package/dist/test/utils.test.js +588 -0
- package/dist/test/vault-tools.test.js +103 -12
- package/dist/test/vault-writer.test.js +371 -0
- package/dist/test/vm-handlers.test.js +620 -0
- package/extension-packages.json +9 -0
- package/package.json +107 -90
- package/pi-vault-mind.config.example.json +24 -2
- package/scripts/check-deps.sh +35 -32
- package/scripts/cli-e2e.mjs +215 -0
- package/scripts/configuration-e2e.mjs +783 -0
- package/scripts/e2e-commands.mjs +391 -0
- package/scripts/e2e-ws.mjs +3 -2
- package/scripts/fetch-modal-token.sh +4 -3
- package/scripts/generate-config-keys-json.mjs +45 -0
- package/scripts/generate-extension-packages-json.mjs +55 -0
- package/scripts/pi-session-query +0 -0
- package/scripts/publish-obsidian-plugin.sh +0 -0
- package/scripts/reset-test-vault.sh +2 -2
- package/scripts/setup-test-config.sh +0 -0
- package/scripts/setup-vault-pi.sh +48 -9
- package/scripts/test-slash-commands.mjs +2 -2
- package/scripts/vault-pi.sh +12 -3
- package/skills/github-release-notes-file/SKILL.md +42 -0
- package/skills/obsidian-guided-test-session/SKILL.md +110 -0
- package/skills/obsidian-interactive-test/SKILL.md +88 -0
- package/skills/obsidian-plugin-publish/SKILL.md +58 -0
- package/skills/pi-vault-mind-release/SKILL.md +141 -0
- package/skills/pre-test-release/SKILL.md +116 -0
- package/dist/test/auto-indexer.test.js +0 -2
|
@@ -1,107 +1,74 @@
|
|
|
1
1
|
import { strict as assert } from "node:assert";
|
|
2
2
|
import * as fs from "node:fs";
|
|
3
|
-
import * as http from "node:http";
|
|
4
3
|
import * as path from "node:path";
|
|
5
4
|
import { afterEach, beforeEach, describe, it } from "node:test";
|
|
6
5
|
import { _resetAuthCache } from "../src/auth.js";
|
|
7
|
-
import {
|
|
8
|
-
import {
|
|
6
|
+
import { getConfigPath } from "../src/utils.js";
|
|
7
|
+
import { fakePi, fetchJson, makeVault, startTestServer, TEST_TOKEN, writeVaultConfig, } from "./helpers/server.js";
|
|
9
8
|
const envVar = "PVM_API_TOKEN";
|
|
10
|
-
const
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
9
|
+
const managerToken = "manager-route-token";
|
|
10
|
+
const isolatedEnvVars = [
|
|
11
|
+
"PVM_LOCAL_EMBEDDING_API_KEY",
|
|
12
|
+
"PVM_REMOTE_EMBEDDING_API_KEY",
|
|
13
|
+
"PVM_MODAL_READ_TOKEN",
|
|
14
|
+
"PVM_MODAL_WRITE_TOKEN",
|
|
15
|
+
"PVM_TOKEN_MANAGER",
|
|
16
|
+
"PVM_TOKEN_MINER",
|
|
17
|
+
];
|
|
18
|
+
const secretEnvPath = (vaultPath) => path.join(vaultPath, ".vault-mind", "vault-mind.env");
|
|
19
|
+
const writeSecretEnv = (vaultPath, content) => {
|
|
20
|
+
const filePath = secretEnvPath(vaultPath);
|
|
21
|
+
fs.mkdirSync(path.dirname(filePath), { recursive: true });
|
|
22
|
+
fs.writeFileSync(filePath, content, "utf-8");
|
|
16
23
|
};
|
|
17
|
-
const
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
headers: {
|
|
25
|
-
"Content-Type": "application/json",
|
|
26
|
-
...(token ? { Authorization: `Bearer ${token}` } : {}),
|
|
27
|
-
},
|
|
28
|
-
}, (res) => {
|
|
29
|
-
let data = "";
|
|
30
|
-
res.on("data", (chunk) => {
|
|
31
|
-
data += chunk.toString();
|
|
32
|
-
});
|
|
33
|
-
res.on("end", () => {
|
|
34
|
-
try {
|
|
35
|
-
resolve({ status: res.statusCode ?? 0, body: JSON.parse(data || "{}") });
|
|
36
|
-
}
|
|
37
|
-
catch {
|
|
38
|
-
resolve({ status: res.statusCode ?? 0, body: data });
|
|
39
|
-
}
|
|
40
|
-
});
|
|
41
|
-
});
|
|
42
|
-
req.on("error", reject);
|
|
43
|
-
if (body !== undefined)
|
|
44
|
-
req.write(JSON.stringify(body));
|
|
45
|
-
req.end();
|
|
46
|
-
});
|
|
24
|
+
const assertResponseExcludes = (body, sentinels) => {
|
|
25
|
+
const serialized = JSON.stringify(body);
|
|
26
|
+
for (const sentinel of sentinels) {
|
|
27
|
+
assert.equal(serialized.includes(sentinel), false, "response exposed a complete secret");
|
|
28
|
+
assert.equal(serialized.includes(sentinel.slice(0, 16)), false, "response exposed a recoverable secret prefix");
|
|
29
|
+
assert.equal(serialized.includes(sentinel.slice(-16)), false, "response exposed a recoverable secret suffix");
|
|
30
|
+
}
|
|
47
31
|
};
|
|
48
32
|
describe("REST setup routes", () => {
|
|
49
33
|
let vaultPath;
|
|
50
|
-
let
|
|
51
|
-
let watcherState;
|
|
34
|
+
let srv;
|
|
52
35
|
let port;
|
|
53
36
|
let savedEnv;
|
|
54
|
-
let
|
|
37
|
+
let savedCwd;
|
|
38
|
+
let savedIsolatedEnv;
|
|
55
39
|
beforeEach(async () => {
|
|
56
40
|
savedEnv = process.env[envVar];
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
41
|
+
savedCwd = process.cwd();
|
|
42
|
+
savedIsolatedEnv = Object.fromEntries(isolatedEnvVars.map((key) => [key, process.env[key]]));
|
|
43
|
+
for (const key of isolatedEnvVars)
|
|
44
|
+
delete process.env[key];
|
|
45
|
+
vaultPath = makeVault("rest-setup");
|
|
46
|
+
process.chdir(vaultPath);
|
|
47
|
+
process.env[envVar] = TEST_TOKEN;
|
|
61
48
|
_resetAuthCache();
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
startServer({
|
|
65
|
-
sendUserMessage: () => { },
|
|
66
|
-
events: { emit: () => { } },
|
|
67
|
-
getAllTools: () => [],
|
|
68
|
-
registerCommand: () => { },
|
|
69
|
-
registerTool: () => { },
|
|
70
|
-
}, serverState, watcherState);
|
|
71
|
-
// Wait for the server to be listening, then read the actual port
|
|
72
|
-
await new Promise((resolve, reject) => {
|
|
73
|
-
const srv = serverState.server;
|
|
74
|
-
if (!srv)
|
|
75
|
-
return reject(new Error("server not created"));
|
|
76
|
-
if (srv.listening) {
|
|
77
|
-
const addr = srv.address();
|
|
78
|
-
port = typeof addr === "object" && addr ? addr.port : 0;
|
|
79
|
-
return resolve();
|
|
80
|
-
}
|
|
81
|
-
srv.once("listening", () => {
|
|
82
|
-
const addr = srv.address();
|
|
83
|
-
port = typeof addr === "object" && addr ? addr.port : 0;
|
|
84
|
-
resolve();
|
|
85
|
-
});
|
|
86
|
-
srv.once("error", reject);
|
|
87
|
-
});
|
|
49
|
+
srv = await startTestServer(fakePi);
|
|
50
|
+
port = srv.port;
|
|
88
51
|
});
|
|
89
52
|
afterEach(() => {
|
|
90
|
-
|
|
53
|
+
srv.stop();
|
|
91
54
|
if (savedEnv === undefined)
|
|
92
55
|
delete process.env[envVar];
|
|
93
56
|
else
|
|
94
57
|
process.env[envVar] = savedEnv;
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
58
|
+
for (const key of isolatedEnvVars) {
|
|
59
|
+
const saved = savedIsolatedEnv[key];
|
|
60
|
+
if (saved === undefined)
|
|
61
|
+
delete process.env[key];
|
|
62
|
+
else
|
|
63
|
+
process.env[key] = saved;
|
|
64
|
+
}
|
|
65
|
+
process.chdir(savedCwd);
|
|
99
66
|
if (fs.existsSync(vaultPath))
|
|
100
67
|
fs.rmSync(vaultPath, { recursive: true });
|
|
101
68
|
_resetAuthCache();
|
|
102
69
|
});
|
|
103
70
|
it("GET /vm/status returns ok and configured flag", async () => {
|
|
104
|
-
const { status, body } = await fetchJson(
|
|
71
|
+
const { status, body } = await fetchJson(port, "GET", "/vm/status", { token: TEST_TOKEN });
|
|
105
72
|
assert.equal(status, 200);
|
|
106
73
|
const b = body;
|
|
107
74
|
assert.equal(b.ok, true);
|
|
@@ -111,16 +78,23 @@ describe("REST setup routes", () => {
|
|
|
111
78
|
assert.equal(typeof b.version, "string");
|
|
112
79
|
});
|
|
113
80
|
it("GET /vm/status returns 401 without token", async () => {
|
|
114
|
-
const { status } = await fetchJson(
|
|
81
|
+
const { status } = await fetchJson(port, "GET", "/vm/status");
|
|
115
82
|
assert.equal(status, 401);
|
|
116
83
|
});
|
|
117
|
-
it("POST /vm/
|
|
118
|
-
const { status, body } = await fetchJson(
|
|
84
|
+
it("POST /vm/setup scaffolds config and vault-named collection file", async () => {
|
|
85
|
+
const { status, body } = await fetchJson(port, "POST", "/vm/setup", {
|
|
86
|
+
body: { vault: vaultPath },
|
|
87
|
+
token: TEST_TOKEN,
|
|
88
|
+
});
|
|
119
89
|
assert.equal(status, 200);
|
|
120
90
|
const b = body;
|
|
121
91
|
assert.equal(b.ok, true);
|
|
122
|
-
assert.equal(b.
|
|
123
|
-
|
|
92
|
+
assert.equal(typeof b.collectionName, "string");
|
|
93
|
+
assert.notEqual(b.collectionName, "main");
|
|
94
|
+
assert.ok(Array.isArray(b.created));
|
|
95
|
+
assert.ok(Array.isArray(b.updated));
|
|
96
|
+
assert.ok(Array.isArray(b.skipped));
|
|
97
|
+
const configPath = getConfigPath(vaultPath);
|
|
124
98
|
assert.ok(fs.existsSync(configPath));
|
|
125
99
|
const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
|
|
126
100
|
const mainPath = String(cfg.collections?.main?.path || "");
|
|
@@ -129,68 +103,353 @@ describe("REST setup routes", () => {
|
|
|
129
103
|
assert.ok(fs.existsSync(path.join(vaultPath, mainPath)));
|
|
130
104
|
assert.ok(fs.existsSync(path.join(vaultPath, ".gitignore")));
|
|
131
105
|
});
|
|
132
|
-
it("POST /vm/
|
|
133
|
-
const { status, body } = await fetchJson(
|
|
106
|
+
it("POST /vm/setup accepts collection override", async () => {
|
|
107
|
+
const { status, body } = await fetchJson(port, "POST", "/vm/setup", {
|
|
108
|
+
body: { vault: vaultPath, collection: "returnvape" },
|
|
109
|
+
token: TEST_TOKEN,
|
|
110
|
+
});
|
|
134
111
|
assert.equal(status, 200);
|
|
135
112
|
const b = body;
|
|
136
113
|
assert.equal(b.ok, true);
|
|
137
|
-
|
|
114
|
+
assert.equal(b.collectionName, "returnvape");
|
|
115
|
+
const cfg = JSON.parse(fs.readFileSync(getConfigPath(vaultPath), "utf-8"));
|
|
138
116
|
assert.equal(cfg.collections?.main?.path, "collections/returnvape.jsonl");
|
|
139
117
|
assert.ok(fs.existsSync(path.join(vaultPath, "collections", "returnvape.jsonl")));
|
|
140
118
|
});
|
|
141
|
-
it("POST /vm/
|
|
142
|
-
await fetchJson(
|
|
143
|
-
const { status, body } = await fetchJson(
|
|
119
|
+
it("POST /vm/setup scaffold is idempotent", async () => {
|
|
120
|
+
await fetchJson(port, "POST", "/vm/setup", { body: { vault: vaultPath }, token: TEST_TOKEN });
|
|
121
|
+
const { status, body } = await fetchJson(port, "POST", "/vm/setup", {
|
|
122
|
+
body: { vault: vaultPath },
|
|
123
|
+
token: TEST_TOKEN,
|
|
124
|
+
});
|
|
144
125
|
assert.equal(status, 200);
|
|
145
126
|
const b = body;
|
|
146
127
|
assert.equal(b.ok, true);
|
|
128
|
+
assert.deepEqual(b.created, []);
|
|
129
|
+
assert.deepEqual(b.updated, []);
|
|
147
130
|
});
|
|
148
|
-
it("POST /vm/
|
|
149
|
-
const { status } = await fetchJson(
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
const { status, body } = await fetchJson("127.0.0.1", port, "POST", "/vm/setup", { vault: vaultPath, localUrl: "http://127.0.0.1:11434/v1", model: "embeddinggemma" }, "test-token");
|
|
131
|
+
it("POST /vm/setup writes config to .vault-mind/vault-mind.config.json", async () => {
|
|
132
|
+
const { status, body } = await fetchJson(port, "POST", "/vm/setup", {
|
|
133
|
+
body: { vault: vaultPath, localUrl: "http://127.0.0.1:11434/v1", model: "embeddinggemma" },
|
|
134
|
+
token: TEST_TOKEN,
|
|
135
|
+
});
|
|
154
136
|
assert.equal(status, 200);
|
|
155
137
|
const b = body;
|
|
156
138
|
assert.equal(b.ok, true);
|
|
157
|
-
const
|
|
158
|
-
assert.ok(fs.existsSync(
|
|
159
|
-
const cfg = JSON.parse(fs.readFileSync(
|
|
139
|
+
const configPath = path.join(vaultPath, ".vault-mind", "vault-mind.config.json");
|
|
140
|
+
assert.ok(fs.existsSync(configPath));
|
|
141
|
+
const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
|
|
160
142
|
assert.equal(cfg.vaultMind.embedding.localUrl, "http://127.0.0.1:11434/v1");
|
|
161
143
|
assert.equal(cfg.vaultMind.embedding.model, "embeddinggemma");
|
|
162
144
|
});
|
|
163
145
|
it("POST /vm/setup returns 401 without token", async () => {
|
|
164
|
-
const { status } = await fetchJson(
|
|
165
|
-
vault: vaultPath,
|
|
166
|
-
localUrl: "http://127.0.0.1:11434/v1",
|
|
146
|
+
const { status } = await fetchJson(port, "POST", "/vm/setup", {
|
|
147
|
+
body: { vault: vaultPath, localUrl: "http://127.0.0.1:11434/v1" },
|
|
167
148
|
});
|
|
168
149
|
assert.equal(status, 401);
|
|
169
150
|
});
|
|
170
151
|
it("POST /server/start returns ok when already running", async () => {
|
|
171
|
-
const { status, body } = await fetchJson(
|
|
152
|
+
const { status, body } = await fetchJson(port, "POST", "/server/start", {
|
|
153
|
+
token: TEST_TOKEN,
|
|
154
|
+
});
|
|
172
155
|
assert.equal(status, 200);
|
|
173
156
|
const b = body;
|
|
174
157
|
assert.equal(b.ok, true);
|
|
175
158
|
assert.equal(b.alreadyRunning, true);
|
|
176
159
|
});
|
|
177
160
|
it("GET /vault-mind/config returns config snapshot", async () => {
|
|
178
|
-
// First run
|
|
179
|
-
await fetchJson(
|
|
180
|
-
await fetchJson(
|
|
181
|
-
|
|
161
|
+
// First run setup so there is config to read
|
|
162
|
+
await fetchJson(port, "POST", "/vm/setup", { body: { vault: vaultPath }, token: TEST_TOKEN });
|
|
163
|
+
await fetchJson(port, "POST", "/vm/setup", {
|
|
164
|
+
body: { vault: vaultPath, localUrl: "http://127.0.0.1:11434/v1" },
|
|
165
|
+
token: TEST_TOKEN,
|
|
166
|
+
});
|
|
167
|
+
const { status, body } = await fetchJson(port, "GET", "/vault-mind/config", {
|
|
168
|
+
token: TEST_TOKEN,
|
|
169
|
+
});
|
|
182
170
|
assert.equal(status, 200);
|
|
183
171
|
const b = body;
|
|
184
172
|
assert.equal(typeof b.hasToken, "boolean");
|
|
185
173
|
assert.equal(typeof b.version, "string");
|
|
186
|
-
assert.ok(b.
|
|
174
|
+
assert.ok(b.config, "returns merged config");
|
|
175
|
+
});
|
|
176
|
+
it("GET /vault-mind/config redacts every provider credential recursively", async () => {
|
|
177
|
+
const sentinels = [
|
|
178
|
+
"LOCAL-ROUTE-SECRET-PREFIX-opaque-END-LOCAL",
|
|
179
|
+
"REMOTE-ROUTE-SECRET-PREFIX-opaque-END-REMOTE",
|
|
180
|
+
"READ-ROUTE-SECRET-PREFIX-opaque-END-READ",
|
|
181
|
+
"WRITE-ROUTE-SECRET-PREFIX-opaque-END-WRITE",
|
|
182
|
+
];
|
|
183
|
+
writeVaultConfig(vaultPath, {
|
|
184
|
+
version: 2,
|
|
185
|
+
collections: {},
|
|
186
|
+
injectors: [],
|
|
187
|
+
vaultMind: {
|
|
188
|
+
dataDir: ".lancedb",
|
|
189
|
+
embedding: {
|
|
190
|
+
localUrl: "http://127.0.0.1:11434/v1",
|
|
191
|
+
apiKey: sentinels[0],
|
|
192
|
+
remoteApiKey: sentinels[1],
|
|
193
|
+
remoteReadApiKey: sentinels[2],
|
|
194
|
+
remoteWriteApiKey: sentinels[3],
|
|
195
|
+
},
|
|
196
|
+
},
|
|
197
|
+
});
|
|
198
|
+
const { status, body } = await fetchJson(port, "GET", "/vault-mind/config", {
|
|
199
|
+
token: TEST_TOKEN,
|
|
200
|
+
});
|
|
201
|
+
assert.equal(status, 200);
|
|
202
|
+
const response = body;
|
|
203
|
+
for (const key of ["apiKey", "remoteApiKey", "remoteReadApiKey", "remoteWriteApiKey"]) {
|
|
204
|
+
assert.equal(response.config.vaultMind.embedding[key], "••••••••");
|
|
205
|
+
}
|
|
206
|
+
assertResponseExcludes(body, sentinels);
|
|
207
|
+
});
|
|
208
|
+
it("GET /vault-mind/config returns four fixed-mask secret statuses", async () => {
|
|
209
|
+
const sentinels = [
|
|
210
|
+
"LOCAL-STATUS-SECRET-PREFIX-opaque-END-LOCAL",
|
|
211
|
+
"REMOTE-STATUS-SECRET-PREFIX-opaque-END-REMOTE",
|
|
212
|
+
"READ-STATUS-SECRET-PREFIX-opaque-END-READ",
|
|
213
|
+
"WRITE-STATUS-SECRET-PREFIX-opaque-END-WRITE",
|
|
214
|
+
];
|
|
215
|
+
writeSecretEnv(vaultPath, [
|
|
216
|
+
`PVM_LOCAL_EMBEDDING_API_KEY="${sentinels[0]}"`,
|
|
217
|
+
`PVM_REMOTE_EMBEDDING_API_KEY="${sentinels[1]}"`,
|
|
218
|
+
`PVM_MODAL_READ_TOKEN="${sentinels[2]}"`,
|
|
219
|
+
`PVM_MODAL_WRITE_TOKEN="${sentinels[3]}"`,
|
|
220
|
+
"",
|
|
221
|
+
].join("\n"));
|
|
222
|
+
const { status, body } = await fetchJson(port, "GET", "/vault-mind/config", {
|
|
223
|
+
token: TEST_TOKEN,
|
|
224
|
+
});
|
|
225
|
+
assert.equal(status, 200);
|
|
226
|
+
const response = body;
|
|
227
|
+
assert.deepEqual(response.embeddingSecrets, {
|
|
228
|
+
secrets: [
|
|
229
|
+
{
|
|
230
|
+
kind: "localApiKey",
|
|
231
|
+
configured: true,
|
|
232
|
+
masked: "••••••••",
|
|
233
|
+
source: "extension-secret-store",
|
|
234
|
+
},
|
|
235
|
+
{
|
|
236
|
+
kind: "remoteApiKey",
|
|
237
|
+
configured: true,
|
|
238
|
+
masked: "••••••••",
|
|
239
|
+
source: "extension-secret-store",
|
|
240
|
+
},
|
|
241
|
+
{
|
|
242
|
+
kind: "remoteReadApiKey",
|
|
243
|
+
configured: true,
|
|
244
|
+
masked: "••••••••",
|
|
245
|
+
source: "extension-secret-store",
|
|
246
|
+
},
|
|
247
|
+
{
|
|
248
|
+
kind: "remoteWriteApiKey",
|
|
249
|
+
configured: true,
|
|
250
|
+
masked: "••••••••",
|
|
251
|
+
source: "extension-secret-store",
|
|
252
|
+
},
|
|
253
|
+
],
|
|
254
|
+
});
|
|
255
|
+
assertResponseExcludes(body, sentinels);
|
|
256
|
+
});
|
|
257
|
+
it("PUT /vm/embedding/secrets requires manager write access", async () => {
|
|
258
|
+
const unauthenticatedSecret = "UNAUTH-ROUTE-SECRET-PREFIX-opaque-END-UNAUTH";
|
|
259
|
+
const minerSecret = "MINER-ROUTE-SECRET-PREFIX-opaque-END-MINER";
|
|
260
|
+
const managerSecret = "MANAGER-ROUTE-SECRET-PREFIX-opaque-END-MANAGER";
|
|
261
|
+
process.env.PVM_TOKEN_MINER = "miner-route-token";
|
|
262
|
+
process.env.PVM_TOKEN_MANAGER = managerToken;
|
|
263
|
+
_resetAuthCache();
|
|
264
|
+
const unauthenticated = await fetchJson(port, "PUT", "/vm/embedding/secrets", {
|
|
265
|
+
body: { remoteApiKey: unauthenticatedSecret },
|
|
266
|
+
});
|
|
267
|
+
assert.equal(unauthenticated.status, 401);
|
|
268
|
+
assert.equal(fs.existsSync(secretEnvPath(vaultPath)), false);
|
|
269
|
+
assertResponseExcludes(unauthenticated.body, [unauthenticatedSecret]);
|
|
270
|
+
const miner = await fetchJson(port, "PUT", "/vm/embedding/secrets", {
|
|
271
|
+
body: { remoteApiKey: minerSecret },
|
|
272
|
+
token: "miner-route-token",
|
|
273
|
+
});
|
|
274
|
+
assert.equal(miner.status, 403);
|
|
275
|
+
assert.equal(fs.existsSync(secretEnvPath(vaultPath)), false);
|
|
276
|
+
assertResponseExcludes(miner.body, [minerSecret]);
|
|
277
|
+
const manager = await fetchJson(port, "PUT", "/vm/embedding/secrets", {
|
|
278
|
+
body: { remoteApiKey: managerSecret },
|
|
279
|
+
token: managerToken,
|
|
280
|
+
});
|
|
281
|
+
assert.equal(manager.status, 200);
|
|
282
|
+
assert.equal(fs.readFileSync(secretEnvPath(vaultPath), "utf-8").includes(managerSecret), true);
|
|
283
|
+
assertResponseExcludes(manager.body, [managerSecret]);
|
|
284
|
+
});
|
|
285
|
+
it("PUT /vm/embedding/secrets rejects empty strings without mutation", async () => {
|
|
286
|
+
const storedSecret = "STORED-VALIDATION-SECRET-PREFIX-opaque-END-STORED";
|
|
287
|
+
const legacySecret = "LEGACY-VALIDATION-SECRET-PREFIX-opaque-END-LEGACY";
|
|
288
|
+
const attemptedSecret = "ATTEMPTED-VALIDATION-SECRET-PREFIX-opaque-END-ATTEMPTED";
|
|
289
|
+
process.env.PVM_TOKEN_MANAGER = managerToken;
|
|
290
|
+
writeVaultConfig(vaultPath, {
|
|
291
|
+
version: 2,
|
|
292
|
+
collections: {},
|
|
293
|
+
injectors: [],
|
|
294
|
+
vaultMind: {
|
|
295
|
+
dataDir: ".lancedb",
|
|
296
|
+
embedding: { remoteReadApiKey: legacySecret },
|
|
297
|
+
graph: { enabled: true },
|
|
298
|
+
},
|
|
299
|
+
});
|
|
300
|
+
writeSecretEnv(vaultPath, `# retain bytes\nPVM_REMOTE_EMBEDDING_API_KEY="${storedSecret}"\nUNRELATED_SETTING="keep-me"\n`);
|
|
301
|
+
const envBefore = fs.readFileSync(secretEnvPath(vaultPath), "utf-8");
|
|
302
|
+
const configBefore = fs.readFileSync(getConfigPath(vaultPath), "utf-8");
|
|
303
|
+
const { status, body } = await fetchJson(port, "PUT", "/vm/embedding/secrets", {
|
|
304
|
+
body: { localApiKey: attemptedSecret, remoteWriteApiKey: "" },
|
|
305
|
+
token: managerToken,
|
|
306
|
+
});
|
|
307
|
+
assert.equal(status, 400);
|
|
308
|
+
const response = body;
|
|
309
|
+
assert.equal(response.error, "invalid_request");
|
|
310
|
+
assert.match(String(response.message), /empty/i);
|
|
311
|
+
assert.equal(fs.readFileSync(secretEnvPath(vaultPath), "utf-8"), envBefore);
|
|
312
|
+
assert.equal(fs.readFileSync(getConfigPath(vaultPath), "utf-8"), configBefore);
|
|
313
|
+
assertResponseExcludes(body, [storedSecret, legacySecret, attemptedSecret]);
|
|
314
|
+
});
|
|
315
|
+
it("PUT /vm/embedding/secrets replaces and deletes secrets without echoing values", async () => {
|
|
316
|
+
const deletedSecret = "DELETED-ROUTE-SECRET-PREFIX-opaque-END-DELETED";
|
|
317
|
+
const replacedSecret = "REPLACED-ROUTE-SECRET-PREFIX-opaque-END-REPLACED";
|
|
318
|
+
const replacementSecret = "REPLACEMENT-ROUTE-SECRET-PREFIX-opaque-END-REPLACEMENT";
|
|
319
|
+
process.env.PVM_TOKEN_MANAGER = managerToken;
|
|
320
|
+
writeVaultConfig(vaultPath, {
|
|
321
|
+
version: 2,
|
|
322
|
+
collections: {},
|
|
323
|
+
injectors: [],
|
|
324
|
+
vaultMind: { dataDir: ".lancedb", embedding: {} },
|
|
325
|
+
});
|
|
326
|
+
writeSecretEnv(vaultPath, [
|
|
327
|
+
`PVM_LOCAL_EMBEDDING_API_KEY="${deletedSecret}"`,
|
|
328
|
+
`PVM_REMOTE_EMBEDDING_API_KEY="${replacedSecret}"`,
|
|
329
|
+
"",
|
|
330
|
+
].join("\n"));
|
|
331
|
+
const { status, body } = await fetchJson(port, "PUT", "/vm/embedding/secrets", {
|
|
332
|
+
body: { localApiKey: null, remoteApiKey: replacementSecret },
|
|
333
|
+
token: managerToken,
|
|
334
|
+
});
|
|
335
|
+
assert.equal(status, 200);
|
|
336
|
+
const response = body;
|
|
337
|
+
assert.equal(response.ok, true);
|
|
338
|
+
assert.equal(response.error, null);
|
|
339
|
+
assert.deepEqual(response.secrets.find(({ kind }) => kind === "localApiKey"), { kind: "localApiKey", configured: false, masked: null, source: "none" });
|
|
340
|
+
assert.deepEqual(response.secrets.find(({ kind }) => kind === "remoteApiKey"), {
|
|
341
|
+
kind: "remoteApiKey",
|
|
342
|
+
configured: true,
|
|
343
|
+
masked: "••••••••",
|
|
344
|
+
source: "extension-secret-store",
|
|
345
|
+
});
|
|
346
|
+
const stored = fs.readFileSync(secretEnvPath(vaultPath), "utf-8");
|
|
347
|
+
assert.equal(stored.includes("PVM_LOCAL_EMBEDDING_API_KEY="), false);
|
|
348
|
+
assert.equal(stored.includes(replacedSecret), false);
|
|
349
|
+
assert.equal(stored.includes(replacementSecret), true);
|
|
350
|
+
assertResponseExcludes(body, [deletedSecret, replacedSecret, replacementSecret]);
|
|
351
|
+
});
|
|
352
|
+
it("PUT /vm/embedding/secrets migrates legacy JSON and preserves unrelated env entries", async () => {
|
|
353
|
+
const legacyRemote = "LEGACY-REMOTE-SECRET-PREFIX-opaque-END-REMOTE";
|
|
354
|
+
const legacyRead = "LEGACY-READ-SECRET-PREFIX-opaque-END-READ";
|
|
355
|
+
const untouchedLegacyWrite = "UNTOUCHED-WRITE-SECRET-PREFIX-opaque-END-WRITE";
|
|
356
|
+
const replacementRemote = "MIGRATED-REMOTE-SECRET-PREFIX-opaque-END-REMOTE";
|
|
357
|
+
const replacementRead = "MIGRATED-READ-SECRET-PREFIX-opaque-END-READ";
|
|
358
|
+
const bridgeToken = "BRIDGE-STORE-SECRET-PREFIX-opaque-END-BRIDGE";
|
|
359
|
+
process.env.PVM_TOKEN_MANAGER = managerToken;
|
|
360
|
+
writeVaultConfig(vaultPath, {
|
|
361
|
+
version: 2,
|
|
362
|
+
collections: {},
|
|
363
|
+
injectors: [],
|
|
364
|
+
vaultMind: {
|
|
365
|
+
dataDir: ".lancedb",
|
|
366
|
+
embedding: {
|
|
367
|
+
remoteUrl: "https://embedding.example.test",
|
|
368
|
+
remoteApiKey: legacyRemote,
|
|
369
|
+
remoteReadApiKey: legacyRead,
|
|
370
|
+
remoteWriteApiKey: untouchedLegacyWrite,
|
|
371
|
+
},
|
|
372
|
+
graph: { enabled: true },
|
|
373
|
+
},
|
|
374
|
+
});
|
|
375
|
+
writeSecretEnv(vaultPath, ["# operator note", `PVM_API_TOKEN="${bridgeToken}"`, 'UNRELATED_SETTING="keep-me"', ""].join("\n"));
|
|
376
|
+
const { status, body } = await fetchJson(port, "PUT", "/vm/embedding/secrets", {
|
|
377
|
+
body: { remoteApiKey: replacementRemote, remoteReadApiKey: replacementRead },
|
|
378
|
+
token: managerToken,
|
|
379
|
+
});
|
|
380
|
+
assert.equal(status, 200);
|
|
381
|
+
const stored = fs.readFileSync(secretEnvPath(vaultPath), "utf-8");
|
|
382
|
+
assert.equal(stored.includes("# operator note"), true);
|
|
383
|
+
assert.equal(stored.includes(`PVM_API_TOKEN="${bridgeToken}"`), true);
|
|
384
|
+
assert.equal(stored.includes('UNRELATED_SETTING="keep-me"'), true);
|
|
385
|
+
assert.equal(stored.includes(replacementRemote), true);
|
|
386
|
+
assert.equal(stored.includes(replacementRead), true);
|
|
387
|
+
const migrated = JSON.parse(fs.readFileSync(getConfigPath(vaultPath), "utf-8"));
|
|
388
|
+
assert.equal("remoteApiKey" in migrated.vaultMind.embedding, false);
|
|
389
|
+
assert.equal("remoteReadApiKey" in migrated.vaultMind.embedding, false);
|
|
390
|
+
assert.equal(migrated.vaultMind.embedding.remoteWriteApiKey, untouchedLegacyWrite);
|
|
391
|
+
assert.deepEqual(migrated.vaultMind.graph, { enabled: true });
|
|
392
|
+
const response = body;
|
|
393
|
+
assert.deepEqual(response.secrets.find(({ kind }) => kind === "remoteWriteApiKey"), {
|
|
394
|
+
kind: "remoteWriteApiKey",
|
|
395
|
+
configured: true,
|
|
396
|
+
masked: "••••••••",
|
|
397
|
+
source: "legacy-config",
|
|
398
|
+
});
|
|
399
|
+
assertResponseExcludes(body, [
|
|
400
|
+
legacyRemote,
|
|
401
|
+
legacyRead,
|
|
402
|
+
untouchedLegacyWrite,
|
|
403
|
+
replacementRemote,
|
|
404
|
+
replacementRead,
|
|
405
|
+
bridgeToken,
|
|
406
|
+
]);
|
|
407
|
+
});
|
|
408
|
+
it("environment-owned secret remains configured after PUT null", async () => {
|
|
409
|
+
const environmentSecret = "ENVIRONMENT-SECRET-PREFIX-opaque-END-ENVIRONMENT";
|
|
410
|
+
const storedSecret = "STORED-DELETE-SECRET-PREFIX-opaque-END-STORED";
|
|
411
|
+
const legacySecret = "LEGACY-DELETE-SECRET-PREFIX-opaque-END-LEGACY";
|
|
412
|
+
process.env.PVM_TOKEN_MANAGER = managerToken;
|
|
413
|
+
process.env.PVM_LOCAL_EMBEDDING_API_KEY = environmentSecret;
|
|
414
|
+
writeVaultConfig(vaultPath, {
|
|
415
|
+
version: 2,
|
|
416
|
+
collections: {},
|
|
417
|
+
injectors: [],
|
|
418
|
+
vaultMind: {
|
|
419
|
+
dataDir: ".lancedb",
|
|
420
|
+
embedding: { apiKey: legacySecret },
|
|
421
|
+
},
|
|
422
|
+
});
|
|
423
|
+
writeSecretEnv(vaultPath, `PVM_LOCAL_EMBEDDING_API_KEY="${storedSecret}"\nUNRELATED_SETTING="keep-me"\n`);
|
|
424
|
+
const { status, body } = await fetchJson(port, "PUT", "/vm/embedding/secrets", {
|
|
425
|
+
body: { localApiKey: null },
|
|
426
|
+
token: managerToken,
|
|
427
|
+
});
|
|
428
|
+
assert.equal(status, 200);
|
|
429
|
+
const response = body;
|
|
430
|
+
assert.deepEqual(response.secrets.find(({ kind }) => kind === "localApiKey"), {
|
|
431
|
+
kind: "localApiKey",
|
|
432
|
+
configured: true,
|
|
433
|
+
masked: "••••••••",
|
|
434
|
+
source: "extension-environment",
|
|
435
|
+
});
|
|
436
|
+
const stored = fs.readFileSync(secretEnvPath(vaultPath), "utf-8");
|
|
437
|
+
assert.equal(stored.includes("PVM_LOCAL_EMBEDDING_API_KEY="), false);
|
|
438
|
+
assert.equal(stored.includes('UNRELATED_SETTING="keep-me"'), true);
|
|
439
|
+
const migrated = JSON.parse(fs.readFileSync(getConfigPath(vaultPath), "utf-8"));
|
|
440
|
+
assert.equal("apiKey" in migrated.vaultMind.embedding, false);
|
|
441
|
+
assert.equal(process.env.PVM_LOCAL_EMBEDDING_API_KEY, environmentSecret);
|
|
442
|
+
assertResponseExcludes(body, [environmentSecret, storedSecret, legacySecret]);
|
|
187
443
|
});
|
|
188
444
|
it("GET /vault-mind/config returns 401 without token", async () => {
|
|
189
|
-
const { status } = await fetchJson(
|
|
445
|
+
const { status } = await fetchJson(port, "GET", "/vault-mind/config");
|
|
190
446
|
assert.equal(status, 401);
|
|
191
447
|
});
|
|
192
448
|
it("POST /vault-mind/context stores editor context", async () => {
|
|
193
|
-
const { status, body } = await fetchJson(
|
|
449
|
+
const { status, body } = await fetchJson(port, "POST", "/vault-mind/context", {
|
|
450
|
+
body: { filePath: "notes/foo.md", selection: "hello", cursor: 42 },
|
|
451
|
+
token: TEST_TOKEN,
|
|
452
|
+
});
|
|
194
453
|
assert.equal(status, 200);
|
|
195
454
|
const b = body;
|
|
196
455
|
assert.equal(b.ok, true);
|
|
@@ -200,8 +459,13 @@ describe("REST setup routes", () => {
|
|
|
200
459
|
assert.equal(ctx.cursor, 42);
|
|
201
460
|
});
|
|
202
461
|
it("GET /vault-mind/context returns the latest editor context", async () => {
|
|
203
|
-
await fetchJson(
|
|
204
|
-
|
|
462
|
+
await fetchJson(port, "POST", "/vault-mind/context", {
|
|
463
|
+
body: { filePath: "notes/bar.md", selection: "world", cursor: 7 },
|
|
464
|
+
token: TEST_TOKEN,
|
|
465
|
+
});
|
|
466
|
+
const { status, body } = await fetchJson(port, "GET", "/vault-mind/context", {
|
|
467
|
+
token: TEST_TOKEN,
|
|
468
|
+
});
|
|
205
469
|
assert.equal(status, 200);
|
|
206
470
|
const b = body;
|
|
207
471
|
assert.equal(b.filePath, "notes/bar.md");
|
|
@@ -209,7 +473,9 @@ describe("REST setup routes", () => {
|
|
|
209
473
|
assert.equal(b.cursor, 7);
|
|
210
474
|
});
|
|
211
475
|
it("GET /vault-mind/context returns nulls when no context has been pushed", async () => {
|
|
212
|
-
const { status, body } = await fetchJson(
|
|
476
|
+
const { status, body } = await fetchJson(port, "GET", "/vault-mind/context", {
|
|
477
|
+
token: TEST_TOKEN,
|
|
478
|
+
});
|
|
213
479
|
assert.equal(status, 200);
|
|
214
480
|
const b = body;
|
|
215
481
|
assert.equal(b.filePath, null);
|
|
@@ -217,11 +483,255 @@ describe("REST setup routes", () => {
|
|
|
217
483
|
assert.equal(b.cursor, null);
|
|
218
484
|
});
|
|
219
485
|
it("/vault-mind/context routes require auth", async () => {
|
|
220
|
-
const post = await fetchJson(
|
|
221
|
-
filePath: "x.md",
|
|
486
|
+
const post = await fetchJson(port, "POST", "/vault-mind/context", {
|
|
487
|
+
body: { filePath: "x.md" },
|
|
222
488
|
});
|
|
223
489
|
assert.equal(post.status, 401);
|
|
224
|
-
const get = await fetchJson(
|
|
490
|
+
const get = await fetchJson(port, "GET", "/vault-mind/context");
|
|
225
491
|
assert.equal(get.status, 401);
|
|
226
492
|
});
|
|
227
493
|
});
|
|
494
|
+
const probeRouteEnvVars = [envVar, ...isolatedEnvVars];
|
|
495
|
+
const minerProbeToken = "miner-probe-route-token";
|
|
496
|
+
describe("POST /vm/embedding/probe", () => {
|
|
497
|
+
let vaultPath;
|
|
498
|
+
let srv;
|
|
499
|
+
let port;
|
|
500
|
+
let savedCwd;
|
|
501
|
+
let savedEnv;
|
|
502
|
+
let savedFetch;
|
|
503
|
+
let savedNow;
|
|
504
|
+
let providerCalls;
|
|
505
|
+
let providerResponse;
|
|
506
|
+
beforeEach(async () => {
|
|
507
|
+
savedCwd = process.cwd();
|
|
508
|
+
savedEnv = Object.fromEntries(probeRouteEnvVars.map((key) => [key, process.env[key]]));
|
|
509
|
+
for (const key of probeRouteEnvVars)
|
|
510
|
+
delete process.env[key];
|
|
511
|
+
vaultPath = makeVault("rest-embedding-probe");
|
|
512
|
+
process.chdir(vaultPath);
|
|
513
|
+
process.env[envVar] = TEST_TOKEN;
|
|
514
|
+
process.env.PVM_TOKEN_MINER = minerProbeToken;
|
|
515
|
+
process.env.PVM_TOKEN_MANAGER = managerToken;
|
|
516
|
+
_resetAuthCache();
|
|
517
|
+
srv = await startTestServer(fakePi);
|
|
518
|
+
port = srv.port;
|
|
519
|
+
providerCalls = [];
|
|
520
|
+
providerResponse = () => {
|
|
521
|
+
throw new Error("provider fetch was not configured for this test");
|
|
522
|
+
};
|
|
523
|
+
savedFetch = globalThis.fetch;
|
|
524
|
+
globalThis.fetch = (async (input, init) => {
|
|
525
|
+
const request = input instanceof Request ? input : null;
|
|
526
|
+
const url = request?.url ?? String(input);
|
|
527
|
+
if (url.startsWith(`http://127.0.0.1:${port}/`)) {
|
|
528
|
+
return savedFetch(input, init);
|
|
529
|
+
}
|
|
530
|
+
const headers = new Headers(request?.headers);
|
|
531
|
+
new Headers(init?.headers).forEach((value, key) => {
|
|
532
|
+
headers.set(key, value);
|
|
533
|
+
});
|
|
534
|
+
const call = {
|
|
535
|
+
url,
|
|
536
|
+
method: init?.method ?? request?.method ?? "GET",
|
|
537
|
+
headers,
|
|
538
|
+
};
|
|
539
|
+
providerCalls.push(call);
|
|
540
|
+
return providerResponse(call);
|
|
541
|
+
});
|
|
542
|
+
savedNow = Date.now;
|
|
543
|
+
Date.now = () => 500;
|
|
544
|
+
});
|
|
545
|
+
afterEach(() => {
|
|
546
|
+
globalThis.fetch = savedFetch;
|
|
547
|
+
Date.now = savedNow;
|
|
548
|
+
srv.stop();
|
|
549
|
+
for (const key of probeRouteEnvVars) {
|
|
550
|
+
const saved = savedEnv[key];
|
|
551
|
+
if (saved === undefined)
|
|
552
|
+
delete process.env[key];
|
|
553
|
+
else
|
|
554
|
+
process.env[key] = saved;
|
|
555
|
+
}
|
|
556
|
+
process.chdir(savedCwd);
|
|
557
|
+
if (fs.existsSync(vaultPath))
|
|
558
|
+
fs.rmSync(vaultPath, { recursive: true });
|
|
559
|
+
_resetAuthCache();
|
|
560
|
+
});
|
|
561
|
+
it("POST /vm/embedding/probe rejects unauthenticated requests without contacting the provider", async () => {
|
|
562
|
+
const secret = "UNAUTHENTICATED-PROBE-SECRET-PREFIX-opaque-END-SECRET";
|
|
563
|
+
const { status, body } = await fetchJson(port, "POST", "/vm/embedding/probe", {
|
|
564
|
+
body: {
|
|
565
|
+
target: "remote",
|
|
566
|
+
url: "https://provider.example.test",
|
|
567
|
+
transientSecrets: { readApiKey: secret },
|
|
568
|
+
},
|
|
569
|
+
});
|
|
570
|
+
assert.equal(status, 401);
|
|
571
|
+
assert.equal(providerCalls.length, 0);
|
|
572
|
+
assertResponseExcludes(body, [secret]);
|
|
573
|
+
});
|
|
574
|
+
it("POST /vm/embedding/probe rejects read-only miner auth without contacting the provider", async () => {
|
|
575
|
+
const secret = "MINER-PROBE-SECRET-PREFIX-opaque-END-SECRET";
|
|
576
|
+
const { status, body } = await fetchJson(port, "POST", "/vm/embedding/probe", {
|
|
577
|
+
body: {
|
|
578
|
+
target: "remote",
|
|
579
|
+
url: "https://provider.example.test",
|
|
580
|
+
transientSecrets: { readApiKey: secret },
|
|
581
|
+
},
|
|
582
|
+
token: minerProbeToken,
|
|
583
|
+
});
|
|
584
|
+
assert.equal(status, 403);
|
|
585
|
+
assert.equal(providerCalls.length, 0);
|
|
586
|
+
assertResponseExcludes(body, [secret]);
|
|
587
|
+
});
|
|
588
|
+
it("POST /vm/embedding/probe rejects non-POST methods without contacting the provider", async () => {
|
|
589
|
+
const { status, body } = await fetchJson(port, "GET", "/vm/embedding/probe", {
|
|
590
|
+
token: managerToken,
|
|
591
|
+
});
|
|
592
|
+
assert.equal(status, 405);
|
|
593
|
+
assert.deepEqual(body, { error: "Method not allowed" });
|
|
594
|
+
assert.equal(providerCalls.length, 0);
|
|
595
|
+
});
|
|
596
|
+
it("POST /vm/embedding/probe rejects invalid target and URL DTOs before contacting the provider", async () => {
|
|
597
|
+
const invalidCases = [
|
|
598
|
+
{
|
|
599
|
+
name: "unknown target",
|
|
600
|
+
body: { target: "other", url: "https://provider.example.test" },
|
|
601
|
+
message: /target/i,
|
|
602
|
+
},
|
|
603
|
+
{
|
|
604
|
+
name: "non-HTTP URL",
|
|
605
|
+
body: { target: "remote", url: "file:///tmp/provider" },
|
|
606
|
+
message: /url|http/i,
|
|
607
|
+
},
|
|
608
|
+
{
|
|
609
|
+
name: "non-string URL",
|
|
610
|
+
body: { target: "local", url: 42 },
|
|
611
|
+
message: /url/i,
|
|
612
|
+
},
|
|
613
|
+
{
|
|
614
|
+
name: "non-string transient credential",
|
|
615
|
+
body: {
|
|
616
|
+
target: "remote",
|
|
617
|
+
url: "https://provider.example.test",
|
|
618
|
+
transientSecrets: { readApiKey: 42 },
|
|
619
|
+
},
|
|
620
|
+
message: /secret|credential|readApiKey/i,
|
|
621
|
+
},
|
|
622
|
+
];
|
|
623
|
+
for (const testCase of invalidCases) {
|
|
624
|
+
const { status, body } = await fetchJson(port, "POST", "/vm/embedding/probe", {
|
|
625
|
+
body: testCase.body,
|
|
626
|
+
token: managerToken,
|
|
627
|
+
});
|
|
628
|
+
const response = body;
|
|
629
|
+
assert.equal(status, 400, testCase.name);
|
|
630
|
+
assert.equal(response.ok, false, testCase.name);
|
|
631
|
+
assert.deepEqual(response.models, [], testCase.name);
|
|
632
|
+
assert.equal(response.selectedModelAvailable, null, testCase.name);
|
|
633
|
+
assert.equal(response.latencyMs, null, testCase.name);
|
|
634
|
+
assert.equal(response.error?.code, "invalid_request", testCase.name);
|
|
635
|
+
assert.match(response.error?.message ?? "", testCase.message, testCase.name);
|
|
636
|
+
}
|
|
637
|
+
assert.equal(providerCalls.length, 0);
|
|
638
|
+
});
|
|
639
|
+
it("POST /vm/embedding/probe accepts manager write auth and returns the exact probe DTO using transient credentials", async () => {
|
|
640
|
+
const transientApiKey = "TRANSIENT-API-PROBE-SECRET-PREFIX-opaque-END-API";
|
|
641
|
+
const transientReadKey = "TRANSIENT-READ-PROBE-SECRET-PREFIX-opaque-END-READ";
|
|
642
|
+
const transientWriteKey = "TRANSIENT-WRITE-PROBE-SECRET-PREFIX-opaque-END-WRITE";
|
|
643
|
+
providerResponse = () => new Response(JSON.stringify({
|
|
644
|
+
models: [
|
|
645
|
+
{ key: "zeta-embed", native_dim: 1024 },
|
|
646
|
+
{ key: "alpha-embed", native_dim: 768 },
|
|
647
|
+
],
|
|
648
|
+
}), { status: 200, headers: { "Content-Type": "application/json" } });
|
|
649
|
+
const { status, body } = await fetchJson(port, "POST", "/vm/embedding/probe", {
|
|
650
|
+
body: {
|
|
651
|
+
target: "remote",
|
|
652
|
+
url: "https://provider.example.test/v1/embeddings/",
|
|
653
|
+
workspace: vaultPath,
|
|
654
|
+
model: "zeta-embed",
|
|
655
|
+
transientSecrets: {
|
|
656
|
+
apiKey: transientApiKey,
|
|
657
|
+
readApiKey: transientReadKey,
|
|
658
|
+
writeApiKey: transientWriteKey,
|
|
659
|
+
},
|
|
660
|
+
},
|
|
661
|
+
token: managerToken,
|
|
662
|
+
});
|
|
663
|
+
assert.equal(status, 200);
|
|
664
|
+
assert.deepEqual(providerCalls.map(({ url, method, headers }) => ({
|
|
665
|
+
url,
|
|
666
|
+
method,
|
|
667
|
+
authorization: headers.get("authorization"),
|
|
668
|
+
})), [
|
|
669
|
+
{
|
|
670
|
+
url: "https://provider.example.test/models",
|
|
671
|
+
method: "GET",
|
|
672
|
+
authorization: `Bearer ${transientReadKey}`,
|
|
673
|
+
},
|
|
674
|
+
]);
|
|
675
|
+
assert.deepEqual(body, {
|
|
676
|
+
ok: true,
|
|
677
|
+
target: "remote",
|
|
678
|
+
endpoint: "https://provider.example.test",
|
|
679
|
+
models: [
|
|
680
|
+
{ id: "alpha-embed", name: "alpha-embed", dim: 768 },
|
|
681
|
+
{ id: "zeta-embed", name: "zeta-embed", dim: 1024 },
|
|
682
|
+
],
|
|
683
|
+
selectedModelAvailable: true,
|
|
684
|
+
latencyMs: 0,
|
|
685
|
+
error: null,
|
|
686
|
+
});
|
|
687
|
+
assert.equal(fs.existsSync(secretEnvPath(vaultPath)), false);
|
|
688
|
+
assertResponseExcludes(body, [transientApiKey, transientReadKey, transientWriteKey]);
|
|
689
|
+
});
|
|
690
|
+
it("POST /vm/embedding/probe normalizes provider failures without leaking secrets or response bodies", async () => {
|
|
691
|
+
const transientApiKey = "ERROR-API-PROBE-SECRET-PREFIX-opaque-END-API";
|
|
692
|
+
const transientReadKey = "ERROR-READ-PROBE-SECRET-PREFIX-opaque-END-READ";
|
|
693
|
+
const transientWriteKey = "ERROR-WRITE-PROBE-SECRET-PREFIX-opaque-END-WRITE";
|
|
694
|
+
const providerBody = "PROVIDER-RESPONSE-BODY-PREFIX-sensitive-END-BODY";
|
|
695
|
+
providerResponse = () => new Response(`provider diagnostic: ${providerBody}`, { status: 503 });
|
|
696
|
+
const { status, body } = await fetchJson(port, "POST", "/vm/embedding/probe", {
|
|
697
|
+
body: {
|
|
698
|
+
target: "remote",
|
|
699
|
+
url: "https://provider.example.test/v1",
|
|
700
|
+
transientSecrets: {
|
|
701
|
+
apiKey: transientApiKey,
|
|
702
|
+
readApiKey: transientReadKey,
|
|
703
|
+
writeApiKey: transientWriteKey,
|
|
704
|
+
},
|
|
705
|
+
},
|
|
706
|
+
token: managerToken,
|
|
707
|
+
});
|
|
708
|
+
assert.equal(status, 502);
|
|
709
|
+
assert.deepEqual(body, {
|
|
710
|
+
ok: false,
|
|
711
|
+
target: "remote",
|
|
712
|
+
endpoint: "https://provider.example.test",
|
|
713
|
+
models: [],
|
|
714
|
+
selectedModelAvailable: null,
|
|
715
|
+
latencyMs: null,
|
|
716
|
+
error: { code: "provider_error", message: "Provider returned an error" },
|
|
717
|
+
});
|
|
718
|
+
assert.deepEqual(providerCalls.map(({ url, method, headers }) => ({
|
|
719
|
+
url,
|
|
720
|
+
method,
|
|
721
|
+
authorization: headers.get("authorization"),
|
|
722
|
+
})), [
|
|
723
|
+
{
|
|
724
|
+
url: "https://provider.example.test/models",
|
|
725
|
+
method: "GET",
|
|
726
|
+
authorization: `Bearer ${transientReadKey}`,
|
|
727
|
+
},
|
|
728
|
+
]);
|
|
729
|
+
assert.equal(fs.existsSync(secretEnvPath(vaultPath)), false);
|
|
730
|
+
assertResponseExcludes(body, [
|
|
731
|
+
transientApiKey,
|
|
732
|
+
transientReadKey,
|
|
733
|
+
transientWriteKey,
|
|
734
|
+
providerBody,
|
|
735
|
+
]);
|
|
736
|
+
});
|
|
737
|
+
});
|