kiku-agent 1.3.2 → 1.3.3

package/server/agent/tests/engineUnload.test.js

@@ -0,0 +1,94 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { unloadModelFromEngine } from '../engineService.js';
+import { unloadLmStudioModel } from '../lmStudioWakeup.js';
+import { handleEngineUnloadRoute } from '../../web-chat/routes/engineRoute.js';
+
+describe('Local Inference Engine Unload Pipeline', () => {
+  test('unloadLmStudioModel handles unreachable LM Studio server gracefully', async () => {
+    const res = await unloadLmStudioModel('test-model', {
+      baseUrl: 'http://127.0.0.1:59999/v1',
+      timeoutMs: 500
+    });
+    assert.ok(typeof res.ok === 'boolean');
+    assert.equal(res.engine, 'lms');
+    assert.ok(res.message);
+  });
+
+  test('unloadModelFromEngine routes to lms engine gracefully', async () => {
+    const res = await unloadModelFromEngine('lms', 'google/gemma-4-e4b', {
+      baseUrl: 'http://127.0.0.1:59999/v1',
+      timeoutMs: 500
+    });
+    assert.ok(typeof res.ok === 'boolean');
+    assert.equal(res.engine, 'lms');
+  });
+
+  test('unloadModelFromEngine stops vllm engine background process', async () => {
+    const res = await unloadModelFromEngine('vllm', 'google/gemma-4-e4b');
+    assert.equal(res.ok, true);
+    assert.equal(res.engine, 'vllm');
+    assert.equal(res.unloaded, true);
+    assert.ok(res.message.includes('vLLM'));
+  });
+
+  test('unloadModelFromEngine rejects unknown engine gracefully', async () => {
+    const res = await unloadModelFromEngine('unknown_custom_engine', 'some-model');
+    assert.equal(res.ok, false);
+    assert.ok(res.message.includes('Unsupported engine'));
+  });
+
+  test('handleEngineUnloadRoute handles valid POST request and returns json', async () => {
+    const payloadStr = JSON.stringify({
+      engine: 'vllm',
+      model: 'google/gemma-4-e4b'
+    });
+
+    const mockReq = {
+      method: 'POST',
+      url: '/api/engine/unload',
+      headers: { 'content-type': 'application/json' },
+      socket: { remoteAddress: '127.0.0.1' },
+      on(event, handler) {
+        if (event === 'data') {
+          process.nextTick(() => handler(Buffer.from(payloadStr)));
+        } else if (event === 'end') {
+          process.nextTick(() => handler());
+        }
+        return this;
+      }
+    };
+
+    let statusCode = 0;
+    let headers = {};
+    let responseBody = '';
+
+    const mockRes = {
+      writeHead(code, head) {
+        statusCode = code;
+        headers = head || {};
+      },
+      end(payload) {
+        responseBody = payload;
+      }
+    };
+
+    await handleEngineUnloadRoute(mockReq, mockRes);
+
+    assert.equal(statusCode, 200);
+    assert.ok(headers['Content-Type']?.includes('application/json'));
+    const parsed = JSON.parse(responseBody);
+    assert.equal(parsed.status, 'ok');
+    assert.equal(parsed.engine, 'vllm');
+    assert.ok(parsed.message);
+  });
+
+  test('unloadLmStudioModel handles gguf filename and unloads matched loaded model instance', async () => {
+    const res = await unloadLmStudioModel('gemma-4-E4B-it-Q4_K_M.gguf', {
+      baseUrl: 'http://127.0.0.1:59999/v1',
+      timeoutMs: 300
+    });
+    assert.ok(typeof res.ok === 'boolean');
+    assert.equal(res.engine, 'lms');
+  });
+});

package/server/agent/tests/envCommand.test.js

@@ -121,6 +121,75 @@ test('/env: init writes defaults to an override target without prompting', async
   fs.rmSync(dir, { recursive: true, force: true });
 });
 
+function withInteractiveStdin(fn) {
+  const previousTty = process.stdin.isTTY;
+  process.stdin.isTTY = true;
+  return Promise.resolve(fn()).finally(() => {
+    if (previousTty === undefined) delete process.stdin.isTTY;
+    else process.stdin.isTTY = previousTty;
+  });
+}
+
+test('/env: init routes wizard questions through ctx.readInput (TUI handoff)', async () => {
+  const dir = tmpDir();
+  const target = path.join(dir, '.env');
+
+  const asked = [];
+  const answers = ['', '32768', '', 'n'];
+  const ctx = {
+    sub: 'init',
+    parts: ['/env', 'init'],
+    extra: '',
+    envOverridePath: target,
+    envProbe: false,
+    readInput: async (options) => {
+      asked.push(options);
+      return answers.shift() ?? '';
+    },
+  };
+
+  await withInteractiveStdin(() => routeCommand('/env init', ctx));
+
+  assert.equal(asked.length, 4, 'four wizard questions — no answer leaks into a chat query');
+  assert.ok(asked.every(q => q.history === false), 'wizard answers never enter command history');
+  const map = readEnvFile(target);
+  assert.equal(map.LMSTUDIO_BASE_URL, 'http://127.0.0.1:1234/v1', 'empty answer accepts the default');
+  assert.equal(map.KIKU_CONTEXT_LIMIT, '32768');
+  assert.equal(map.LMSTUDIO_MODELS_DIR, undefined);
+  assert.equal(map.OPENAI_API_KEY, undefined);
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test('/env: init overwrite question goes through ctx.readInput and regenerates the file', async () => {
+  const dir = tmpDir();
+  const packageFile = path.join(dir, 'package.env');
+  const userFile = path.join(dir, 'user.env');
+  fs.writeFileSync(packageFile, 'LMSTUDIO_BASE_URL=http://127.0.0.1:9999/v1\n');
+
+  const asked = [];
+  const answers = ['y', 'http://127.0.0.1:1234/v1', '', '', 'n'];
+  const ctx = {
+    sub: 'init',
+    parts: ['/env', 'init'],
+    extra: '',
+    envTargets: { packageEnvPath: packageFile, userEnvPath: userFile },
+    envProbe: false,
+    readInput: async (options) => {
+      asked.push(options);
+      return answers.shift() ?? '';
+    },
+  };
+
+  await withInteractiveStdin(() => routeCommand('/env init', ctx));
+
+  assert.ok(asked.length >= 1);
+  assert.match(String(asked[0].prompt), /Overwrite/, 'first question is the overwrite confirmation');
+  const map = readEnvFile(packageFile);
+  assert.equal(map.LMSTUDIO_BASE_URL, 'http://127.0.0.1:1234/v1', 'existing file is regenerated after confirm');
+  assert.equal(readEnvFile(userFile), null, 'user env file stays untouched');
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
 test('/env: set/get/unset round-trips through the override target', async () => {
   const dir = tmpDir();
   const target = path.join(dir, '.env');

package/server/agent/tests/evalMetrics.test.js

@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
+  scoreCoverage,
   evaluateToolCorrectness,
   detectTrajectoryLoops,
   computeLatencyBreakdown,
@@ -168,6 +169,13 @@ test('checkGroundedness verifies facts in answer against tool observation data',
   assert.equal(resNoFacts.matchedInAnswer, 0);
 });
 
+test('scoreCoverage uses numeric boundaries instead of substring matches', () => {
+  const caseData = { groups: [['18'], ['3:45']] };
+  const result = scoreCoverage(caseData, 'The value is 1800 and the duration is 13:45.');
+  assert.equal(result.matched, 0);
+  assert.deepEqual(result.missing, [['18'], ['3:45']]);
+});
+
 test('evaluateGates validates thresholds and flags failing metrics', () => {
   const passingSummary = {
     completionRate: 1.0,

package/server/agent/tests/fetchApi.test.js

@@ -0,0 +1,99 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+
+import { toolHandlers } from '../tools.js';
+import { handleApiRequest } from '../../apiRouter.js';
+
+async function withApiServer(run) {
+  const server = createServer((req, res) => {
+    void handleApiRequest(req, res).catch(error => {
+      res.statusCode = 500;
+      res.end(error.message);
+    });
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+
+  const address = server.address();
+  try {
+    await run(`http://127.0.0.1:${address.port}`);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+}
+
+test('fetch_api normalizes paths, prefixes, and aliases against local server', async () => {
+  await withApiServer(async baseUrl => {
+    
+    const worksRes = await toolHandlers.fetch_api({ endpoint: '/api/v1/works', baseUrl });
+    assert.equal(worksRes.status, 'success', `fetch_api with /api/v1/works should succeed: ${JSON.stringify(worksRes)}`);
+    assert.ok(Array.isArray(worksRes.data), 'works data should be an array');
+    assert.equal(worksRes.endpoint, '/works');
+
+   
+    const profileRes = await toolHandlers.fetch_api({ endpoint: 'profile', baseUrl });
+    assert.equal(profileRes.status, 'success');
+    assert.equal(profileRes.endpoint, '/profile');
+    assert.equal(profileRes.data.nameCn, '鞠婧祎');
+
+    
+    const musicRes = await toolHandlers.fetch_api({ endpoint: 'music', baseUrl });
+    assert.equal(musicRes.status, 'success', `fetch_api with 'music' alias should succeed: ${JSON.stringify(musicRes)}`);
+    assert.equal(musicRes.endpoint, '/discography');
+    assert.ok(Array.isArray(musicRes.data));
+
+   
+    const commercialRes = await toolHandlers.fetch_api({ endpoint: 'commercial', baseUrl });
+    assert.equal(commercialRes.status, 'success');
+    assert.equal(commercialRes.endpoint, '/brands');
+    assert.ok(Array.isArray(commercialRes.data));
+
+   
+    const timelineRes = await toolHandlers.fetch_api({ endpoint: 'milestones', baseUrl });
+    assert.equal(timelineRes.status, 'success');
+    assert.equal(timelineRes.endpoint, '/timeline');
+    assert.ok(Array.isArray(timelineRes.data));
+
+   
+    const awardsRes = await toolHandlers.fetch_api({ endpoint: 'honors', baseUrl });
+    assert.equal(awardsRes.status, 'success');
+    assert.equal(awardsRes.endpoint, '/awards');
+    assert.ok(Array.isArray(awardsRes.data));
+
+    
+    const fullUrlRes = await toolHandlers.fetch_api({ endpoint: `${baseUrl}/api/v1/stats`, baseUrl });
+    assert.equal(fullUrlRes.status, 'success');
+    assert.equal(fullUrlRes.endpoint, '/stats');
+    assert.ok(fullUrlRes.data.totalWorks > 0);
+  });
+});
+
+test('apiRouter directly serves new aliases /music, /commercial, /milestones, /honors with HTTP 200', async () => {
+  await withApiServer(async baseUrl => {
+    const [musicRes, commercialRes, milestonesRes, honorsRes] = await Promise.all([
+      fetch(`${baseUrl}/api/v1/music`),
+      fetch(`${baseUrl}/api/v1/commercial`),
+      fetch(`${baseUrl}/api/v1/milestones`),
+      fetch(`${baseUrl}/api/v1/honors`),
+    ]);
+
+    assert.equal(musicRes.status, 200, '/api/v1/music should return HTTP 200');
+    assert.equal(commercialRes.status, 200, '/api/v1/commercial should return HTTP 200');
+    assert.equal(milestonesRes.status, 200, '/api/v1/milestones should return HTTP 200');
+    assert.equal(honorsRes.status, 200, '/api/v1/honors should return HTTP 200');
+
+    const musicJson = await musicRes.json();
+    assert.equal(musicJson.status, 'success');
+    assert.ok(Array.isArray(musicJson.data));
+  });
+});
+
+test('fetch_api rejects missing endpoint gracefully', async () => {
+  const emptyRes = await toolHandlers.fetch_api({});
+  assert.equal(emptyRes.status, 'error');
+  assert.match(emptyRes.message, /endpoint parameter is required/);
+});

package/server/agent/tests/hybridWebSearch.test.js

@@ -120,6 +120,8 @@ test('SSRF Defense rejects private IPs, loopback, and metadata addresses', async
 
 
   assert.equal(isPrivateIPv6('::1'), true);
+  assert.equal(isPrivateIPv6('::ffff:7f00:1'), true);
+  assert.equal(isPrivateIPv6('::7f00:1'), true);
   assert.equal(isPrivateIPv6('fe80::1'), true);
   assert.equal(isPrivateIPv6('fc00::1'), true);
 

package/server/agent/tests/lanDiscovery.test.js

@@ -166,6 +166,11 @@ test('expandTargets rejects invalid specs and enforces the host cap', () => {
   assert.equal(DEFAULT_MAX_SCAN_HOSTS, 4096);
 });
 
+test('expandTargets enforces the cap on unique hosts after overlapping ranges', () => {
+  const targets = expandTargets(['10.0.0.1-10.0.0.4', '10.0.0.1'], { maxHosts: 4 });
+  assert.deepEqual(targets, ['10.0.0.1', '10.0.0.2', '10.0.0.3', '10.0.0.4']);
+});
+
 test('scanLan scans a user-specified custom range instead of the local subnets', async () => {
   clearLanScanCache();
   const probed = [];