@baize-ai/core 0.2.0 → 0.3.1

package/test/a2a-cli.test.js

@@ -0,0 +1,180 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, test, jest } from '@jest/globals';
+import { a2aCliPath, a2aCliCandidates, formatA2aOutput } from '../cli/lib/a2a.js';
+import { a2aCommand, A2A_SUBCOMMANDS } from '../cli/commands/a2a.js';
+
+let tmp;
+let envPath;
+
+beforeEach(() => {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'a2a-cli-'));
+  envPath = path.join(tmp, 'fake-a2a', 'scripts', 'cli.js');
+  fs.mkdirSync(path.dirname(envPath), { recursive: true });
+  fs.writeFileSync(envPath, 'console.log(JSON.stringify({ ok: true }));\n');
+});
+
+afterEach(() => {
+  delete process.env.BAIZE_A2A_PATH;
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+function runCommand(args, { runResult, cli = envPath, exit = () => {}, log = () => {}, logError = () => {} } = {}) {
+  const runA2aCli = runResult !== undefined
+    ? jest.fn(async () => runResult)
+    : jest.fn(async () => ({ success: true, json: { ok: true }, output: '{"ok":true}' }));
+  const result = { exitCode: null, logs: [], errors: [] };
+  return a2aCommand(args, {
+    cliPath: cli,
+    runA2aCli,
+    exit: (code) => { result.exitCode = code; },
+    log: (s) => result.logs.push(s),
+    logError: (s) => result.errors.push(s),
+  }).then(() => ({ runA2aCli, result }));
+}
+
+describe('a2aCliPath resolution', () => {
+  test('BAIZE_A2A_PATH file wins', () => {
+    process.env.BAIZE_A2A_PATH = envPath;
+    expect(a2aCliPath()).toBe(envPath);
+  });
+  test('BAIZE_A2A_PATH directory resolves scripts/cli.js inside', () => {
+    process.env.BAIZE_A2A_PATH = path.dirname(path.dirname(envPath));
+    expect(a2aCliPath()).toBe(envPath);
+  });
+  test('nonexistent env path falls through to candidates', () => {
+    process.env.BAIZE_A2A_PATH = path.join(tmp, 'missing', 'cli.js');
+    const found = a2aCliPath();
+    // In the dev workspace the ../baize-a2a sibling exists and is the fallback;
+    // otherwise (no install anywhere) resolution returns null.
+    const devSibling = a2aCliCandidates().at(-1);
+    if (fs.existsSync(devSibling)) {
+      expect(found).toBe(devSibling);
+    } else {
+      expect(found).toBeNull();
+    }
+  });
+  test('candidate list orders local node_modules → global npm → dev sibling', () => {
+    const candidates = a2aCliCandidates();
+    expect(candidates.length).toBeGreaterThanOrEqual(3);
+    // dev sibling is the final fallback
+    expect(candidates.at(-1).endsWith(path.join('baize-a2a', 'scripts', 'cli.js'))).toBe(true);
+    expect(candidates.some((c) => c.includes(path.join('@baize-ai', 'baize-a2a', 'scripts', 'cli.js')))).toBe(true);
+  });
+});
+
+describe('a2aCommand help and validation', () => {
+  test('no args prints help listing all subcommands', async () => {
+    const { result } = await runCommand([]);
+    const help = result.logs.join('\n');
+    expect(help).toContain('baize a2a');
+    for (const s of ['status', 'enable', 'disable', 'peer list', 'search', 'send', 'task status', 'task cancel']) {
+      expect(help).toContain(s);
+    }
+    expect(result.exitCode).toBeNull();
+  });
+  test('--help prints help without delegating', async () => {
+    const { runA2aCli, result } = await runCommand(['--help']);
+    expect(result.logs.join('\n')).toContain('Subcommands');
+    expect(runA2aCli).not.toHaveBeenCalled();
+  });
+  test('unknown subcommand exits 1 with error', async () => {
+    const { runA2aCli, result } = await runCommand(['bogus']);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors.join('\n')).toMatch(/Unknown a2a subcommand: bogus/);
+    expect(runA2aCli).not.toHaveBeenCalled();
+  });
+  test('exposes every contract subcommand in A2A_SUBCOMMANDS', () => {
+    expect(A2A_SUBCOMMANDS).toEqual(['status', 'enable', 'disable', 'peer', 'search', 'send', 'task']);
+  });
+});
+
+describe('a2aCommand delegation', () => {
+  test('status delegates with --json appended and prints formatted output', async () => {
+    const { runA2aCli, result } = await runCommand(['status'], {
+      runResult: {
+        success: true,
+        json: {
+          enabled: true, agentId: 'agent_1', registered: false, registrationStatus: 'pending',
+          advertiseUrl: 'https://a2a.example.com', endpoint: 'https://a2a.example.com/a2a/v1', version: '0.1.0',
+        },
+        output: '{}',
+      },
+    });
+    expect(runA2aCli).toHaveBeenCalledWith(['status'], expect.objectContaining({ cliPath: envPath }));
+    const out = result.logs.join('\n');
+    expect(out).toContain('启用: 是');
+    expect(out).toContain('已注册: 否');
+    expect(out).toContain('Agent ID: agent_1');
+    expect(out).toContain('注册状态: pending');
+    expect(result.exitCode).toBeNull();
+  });
+  test('enable passes through --admin/--advertise flags', async () => {
+    const { runA2aCli } = await runCommand(['enable', '--admin', 'https://admin.example.com', '--advertise', 'https://a2a.example.com'], {
+      runResult: { success: true, json: { agentId: 'a', registrationId: 'r', status: 'pending' }, output: '{}' },
+    });
+    expect(runA2aCli).toHaveBeenCalledWith(
+      ['enable', '--admin', 'https://admin.example.com', '--advertise', 'https://a2a.example.com'],
+      expect.objectContaining({ cliPath: envPath }),
+    );
+  });
+  test('task dispatch (sync) uses the 10-minute timeout', async () => {
+    const { runA2aCli } = await runCommand(['task', 'agent_x', 'do it'], {
+      runResult: { success: true, json: { taskId: 't1', status: 'completed' }, output: '{}' },
+    });
+    expect(runA2aCli).toHaveBeenCalledWith(['task', 'agent_x', 'do it'], expect.objectContaining({ timeout: 660000 }));
+  });
+  test('task with --async and task status use the default timeout', async () => {
+    const res = { success: true, json: { taskId: 't1', status: 'queued' }, output: '{}' };
+    const a = await runCommand(['task', 'agent_x', 'do it', '--async'], { runResult: res });
+    expect(a.runA2aCli).toHaveBeenCalledWith(['task', 'agent_x', 'do it', '--async'], expect.objectContaining({ timeout: 120000 }));
+    const b = await runCommand(['task', 'status', 't1'], { runResult: res });
+    expect(b.runA2aCli).toHaveBeenCalledWith(['task', 'status', 't1'], expect.objectContaining({ timeout: 120000 }));
+  });
+  test('existing --json flag is not duplicated', async () => {
+    const { runA2aCli } = await runCommand(['status', '--json'], {
+      runResult: { success: true, json: { enabled: false }, output: '{}' },
+    });
+    expect(runA2aCli).toHaveBeenCalledWith(['status', '--json'], expect.anything());
+  });
+  test('missing CLI exits 1 with guidance', async () => {
+    const { runA2aCli, result } = await runCommand(['status'], { cli: null });
+    expect(result.exitCode).toBe(1);
+    expect(result.errors.join('\n')).toMatch(/未找到 baize-a2a CLI/);
+    expect(runA2aCli).not.toHaveBeenCalled();
+  });
+  test('delegated failure prints error and exits 1', async () => {
+    const { result } = await runCommand(['status'], {
+      runResult: { success: false, error: '注册未通过审批', output: '{"error":"注册未通过审批"}' },
+    });
+    expect(result.exitCode).toBe(1);
+    expect(result.errors.join('\n')).toContain('注册未通过审批');
+  });
+});
+
+describe('formatA2aOutput', () => {
+  test('status shapes booleans as 是/否', () => {
+    const out = formatA2aOutput('status', { enabled: true, agentId: 'a1', registered: false });
+    expect(out).toContain('启用: 是');
+    expect(out).toContain('已注册: 否');
+    expect(out).toContain('Agent ID: a1');
+  });
+  test('peer list renders agent entries with endpoints', () => {
+    const out = formatA2aOutput('peer-list', { peers: [{ agentId: 'p1', endpoint: 'https://p1/a2a/v1', skills: [{ id: 's1' }] }] });
+    expect(out).toContain('p1');
+    expect(out).toContain('endpoint: https://p1/a2a/v1');
+    expect(out).toContain('skills: s1');
+  });
+  test('search renders agent rows', () => {
+    const out = formatA2aOutput('search', { agents: [{ agentId: 'x', name: 'X', status: 'approved' }] });
+    expect(out).toContain('x（X）');
+    expect(out).toContain('approved');
+  });
+  test('disable renders ok message', () => {
+    expect(formatA2aOutput('disable', { ok: true })).toContain('A2A 已停用');
+  });
+  test('unknown kind falls back to pretty JSON', () => {
+    expect(formatA2aOutput('weird', { a: 1 })).toContain('"a": 1');
+  });
+});

package/test/agent-card-api.test.js

@@ -0,0 +1,261 @@
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { afterEach, beforeEach, describe, expect, test } from '@jest/globals';
+import Database from '../skills/web-console/node_modules/better-sqlite3/lib/index.js';
+
+const SERVER_PATH = path.resolve('skills/web-console/scripts/server.js');
+
+let ctx;
+
+function freePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+  });
+}
+
+function createDb(dbPath) {
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+  db.exec(`
+    CREATE TABLE conversations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      direction TEXT,
+      channel TEXT,
+      endpoint_id TEXT,
+      content TEXT,
+      timestamp TEXT
+    );
+  `);
+  db.close();
+}
+
+function writeSkill(skillsDir, dir, name, description) {
+  fs.mkdirSync(path.join(skillsDir, dir), { recursive: true });
+  fs.writeFileSync(
+    path.join(skillsDir, dir, 'SKILL.md'),
+    `---\nname: ${name}\ndescription: ${description}\n---\n`
+  );
+}
+
+async function startServer({ envContent = '' } = {}) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'wc-card-api-'));
+  const skillsDir = path.join(root, 'skills');
+  writeSkill(skillsDir, 'doccraft', 'Doc Craft', 'Craft documentation');
+  writeSkill(skillsDir, 'memory', 'Memory', '>-\n  Persistent memory\n  across sessions');
+  writeSkill(skillsDir, 'feishu', 'Feishu', 'Feishu channel');
+  createDb(path.join(root, 'comm-bridge', 'c4.db'));
+  fs.mkdirSync(path.join(root, 'activity-monitor'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'activity-monitor', 'agent-status.json'), '{"state":"idle"}');
+  fs.writeFileSync(path.join(root, '.env'), envContent);
+  const port = await freePort();
+
+  const child = spawn(process.execPath, [SERVER_PATH], {
+    cwd: path.resolve('.'),
+    env: {
+      ...process.env,
+      BAIZE_DIR: root,
+      WEB_CONSOLE_SKILLS_DIR: skillsDir,
+      WEB_CONSOLE_PORT: String(port),
+      WEB_CONSOLE_BIND: '127.0.0.1',
+    },
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+
+  let output = '';
+  child.stdout.on('data', (chunk) => { output += chunk.toString(); });
+  child.stderr.on('data', (chunk) => { output += chunk.toString(); });
+
+  const baseUrl = `http://127.0.0.1:${port}`;
+
+  // /api/health sits behind the auth gate when a password is set — log in first.
+  const passwordMatch = envContent.match(/^BAIZE_WEB_PASSWORD=(.*)$/m);
+  let probeHeaders = {};
+  if (passwordMatch) {
+    const loginDeadline = Date.now() + 5000;
+    while (Date.now() < loginDeadline) {
+      try {
+        const loginRes = await fetch(`${baseUrl}/api/auth`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ password: passwordMatch[1] }),
+        });
+        const setCookie = loginRes.headers.get('set-cookie');
+        if (setCookie) {
+          probeHeaders = { Cookie: setCookie.split(';')[0] };
+          break;
+        }
+      } catch {
+        // Not listening yet — retry.
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+  }
+
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) throw new Error(`server exited early: ${output}`);
+    try {
+      const res = await fetch(`${baseUrl}/api/health`, { headers: probeHeaders });
+      if (res.ok) return { root, skillsDir, baseUrl, child };
+    } catch {
+      // Retry until server is listening.
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+
+  child.kill('SIGTERM');
+  throw new Error(`server did not start: ${output}`);
+}
+
+function stopServer(active) {
+  if (!active) return;
+  active.child.kill('SIGTERM');
+  fs.rmSync(active.root, { recursive: true, force: true });
+}
+
+async function putCard(baseUrl, payload) {
+  const res = await fetch(`${baseUrl}/api/admin/a2a/card`, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+  return { status: res.status, body: await res.json() };
+}
+
+function readConfig(root) {
+  const file = path.join(root, 'components', 'a2a', 'config.json');
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+beforeEach(() => {
+  ctx = null;
+});
+
+afterEach(() => {
+  stopServer(ctx);
+});
+
+describe('web-console agent card API (D21)', () => {
+  test('GET /api/admin/a2a/card/skills lists installed skills sorted by name', async () => {
+    ctx = await startServer();
+    const res = await fetch(`${ctx.baseUrl}/api/admin/a2a/card/skills`);
+    expect(res.status).toBe(200);
+    const { success, skills } = await res.json();
+    expect(success).toBe(true);
+    expect(skills.map((s) => s.id)).toEqual(['doccraft', 'feishu', 'memory']);
+    expect(skills[0]).toMatchObject({ id: 'doccraft', name: 'Doc Craft', description: 'Craft documentation' });
+  });
+
+  test('GET /api/admin/a2a/card returns defaults when config.json is absent', async () => {
+    ctx = await startServer();
+    const res = await fetch(`${ctx.baseUrl}/api/admin/a2a/card`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toMatchObject({ success: true, name: 'Baize Agent', description: 'A Baize agent reachable over the baize-a2a protocol.', skills: [] });
+  });
+
+  test('PUT persists the card to config.json and returns the saved card', async () => {
+    ctx = await startServer();
+    const { status, body } = await putCard(ctx.baseUrl, {
+      name: 'My Baize Agent',
+      description: 'A helpful agent',
+      skills: ['doccraft', 'memory'],
+    });
+    expect(status).toBe(200);
+    expect(body).toMatchObject({
+      success: true,
+      name: 'My Baize Agent',
+      description: 'A helpful agent',
+      skills: [
+        { id: 'doccraft', name: 'Doc Craft', description: 'Craft documentation' },
+        { id: 'memory', name: 'Memory', description: 'Persistent memory across sessions' },
+      ],
+    });
+
+    const cfg = readConfig(ctx.root);
+    expect(cfg.name).toBe('My Baize Agent');
+    expect(cfg.description).toBe('A helpful agent');
+    expect(cfg.skills.map((s) => s.id)).toEqual(['doccraft', 'memory']);
+
+    // GET now reflects the saved card
+    const getRes = await (await fetch(`${ctx.baseUrl}/api/admin/a2a/card`)).json();
+    expect(getRes).toMatchObject({ name: 'My Baize Agent', description: 'A helpful agent' });
+    expect(getRes.skills.map((s) => s.id)).toEqual(['doccraft', 'memory']);
+  });
+
+  test('PUT preserves other config.json fields', async () => {
+    ctx = await startServer();
+    const configDir = path.join(ctx.root, 'components', 'a2a');
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(path.join(configDir, 'config.json'), JSON.stringify({
+      enabled: true,
+      agentId: 'agent-1',
+      advertiseUrl: 'https://a2a.example.com',
+      name: 'Old Name',
+      skills: [],
+      listenPort: 8443,
+    }));
+
+    const { status } = await putCard(ctx.baseUrl, { name: 'New Name', description: '', skills: [] });
+    expect(status).toBe(200);
+    const cfg = readConfig(ctx.root);
+    expect(cfg.enabled).toBe(true);
+    expect(cfg.agentId).toBe('agent-1');
+    expect(cfg.advertiseUrl).toBe('https://a2a.example.com');
+    expect(cfg.listenPort).toBe(8443);
+    expect(cfg.name).toBe('New Name');
+  });
+
+  test('PUT rejects missing or over-long name with 400', async () => {
+    ctx = await startServer();
+    const missing = await putCard(ctx.baseUrl, { description: 'x', skills: [] });
+    expect(missing.status).toBe(400);
+    expect(missing.body.success).toBe(false);
+
+    const tooLong = await putCard(ctx.baseUrl, { name: 'x'.repeat(61), description: '', skills: [] });
+    expect(tooLong.status).toBe(400);
+    expect(tooLong.body.success).toBe(false);
+    expect(tooLong.body.error).toContain('60');
+  });
+
+  test('PUT rejects over-long description with 400', async () => {
+    ctx = await startServer();
+    const res = await putCard(ctx.baseUrl, { name: 'ok', description: 'x'.repeat(301), skills: [] });
+    expect(res.status).toBe(400);
+    expect(res.body.success).toBe(false);
+    expect(res.body.error).toContain('300');
+  });
+
+  test('PUT rejects skills ids that are not installed', async () => {
+    ctx = await startServer();
+    const res = await putCard(ctx.baseUrl, { name: 'ok', description: '', skills: ['doccraft', 'made-up-skill'] });
+    expect(res.status).toBe(400);
+    expect(res.body.success).toBe(false);
+    expect(res.body.error).toContain('made-up-skill');
+    expect(fs.existsSync(path.join(ctx.root, 'components', 'a2a', 'config.json'))).toBe(false);
+  });
+
+  test('PUT rejects duplicate skills ids', async () => {
+    ctx = await startServer();
+    const res = await putCard(ctx.baseUrl, { name: 'ok', description: '', skills: ['doccraft', 'doccraft'] });
+    expect(res.status).toBe(400);
+    expect(res.body.success).toBe(false);
+    expect(res.body.error).toContain('doccraft');
+  });
+
+  test('card routes require session when a password is set', async () => {
+    ctx = await startServer({ envContent: 'BAIZE_WEB_PASSWORD=secret123\n' });
+    const get = await fetch(`${ctx.baseUrl}/api/admin/a2a/card`);
+    expect(get.status).toBe(401);
+    const put = await putCard(ctx.baseUrl, { name: 'x', description: '', skills: [] });
+    expect(put.status).toBe(401);
+  });
+});

package/test/channel-admin.test.js

@@ -233,3 +233,90 @@ describe('installChannel / uninstallChannel', () => {
     expect(ca.cliPath()).toBe(repoCli);
   });
 });
+
+describe('a2a builtin channel (D19 单元 C)', () => {
+  const a2aSchemaKeys = ['enabled', 'adminUrl', 'agentId', 'advertiseUrl', 'listenPort', 'certKeyPath', 'certCertPath'];
+
+  test('catalogue includes a2a with the contract config schema (target: config)', async () => {
+    const channels = await ca.discoverChannels({ fetch: noResultsFetch });
+    const a2a = channels.find((c) => c.name === 'a2a');
+    expect(a2a).toBeTruthy();
+    expect(a2a).toMatchObject({
+      npmPkg: '@baize-ai/baize-a2a',
+      repo: 'baize-ai/baize-a2a',
+      installed: false,
+    });
+    expect(a2a.configSchema.map((f) => f.key)).toEqual(a2aSchemaKeys);
+    expect(a2a.configSchema.every((f) => f.target === 'config')).toBe(true);
+    // nested cert paths persist via dotted configKey
+    expect(a2a.configSchema.find((f) => f.key === 'certKeyPath').configKey).toBe('cert.keyPath');
+    expect(a2a.configSchema.find((f) => f.key === 'certCertPath').configKey).toBe('cert.certPath');
+  });
+
+  test('verify: enabling without adminUrl/advertiseUrl is rejected', async () => {
+    const r1 = await ca.configureChannel('a2a', { enabled: 'true' });
+    expect(r1.success).toBe(false);
+    expect(r1.error).toMatch(/Admin 服务地址/);
+    const r2 = await ca.configureChannel('a2a', { enabled: 'true', adminUrl: 'https://admin.example.com' });
+    expect(r2.success).toBe(false);
+    expect(r2.error).toMatch(/对外宣告地址/);
+  });
+
+  test('disabled config does not require admin/advertise and persists enabled:false', async () => {
+    const r = await ca.configureChannel('a2a', { enabled: 'false' });
+    expect(r.success).toBe(true);
+    const config = JSON.parse(fs.readFileSync(path.join(baizeDir, 'components', 'a2a', 'config.json'), 'utf8'));
+    expect(config.enabled).toBe(false);
+  });
+
+  test('enabled config persists boolean enabled + adminUrl + advertiseUrl + nested cert', async () => {
+    const r = await ca.configureChannel('a2a', {
+      enabled: 'true',
+      adminUrl: 'https://admin.example.com',
+      advertiseUrl: 'https://a2a.example.com',
+      certKeyPath: '/etc/ssl/key.pem',
+      certCertPath: '/etc/ssl/cert.pem',
+    });
+    expect(r.success).toBe(true);
+    const config = JSON.parse(fs.readFileSync(path.join(baizeDir, 'components', 'a2a', 'config.json'), 'utf8'));
+    expect(config.enabled).toBe(true); // real boolean, not "true"
+    expect(config.adminUrl).toBe('https://admin.example.com');
+    expect(config.advertiseUrl).toBe('https://a2a.example.com');
+    expect(config.cert).toEqual({ keyPath: '/etc/ssl/key.pem', certPath: '/etc/ssl/cert.pem' });
+  });
+
+  test('channelStatus for installed a2a: configured only when enabled + both urls', async () => {
+    const entry = (await ca.discoverChannels({ fetch: noResultsFetch })).find((c) => c.name === 'a2a');
+    fs.writeFileSync(path.join(baizeDir, '.baize', 'components.json'), JSON.stringify({
+      a2a: { version: '0.1.0', source: { type: 'npm' } },
+    }));
+    // installed but not configured → not configured
+    const st0 = ca.channelStatus({ ...entry, installed: true }, {});
+    expect(st0.configured).toBe(false);
+    const a2aCfgDir = path.join(baizeDir, 'components', 'a2a');
+    fs.mkdirSync(a2aCfgDir, { recursive: true });
+    // disabled but urls present → not configured
+    fs.writeFileSync(path.join(a2aCfgDir, 'config.json'), JSON.stringify({
+      enabled: false, adminUrl: 'https://admin.example.com', advertiseUrl: 'https://a2a.example.com',
+    }));
+    const st1 = ca.channelStatus({ ...entry, installed: true }, {});
+    expect(st1.configured).toBe(false);
+    expect(st1.configSummary).toContain('未启用');
+    // enabled + urls → configured
+    fs.writeFileSync(path.join(a2aCfgDir, 'config.json'), JSON.stringify({
+      enabled: true, adminUrl: 'https://admin.example.com', advertiseUrl: 'https://a2a.example.com',
+    }));
+    const st2 = ca.channelStatus({ ...entry, installed: true }, {});
+    expect(st2.configured).toBe(true);
+    expect(st2.configSummary).toContain('admin: https://admin.example.com');
+    // generic lifecycle: a2a has no bespoke start/stop → channelAction falls through
+    expect(typeof ca.channelAction).toBe('function');
+  });
+
+  test('a2a lifecycle uses the generic PM2 path (no bespoke start hook)', async () => {
+    const r = await ca.channelAction('a2a', 'start');
+    // not installed → genericLifecycle reports not installed (no bespoke hook crashed)
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/未安装/);
+  });
+});