@baize-ai/core 0.3.14 → 0.3.16

package/test/upgrade-restart-hook.test.js

@@ -0,0 +1,129 @@
+/**
+ * K5: step8 restart hook. A nohup-started baize-a2a daemon (Docker entrypoint)
+ * is invisible to pm2, so the pm2-only restart never refreshed its code (C6).
+ * For service name 'baize-a2a' step8 must prefer `node <a2a-cli> restart`
+ * (daemon-ctl covers nohup pid + pm2 + waitReady), falling back to the
+ * existing pm2 path when the CLI is missing or fails.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, test } from '@jest/globals';
+import { step8_startService } from '../cli/lib/upgrade.js';
+
+let tmp;
+
+beforeEach(() => {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'restart-hook-'));
+});
+
+afterEach(() => {
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+function makeCtx({ component = 'a2a', serviceWasRunning = true, skillMd = null } = {}) {
+  const skillDir = path.join(tmp, component);
+  fs.mkdirSync(skillDir, { recursive: true });
+  if (skillMd) fs.writeFileSync(path.join(skillDir, 'SKILL.md'), skillMd);
+  return {
+    component,
+    skillDir,
+    serviceWasRunning,
+    steps: [],
+    mergeConflicts: [],
+    mergedFiles: [],
+  };
+}
+
+const throwingPm2 = {
+  restartManagedProcess: () => { throw new Error('pm2 restart must not be called'); },
+  restartFromEcosystem: () => { throw new Error('pm2 ecosystem restart must not be called'); },
+};
+
+describe('step8 a2a cli restart hook (K5)', () => {
+  test('service name baize-a2a prefers the a2a cli restart and skips pm2', () => {
+    const ctx = makeCtx();
+    const calls = [];
+    const spawnSyncFn = (cmd, args, opts) => {
+      calls.push({ cmd, args, opts });
+      return { status: 0, stdout: '{"ok":true}' };
+    };
+    const step = step8_startService(ctx, {
+      ...throwingPm2,
+      spawnSyncFn,
+      resolveA2aCli: () => '/fake/a2a/scripts/cli.js',
+    });
+    expect(step.status).toBe('done');
+    expect(step.message).toBe('baize-a2a (a2a cli restart)');
+    expect(calls).toHaveLength(1);
+    expect(calls[0].args[0]).toBe('/fake/a2a/scripts/cli.js');
+    expect(calls[0].args[1]).toBe('restart');
+    // JSON contract on stdout + stdin closed immediately (a2a cli merges stdin)
+    expect(calls[0].args).toContain('--json');
+    expect(calls[0].opts).toMatchObject({ timeout: 120000 });
+    expect(calls[0].opts.input).toBe('');
+  });
+
+  test('hook fires even when pm2 never managed the service (nohup daemon)', () => {
+    // Docker nohup daemon: pm2 jlist has no entry → serviceWasRunning=false.
+    // The hook must still run, otherwise the daemon keeps the old code (C6).
+    const ctx = makeCtx({ serviceWasRunning: false });
+    const step = step8_startService(ctx, {
+      ...throwingPm2,
+      spawnSyncFn: () => ({ status: 0, stdout: '{"ok":true}' }),
+      resolveA2aCli: () => '/fake/a2a/scripts/cli.js',
+    });
+    expect(step.status).toBe('done');
+  });
+
+  test('falls back to the pm2 path when the cli restart fails', () => {
+    const ctx = makeCtx();
+    let restartCalls = 0;
+    const step = step8_startService(ctx, {
+      spawnSyncFn: () => ({ status: 1, stdout: '{"ok":false,"error":"boom"}' }),
+      resolveA2aCli: () => '/fake/a2a/scripts/cli.js',
+      restartManagedProcess: () => { restartCalls += 1; },
+      restartFromEcosystem: () => { throw new Error('unexpected'); },
+    });
+    expect(step.status).toBe('done');
+    expect(step.message).toBe('baize-a2a');
+    expect(restartCalls).toBe(1);
+  });
+
+  test('falls back to the pm2 path when no a2a cli can be resolved', () => {
+    const ctx = makeCtx();
+    let spawnCalls = 0;
+    const step = step8_startService(ctx, {
+      spawnSyncFn: () => { spawnCalls += 1; return { status: 0 }; },
+      resolveA2aCli: () => null,
+      restartManagedProcess: () => {},
+      restartFromEcosystem: () => { throw new Error('unexpected'); },
+    });
+    expect(spawnCalls).toBe(0);
+    expect(step.status).toBe('done');
+    expect(step.message).toBe('baize-a2a');
+  });
+
+  test('non-a2a components never trigger the hook (pm2 path directly)', () => {
+    const ctx = makeCtx({
+      component: 'telegram',
+      skillMd: '---\nname: telegram\nlifecycle:\n  service:\n    name: baize-telegram\n---\n# T\n',
+    });
+    let spawnCalls = 0;
+    const step = step8_startService(ctx, {
+      spawnSyncFn: () => { spawnCalls += 1; return { status: 0 }; },
+      restartManagedProcess: () => {},
+      restartFromEcosystem: () => { throw new Error('unexpected'); },
+    });
+    expect(spawnCalls).toBe(0);
+    expect(step.status).toBe('done');
+    expect(step.message).toBe('baize-telegram');
+  });
+
+  test('non-a2a component that was not running stays skipped', () => {
+    const ctx = makeCtx({ component: 'telegram', serviceWasRunning: false });
+    const step = step8_startService(ctx, { ...throwingPm2, spawnSyncFn: () => ({ status: 0 }) });
+    expect(step.status).toBe('skipped');
+    expect(step.message).toBe('was not running');
+  });
+});

package/test/web-console-routes.test.js

@@ -744,7 +744,7 @@ describe('web-console a2a authz routes (D22 单元 C)', () => {
     expect(await res.json()).toEqual({ success: true, mode: 'open', allow: [], block: [] });
   });
 
-  test('PUT authz validates mode enum and list entries', async () => {
+  test('PUT authz validates mode enum; allow/block ignored and forced empty (D52 governance)', async () => {
     ctx = await startServer({ extraEnv: a2aEnv() });
     const put = async (body) => {
       const res = await fetch(`${ctx.baseUrl}/api/admin/a2a/authz`, {
@@ -754,17 +754,15 @@ describe('web-console a2a authz routes (D22 单元 C)', () => {
       });
       return { status: res.status, body: await res.json() };
     };
-    expect((await put({ mode: 'bogus' })).status).toBe(400);
-    expect((await put({ mode: 'open', allow: 'x' })).status).toBe(400);      // allow not an array
-    expect((await put({ mode: 'open', block: [''], allow: [] })).status).toBe(400); // empty string element
-    expect((await put({ mode: 'open', block: [42], allow: [] })).status).toBe(400); // non-string element
-    expect((await put({ mode: 'open', block: ['a', 'a'], allow: [] })).status).toBe(400); // duplicate
-    const ok = await put({ mode: 'allowlist', allow: ['peer_1', 'peer_2'], block: [] });
+    expect((await put({ mode: 'bogus' })).status).toBe(400);           // invalid mode rejected
+    expect((await put({})).status).toBe(400);                          // missing mode rejected
+    // D52: lists are admin-managed — any allow/block payload is ignored → []
+    const ok = await put({ mode: 'allowlist', allow: ['peer_1', 'peer_2'], block: ['x'] });
     expect(ok.status).toBe(200);
-    expect(ok.body).toEqual({ success: true, mode: 'allowlist', allow: ['peer_1', 'peer_2'], block: [] });
+    expect(ok.body).toEqual({ success: true, mode: 'allowlist', allow: [], block: [] });
   });
 
-  test('PUT authz writes config.json preserving other fields and trims entries', async () => {
+  test('PUT authz writes config.json preserving other fields; lists forced empty', async () => {
     ctx = await startServer({ extraEnv: a2aEnv() });
     const res = await fetch(`${ctx.baseUrl}/api/admin/a2a/authz`, {
       method: 'PUT',
@@ -772,16 +770,16 @@ describe('web-console a2a authz routes (D22 单元 C)', () => {
       body: JSON.stringify({ mode: 'open', allow: [], block: ['  peer_9  ', 'peer_10'] }),
     });
     expect(res.status).toBe(200);
-    expect(await res.json()).toEqual({ success: true, mode: 'open', allow: [], block: ['peer_9', 'peer_10'] });
+    expect(await res.json()).toEqual({ success: true, mode: 'open', allow: [], block: [] });
     const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
-    expect(cfg.authz).toEqual({ mode: 'open', allow: [], block: ['peer_9', 'peer_10'] });
+    expect(cfg.authz).toEqual({ mode: 'open', allow: [], block: [] });
     expect(cfg.enabled).toBe(true);
     expect(cfg.agentId).toBe('agent_test');
     expect(cfg.cert).toEqual({ keyPath: '', certPath: '' });
     expect(cfg.name).toBeUndefined();
   });
 
-  test('PUT authz creates config.json when missing', async () => {
+  test('PUT authz creates config.json when missing (mode only)', async () => {
     fs.rmSync(configFile());
     ctx = await startServer({ extraEnv: a2aEnv() });
     const res = await fetch(`${ctx.baseUrl}/api/admin/a2a/authz`, {
@@ -791,7 +789,7 @@ describe('web-console a2a authz routes (D22 单元 C)', () => {
     });
     expect(res.status).toBe(200);
     const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
-    expect(cfg.authz).toEqual({ mode: 'allowlist', allow: ['peer_1'], block: [] });
+    expect(cfg.authz).toEqual({ mode: 'allowlist', allow: [], block: [] });
   });
 
   test('authz routes require session when a password is set', async () => {
@@ -827,6 +825,11 @@ switch (args[0]) {
     break;
   case 'enable': out({ ok: true, ...(mode ? { mode } : {}) }); break;
   case 'disable': out({ ok: true, ...(mode ? { mode } : {}) }); break;
+  case 'restart':
+    // D49 K3: upgrade pipeline must restart the daemon via the a2a cli.
+    require('fs').writeFileSync(process.env.BAIZE_A2A_PATH + '/restart-called', '1');
+    out({ ok: true });
+    break;
   default: console.error('unknown: ' + args.join(' ')); process.exit(1);
 }
 `);
@@ -1030,21 +1033,95 @@ switch (args[0]) {
     });
   });
 
-  test('install rejects when a2a is already installed', async () => {
+  test('second upload with the same version is rejected as version_not_higher (409)', async () => {
     ctx = await startServer({ extraEnv: a2aEnv() });
     const tgz = buildTarball({ 'package.json': validManifest });
     try {
       const first = await installUpload(ctx, tgz);
       expect(first.status).toBe(200);
       const second = await installUpload(ctx, tgz);
-      expect(second.status).toBe(400);
-      expect(second.body).toMatchObject({ ok: false });
-      expect(second.body.error).toMatch(/已安装/);
+      expect(second.status).toBe(409);
+      expect(second.body).toMatchObject({
+        ok: false,
+        error: 'version_not_higher',
+        local: '9.9.9',
+        incoming: '9.9.9',
+      });
+      // Installation untouched by the rejected upload
+      const pkg = JSON.parse(fs.readFileSync(path.join(ctx.skillsDir, 'a2a', 'package.json'), 'utf8'));
+      expect(pkg.version).toBe('9.9.9');
     } finally {
       fs.rmSync(tgz, { force: true });
     }
   });
 
+  test('uploading a lower version than installed is rejected with local/incoming detail', async () => {
+    ctx = await startServer({ extraEnv: a2aEnv() });
+    const v1 = buildTarball({ 'package.json': validManifest });
+    const v0 = buildTarball({ 'package.json': JSON.stringify({ name: '@baize-ai/baize-a2a', version: '1.0.0' }) });
+    try {
+      expect((await installUpload(ctx, v1)).status).toBe(200);
+      const downgrade = await installUpload(ctx, v0);
+      expect(downgrade.status).toBe(409);
+      expect(downgrade.body).toMatchObject({ ok: false, error: 'version_not_higher', local: '9.9.9', incoming: '1.0.0' });
+      const pkg = JSON.parse(fs.readFileSync(path.join(ctx.skillsDir, 'a2a', 'package.json'), 'utf8'));
+      expect(pkg.version).toBe('9.9.9');
+    } finally {
+      fs.rmSync(v1, { force: true });
+      fs.rmSync(v0, { force: true });
+    }
+  });
+
+  test('uploading a higher version upgrades in place: files replaced, components.json bumped, a2a cli restart called', async () => {
+    ctx = await startServer({ extraEnv: a2aEnv() });
+    const v1 = buildTarball({
+      'package.json': validManifest,
+      'SKILL.md': '---\nname: a2a\n---\n# A2A v9\n',
+    });
+    const v2 = buildTarball({
+      'package.json': JSON.stringify({ name: '@baize-ai/baize-a2a', version: '10.0.0' }),
+      'SKILL.md': '---\nname: a2a\nversion: 10.0.0\n---\n# A2A v10\n',
+      'new-module.js': 'export const fresh = true;\n',
+    });
+    try {
+      expect((await installUpload(ctx, v1)).status).toBe(200);
+      const second = await installUpload(ctx, v2);
+      expect(second.status).toBe(200);
+      expect(second.body).toMatchObject({
+        ok: true,
+        version: '10.0.0',
+        previousVersion: '9.9.9',
+        upgraded: true,
+        restarted: true,
+      });
+      // K3/K5: the upgrade restarted the daemon through the a2a cli
+      expect(fs.existsSync(path.join(fakeA2aDir, 'restart-called'))).toBe(true);
+      // Files replaced in place
+      const pkg = JSON.parse(fs.readFileSync(path.join(ctx.skillsDir, 'a2a', 'package.json'), 'utf8'));
+      expect(pkg.version).toBe('10.0.0');
+      expect(fs.readFileSync(path.join(ctx.skillsDir, 'a2a', 'new-module.js'), 'utf8')).toContain('fresh');
+      // Registration preserved, version bumped, both timestamps present
+      const components = JSON.parse(fs.readFileSync(path.join(ctx.root, '.baize', 'components.json'), 'utf8'));
+      expect(components.a2a).toMatchObject({
+        version: '10.0.0',
+        repo: 'baize-ai/baize-a2a',
+        skillDir: path.join(ctx.skillsDir, 'a2a'),
+      });
+      expect(components.a2a.installedAt).toBeTruthy();
+      expect(components.a2a.upgradedAt).toBeTruthy();
+      // Backup taken before any write (upgrade.js .backup convention)
+      const backupRoot = path.join(ctx.skillsDir, 'a2a', '.backup');
+      expect(fs.readdirSync(backupRoot)).toHaveLength(1);
+      // Backup holds the pre-upgrade code
+      const backupTs = fs.readdirSync(backupRoot)[0];
+      const backupPkg = JSON.parse(fs.readFileSync(path.join(backupRoot, backupTs, 'package.json'), 'utf8'));
+      expect(backupPkg.version).toBe('9.9.9');
+    } finally {
+      fs.rmSync(v1, { force: true });
+      fs.rmSync(v2, { force: true });
+    }
+  });
+
   test('install requires a session when a password is set', async () => {
     ctx = await startServer({ envContent: 'BAIZE_WEB_PASSWORD=secret123\n', extraEnv: a2aEnv() });
     const res = await fetch(`${ctx.baseUrl}/api/admin/a2a/install`, { method: 'POST' });