433 lines
16 KiB
JavaScript
433 lines
16 KiB
JavaScript
const { test } = require('node:test'),
|
|
assert = require('node:assert/strict'),
|
|
fs = require('node:fs/promises'),
|
|
os = require('node:os'),
|
|
path = require('node:path');
|
|
const admin = {
|
|
user: { id: 'admin', username: 'admin', role: 'admin' },
|
|
sessionId: 'admin-session',
|
|
},
|
|
operator = {
|
|
user: { id: 'operator', username: 'operator', role: 'operator' },
|
|
sessionId: 'operator-session',
|
|
},
|
|
viewer = {
|
|
user: { id: 'viewer', username: 'viewer', role: 'viewer' },
|
|
sessionId: 'viewer-session',
|
|
};
|
|
async function fixture(t, runtime) {
|
|
const { AssistantStore } = require('../../src/modules/assistant/store.cjs'),
|
|
{ AssistantService } = require('../../src/modules/assistant/service.cjs');
|
|
const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'order-assistant-')),
|
|
store = new AssistantStore(dir);
|
|
let checks = 0,
|
|
scans = 0,
|
|
archives = 0;
|
|
const connections = [
|
|
{
|
|
id: 'own',
|
|
owner: 'operator',
|
|
name: 'Own BPM',
|
|
status: 'connected',
|
|
identity: 'PRIVATE_IDENTITY',
|
|
},
|
|
{ id: 'other', owner: 'other', name: 'Other BPM', status: 'connected' },
|
|
];
|
|
const workspace = {
|
|
snapshot: () => ({
|
|
connections,
|
|
exceptions: [
|
|
{
|
|
id: 'e1',
|
|
owner: 'operator',
|
|
title: '扫描失败',
|
|
status: 'open',
|
|
description: 'password=PRIVATE_PASSWORD Cookie=PRIVATE_COOKIE',
|
|
},
|
|
],
|
|
}),
|
|
getConnection: (id) => connections.find((c) => c.id === id),
|
|
record() {},
|
|
};
|
|
const storage = {
|
|
store: {
|
|
servers: () => [
|
|
{
|
|
id: 'server',
|
|
name: 'Archive',
|
|
enabled: true,
|
|
username: 'SECRET_USER',
|
|
password: 'PRIVATE_PASSWORD',
|
|
state: { readable: true, writable: true, message: 'open C:/PRIVATE_FOLDER/file.txt' },
|
|
},
|
|
],
|
|
archives: () => [
|
|
{
|
|
id: 'archive',
|
|
status: 'error',
|
|
serverId: 'server',
|
|
jobId: 'pdf',
|
|
baseDirectory: '产业A',
|
|
error: '共享不可用',
|
|
},
|
|
],
|
|
},
|
|
check: async () => {
|
|
checks++;
|
|
return { state: { readable: true, writable: true } };
|
|
},
|
|
archive: async () => {
|
|
archives++;
|
|
return { status: 'success', relativePath: '产业A/123456/file.pdf' };
|
|
},
|
|
};
|
|
const scanner = {
|
|
store: {
|
|
status: () => ({
|
|
config: { enabled: true },
|
|
runs: [
|
|
{ connectionId: 'own', status: 'success' },
|
|
{ connectionId: 'other', status: 'error', message: 'Cookie=PRIVATE_COOKIE' },
|
|
],
|
|
}),
|
|
},
|
|
scan: async () => {
|
|
scans++;
|
|
return { seen: 2, added: 0 };
|
|
},
|
|
};
|
|
const dashboard = {
|
|
jobs: () => [
|
|
{
|
|
jobId: 'pdf',
|
|
status: 'success',
|
|
path: 'C:/PRIVATE_PATH/file.pdf',
|
|
metadata: { order: '123456' },
|
|
},
|
|
],
|
|
};
|
|
const service = new AssistantService({
|
|
store,
|
|
workspace,
|
|
storage,
|
|
scanner,
|
|
dashboard,
|
|
runtime: runtime || {
|
|
probe: async () => ({ available: true, version: '3.14.3' }),
|
|
chat: async () => JSON.stringify({ reply: '已查询状态', actions: [] }),
|
|
},
|
|
});
|
|
t.after(async () => {
|
|
await service.stop();
|
|
store.close();
|
|
await fs.rm(dir, { recursive: true, force: true });
|
|
});
|
|
store.saveSettings({
|
|
...store.settings(),
|
|
enabled: true,
|
|
runtimePath: process.execPath,
|
|
apiBase: 'https://models.example/v1',
|
|
model: 'test-model',
|
|
apiKey: 'PRIVATE_API_KEY',
|
|
allowActions: true,
|
|
});
|
|
return { dir, store, service, workspace, counters: () => ({ checks, scans, archives }) };
|
|
}
|
|
|
|
test('configured DSH is usable without a separate enable switch', async (t) => {
|
|
const { store, service } = await fixture(t);
|
|
store.saveSettings({ ...store.settings(), enabled: false });
|
|
const conversation = store.create(admin.user.id);
|
|
const turn = service.send(conversation.id, admin, '测试配置');
|
|
await service.running.get(turn.id).task;
|
|
assert.equal(store.conversation(conversation.id, admin.user.id).turns[0].status, 'success');
|
|
});
|
|
|
|
test('nested JSON and complete credential headers are absent from runtime inputs and persisted history', async (t) => {
|
|
const calls = [],
|
|
payload =
|
|
'{"nested":{"password":"dummy p a s s","cookie":"dummy=a; dummy2=b","authorization":"Basic dummy credential"}}\nCookie: dummySession=x; dummyCsrf=y\nAuthorization: Custom dummy auth value\nC:/local/private.txt';
|
|
const { store, service } = await fixture(t, {
|
|
chat: async (input) => {
|
|
calls.push(input);
|
|
return JSON.stringify({ reply: payload, actions: [] });
|
|
},
|
|
}),
|
|
conversation = store.create(admin.user.id);
|
|
for (const text of [payload, 'follow up']) {
|
|
const turn = service.send(conversation.id, admin, text);
|
|
await service.running.get(turn.id).task;
|
|
}
|
|
const actual = JSON.stringify({
|
|
inputs: calls.map(({ config, signal, ...input }) => input),
|
|
persisted: store.conversation(conversation.id, admin.user.id),
|
|
});
|
|
for (const secret of [
|
|
'dummy p a s s',
|
|
'dummy=a',
|
|
'dummy2=b',
|
|
'dummy credential',
|
|
'dummySession=x',
|
|
'dummyCsrf=y',
|
|
'dummy auth value',
|
|
'local/private.txt',
|
|
])
|
|
assert.equal(actual.includes(secret), false, secret);
|
|
});
|
|
|
|
test('structured credential values at arbitrary depth and escaped JSON logs are removed before runtime and store', async (t) => {
|
|
const calls = [],
|
|
deep = {
|
|
password: { a: { b: { c: 'FAKE_DEEP_SECRET' } } },
|
|
nested: [{ cookie: [{ a: [{ b: 'FAKE_ARRAY_SECRET' }] }] }],
|
|
variants: {
|
|
access_token: 'FAKE_ACCESS_SECRET',
|
|
refreshToken: 'FAKE_REFRESH_SECRET',
|
|
'CLIENT-SECRET': 'FAKE_CLIENT_SECRET',
|
|
secret: 'FAKE_BARE_SECRET',
|
|
'session_cookie': 'FAKE_SESSION_SECRET',
|
|
},
|
|
},
|
|
escaped = { payload: { token: { a: { b: { c: 'FAKE_ESCAPED_SECRET' } } } } };
|
|
const payloads = [
|
|
JSON.stringify(deep, null, 2),
|
|
'debug ' + JSON.stringify(JSON.stringify(escaped)),
|
|
];
|
|
const { store, service } = await fixture(t, {
|
|
chat: async (input) => {
|
|
calls.push(input);
|
|
return JSON.stringify({ reply: payloads.join('\n'), actions: [] });
|
|
},
|
|
}),
|
|
conversation = store.create(admin.user.id);
|
|
for (const text of payloads) {
|
|
const turn = service.send(conversation.id, admin, text);
|
|
await service.running.get(turn.id).task;
|
|
}
|
|
const actual = JSON.stringify({
|
|
inputs: calls.map(({ config, signal, ...input }) => input),
|
|
persisted: store.conversation(conversation.id, admin.user.id),
|
|
});
|
|
assert.doesNotMatch(
|
|
actual,
|
|
/FAKE_(?:DEEP|ARRAY|ESCAPED|ACCESS|REFRESH|CLIENT|BARE|SESSION)_SECRET/,
|
|
);
|
|
});
|
|
test('assistant conversations are private, encrypted and survive restart without exposing the API key', async (t) => {
|
|
const { AssistantStore } = require('../../src/modules/assistant/store.cjs'),
|
|
{ dir, store, service } = await fixture(t),
|
|
c = store.create(admin.user.id);
|
|
const turn = service.send(c.id, admin, 'PRIVATE_CHAT_MESSAGE');
|
|
await service.running.get(turn.id).task;
|
|
assert.throws(
|
|
() => store.conversation(c.id, operator.user.id),
|
|
(e) => e.status === 404,
|
|
);
|
|
assert.deepEqual(store.conversations(operator.user.id), []);
|
|
assert.equal(store.settings().hasApiKey, true);
|
|
assert.equal(store.settings().apiKey, undefined);
|
|
const restart = new AssistantStore(dir);
|
|
try {
|
|
assert.equal(restart.conversation(c.id, admin.user.id).turns[0].text, 'PRIVATE_CHAT_MESSAGE');
|
|
assert.equal(restart.secretSettings().apiKey, 'PRIVATE_API_KEY');
|
|
} finally {
|
|
restart.close();
|
|
}
|
|
for (const name of await fs.readdir(dir))
|
|
if (name.includes('.sqlite')) {
|
|
const bytes = await fs.readFile(path.join(dir, name));
|
|
assert.equal(bytes.includes(Buffer.from('PRIVATE_CHAT_MESSAGE')), false);
|
|
assert.equal(bytes.includes(Buffer.from('PRIVATE_API_KEY')), false);
|
|
}
|
|
});
|
|
test('model gets only permitted diagnostic fields and unsupported actions never execute', async (t) => {
|
|
let request;
|
|
const runtime = {
|
|
chat: async (input) => {
|
|
request = input;
|
|
return JSON.stringify({
|
|
reply: '状态已读取',
|
|
actions: [{ kind: 'shell', targetId: 'server' }],
|
|
});
|
|
},
|
|
};
|
|
const { store, service, counters } = await fixture(t, runtime),
|
|
c = store.create(operator.user.id),
|
|
turn = service.send(c.id, operator, '分析失败');
|
|
await service.running.get(turn.id).task;
|
|
const context = JSON.stringify(request.context);
|
|
assert.doesNotMatch(context, /PRIVATE_|SECRET_USER|C:\/|Other BPM|other"/);
|
|
assert.equal(store.conversation(c.id, operator.user.id).turns[0].status, 'error');
|
|
assert.deepEqual(counters(), { checks: 0, scans: 0, archives: 0 });
|
|
});
|
|
test('fixed action cards require opt-in and current role, check ownership and are single use', async (t) => {
|
|
const runtime = {
|
|
chat: async () =>
|
|
JSON.stringify({
|
|
reply: '建议检查共享',
|
|
actions: [
|
|
{ kind: 'check_storage', targetId: 'server' },
|
|
{ kind: 'scan_bpm', targetId: 'own' },
|
|
{ kind: 'retry_archive', targetId: 'archive' },
|
|
],
|
|
}),
|
|
};
|
|
const { store, service, counters } = await fixture(t, runtime),
|
|
c = store.create(admin.user.id),
|
|
turn = service.send(c.id, admin, '检查情况');
|
|
await service.running.get(turn.id).task;
|
|
let saved = store.conversation(c.id, admin.user.id).turns[0];
|
|
assert.deepEqual(counters(), { checks: 0, scans: 0, archives: 0 });
|
|
assert.equal(saved.actions.length, 3);
|
|
await assert.rejects(
|
|
service.executeAction(c.id, saved.actions[0].id, {
|
|
...viewer,
|
|
user: { ...viewer.user, id: admin.user.id },
|
|
}),
|
|
(e) => e.status === 403,
|
|
);
|
|
for (const action of saved.actions) await service.executeAction(c.id, action.id, admin);
|
|
assert.deepEqual(counters(), { checks: 1, scans: 1, archives: 1 });
|
|
await assert.rejects(
|
|
service.executeAction(c.id, saved.actions[0].id, admin),
|
|
(e) => e.status === 409,
|
|
);
|
|
store.saveSettings({ ...store.settings(), apiKey: '', allowActions: false });
|
|
saved = store.conversation(c.id, admin.user.id).turns[0];
|
|
assert.ok(saved.actions.every((a) => a.status === 'success'));
|
|
});
|
|
test('unauthorized BPM targets are rejected, and disabling actions also blocks previously proposed cards', async (t) => {
|
|
let other = true;
|
|
const { store, service, counters } = await fixture(t, {
|
|
chat: async () =>
|
|
JSON.stringify({
|
|
reply: '建议扫描',
|
|
actions: [{ kind: 'scan_bpm', targetId: other ? 'other' : 'own' }],
|
|
}),
|
|
}),
|
|
c = store.create(operator.user.id);
|
|
let turn = service.send(c.id, operator, '扫描');
|
|
await service.running.get(turn.id).task;
|
|
assert.equal(store.conversation(c.id, operator.user.id).turns[0].status, 'error');
|
|
other = false;
|
|
turn = service.send(c.id, operator, '扫描我的连接');
|
|
await service.running.get(turn.id).task;
|
|
const action = store.conversation(c.id, operator.user.id).turns.at(-1).actions[0];
|
|
store.saveSettings({ ...store.settings(), apiKey: '', allowActions: false });
|
|
await assert.rejects(service.executeAction(c.id, action.id, operator), (e) => e.status === 403);
|
|
assert.equal(counters().scans, 0);
|
|
});
|
|
test('cancellation, per-conversation serialization and daily limits retain truthful task states', async (t) => {
|
|
const { store, service } = await fixture(t, {
|
|
chat: ({ signal }) =>
|
|
new Promise((resolve, reject) => {
|
|
if (signal.aborted) reject(signal.reason);
|
|
else signal.addEventListener('abort', () => reject(signal.reason), { once: true });
|
|
}),
|
|
}),
|
|
c = store.create(admin.user.id);
|
|
store.saveSettings({ ...store.settings(), apiKey: '', dailyLimit: 1 });
|
|
const turn = service.send(c.id, admin, '分析');
|
|
assert.throws(
|
|
() => service.send(c.id, admin, '重复'),
|
|
(e) => e.status === 409,
|
|
);
|
|
service.cancel(c.id, admin);
|
|
await service.running.get(turn.id).task;
|
|
assert.equal(store.conversation(c.id, admin.user.id).turns[0].status, 'cancelled');
|
|
assert.throws(
|
|
() => service.send(c.id, admin, '第二次'),
|
|
(e) => e.status === 429,
|
|
);
|
|
});
|
|
test('a failing diagnostic source does not leave an un-cancellable running turn', async (t) => {
|
|
const { store, service } = await fixture(t),
|
|
c = store.create(admin.user.id),
|
|
status = service.deps.scanner.store.status;
|
|
service.deps.scanner.store.status = () => {
|
|
throw new Error('damaged source');
|
|
};
|
|
assert.throws(() => service.send(c.id, admin, '分析'));
|
|
assert.equal(store.conversation(c.id, admin.user.id).turns.length, 0);
|
|
service.deps.scanner.store.status = status;
|
|
const turn = service.send(c.id, admin, '再次分析');
|
|
await service.running.get(turn.id).task;
|
|
assert.equal(store.conversation(c.id, admin.user.id).turns[0].status, 'success');
|
|
});
|
|
test('a known API key pasted into an earlier message never reappears in follow-up model history', async (t) => {
|
|
const calls = [],
|
|
{ store, service } = await fixture(t, {
|
|
chat: async (input) => {
|
|
calls.push(input);
|
|
return JSON.stringify({ reply: '已读取状态', actions: [] });
|
|
},
|
|
}),
|
|
c = store.create(admin.user.id);
|
|
let turn = service.send(c.id, admin, 'PRIVATE_API_KEY');
|
|
await service.running.get(turn.id).task;
|
|
store.saveSettings({
|
|
...store.settings(),
|
|
apiKey: 'NEW_API_KEY',
|
|
apiBase: 'https://new-models.example/v1',
|
|
});
|
|
turn = service.send(c.id, admin, '继续' + '字'.repeat(2998));
|
|
await service.running.get(turn.id).task;
|
|
assert.doesNotMatch(JSON.stringify(calls.map(({ config, ...rest }) => rest)), /PRIVATE_API_KEY/);
|
|
assert.match(calls[1].history[0].user, /已隐藏/);
|
|
assert.equal(calls[1].text.length, 3000);
|
|
assert.equal(store.conversation(c.id, admin.user.id).turns.at(-1).text.length, 3000);
|
|
});
|
|
test('a cancellation signal alone cannot label an unconfirmed runtime failure as stopped', async (t) => {
|
|
const { store, service } = await fixture(t, {
|
|
chat: ({ signal }) =>
|
|
new Promise((resolve, reject) =>
|
|
signal.addEventListener('abort', () => reject(new Error('cleanup failed')), {
|
|
once: true,
|
|
}),
|
|
),
|
|
}),
|
|
c = store.create(admin.user.id),
|
|
turn = service.send(c.id, admin, '分析');
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
service.cancel(c.id, admin);
|
|
await service.running.get(turn.id).task;
|
|
assert.equal(store.conversation(c.id, admin.user.id).turns[0].status, 'error');
|
|
});
|
|
test('only a pinned DSH runtime is discovered without enabling a model', async (t) => {
|
|
const { AssistantStore } = require('../../src/modules/assistant/store.cjs');
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), 'order-dsh-discovery-')),
|
|
old = process.env.LOCALAPPDATA;
|
|
process.env.LOCALAPPDATA = root;
|
|
t.after(async () => {
|
|
if (old === undefined) delete process.env.LOCALAPPDATA;
|
|
else process.env.LOCALAPPDATA = old;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
});
|
|
const base = path.join(
|
|
root,
|
|
'OrderNotificationAutomationRuntimes/dsh-0.2.1-rc.2/node_modules/@deepseek-ai/dsh',
|
|
),
|
|
runtimePath = path.join(base, 'lib/bin.js');
|
|
await fs.mkdir(path.dirname(runtimePath), { recursive: true });
|
|
await fs.writeFile(runtimePath, 'fixture');
|
|
await fs.writeFile(
|
|
path.join(base, 'package.json'),
|
|
JSON.stringify({ name: '@deepseek-ai/dsh', version: '0.2.1-rc.2' }),
|
|
);
|
|
const store = new AssistantStore(path.join(root, 'assistant'));
|
|
assert.equal(store.settings().runtimePath, runtimePath);
|
|
assert.equal(store.settings().enabled, false);
|
|
assert.equal(store.settings().hasApiKey, false);
|
|
store.close();
|
|
await fs.writeFile(
|
|
path.join(base, 'package.json'),
|
|
JSON.stringify({ name: '@deepseek-ai/dsh', version: 'unverified' }),
|
|
);
|
|
const changed = new AssistantStore(path.join(root, 'assistant'));
|
|
try {
|
|
assert.equal(changed.settings().runtimePath, '');
|
|
} finally {
|
|
changed.close();
|
|
}
|
|
});
|