@baize-ai/core 0.3.13 → 0.3.15

package/test/upgrade-file.test.js

@@ -0,0 +1,229 @@
+/**
+ * K4 e2e: `baize upgrade <name> --file <tgz>` — offline commercial upgrade
+ * channel. The tarball IS the source (checkForUpdates/downloadToTemp skipped);
+ * version gate via K6 getLocalVersion (package.json first); the existing
+ * 9-step runUpgrade pipeline (backup → smart merge → npm install → baseline →
+ * restart) executes unchanged, with rollback on failure.
+ */
+import { describe, test, expect, beforeAll, afterAll } from '@jest/globals';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import {
+  generateManifest,
+  loadManifest,
+  saveMergeBaseline,
+} from '../cli/lib/manifest.js';
+
+const DRIVER = path.join(import.meta.dirname, 'helpers', 'run-upgrade-file-driver.mjs');
+
+let tmpRoot;
+let baizeDir;
+let skillsDir;
+let shimDir;
+let failFlag;
+
+function mkTmp() {
+  return fs.mkdtempSync(path.join(tmpRoot, 'test-'));
+}
+
+function writeFile(dir, relPath, content) {
+  const full = path.join(dir, relPath);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content);
+}
+
+function readFile(dir, relPath) {
+  return fs.readFileSync(path.join(dir, relPath), 'utf8');
+}
+
+/** Install a v1 fixture: real skill dir + authoritative baseline manifest +
+ * components.json registration (required: upgrade refuses unregistered comps). */
+function installV1(name) {
+  const dest = path.join(skillsDir, name);
+  const source = mkTmp();
+  writeFile(source, 'a.js', 'v1');
+  writeFile(source, 'package.json', JSON.stringify({ name, version: '1.0.0' }));
+  writeFile(dest, 'a.js', 'v1');
+  writeFile(dest, 'package.json', JSON.stringify({ name, version: '1.0.0' }));
+  saveMergeBaseline(dest, source, generateManifest(source));
+  const componentsFile = path.join(baizeDir, '.baize', 'components.json');
+  fs.mkdirSync(path.dirname(componentsFile), { recursive: true });
+  const components = JSON.parse(fs.existsSync(componentsFile) ? fs.readFileSync(componentsFile, 'utf8') : '{}');
+  components[name] = {
+    version: '1.0.0',
+    repo: `baize-ai/${name}`,
+    skillDir: dest,
+    installedAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(componentsFile, JSON.stringify(components, null, 2));
+  return dest;
+}
+
+/** Pack a real .tgz (single wrapper dir, npm publish layout). */
+function buildTarball(name, version, { pkgName = name, aContent = `v-${version}` } = {}) {
+  const dir = mkTmp();
+  writeFile(dir, path.join('package', 'a.js'), aContent);
+  writeFile(dir, path.join('package', 'package.json'), JSON.stringify({ name: pkgName, version }));
+  const out = path.join(os.tmpdir(), `upgrade-file-${name}-${version}-${Math.random().toString(36).slice(2)}.tgz`);
+  execTar(dir);
+  fs.rmSync(dir, { recursive: true, force: true });
+  return out;
+
+  function execTar(from) {
+    spawnSync('tar', ['czf', out, '-C', from, 'package'], { encoding: 'utf8' });
+  }
+}
+
+function runFileUpgrade(name, tgzPath, { check = false } = {}) {
+  const args = [DRIVER, name, tgzPath];
+  if (check) args.push('--check');
+  const child = spawnSync(process.execPath, args, {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      BAIZE_DIR: baizeDir,
+      PATH: shimDir + path.delimiter + process.env.PATH,
+      BAIZE_TEST_BASELINE_COMMIT_FAIL: '0',
+    },
+    timeout: 60000,
+  });
+  let body = null;
+  try { body = JSON.parse(child.stdout); } catch { /* surfaced below */ }
+  return { status: child.status, stderr: child.stderr, body };
+}
+
+beforeAll(() => {
+  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'baize-upgrade-file-e2e-'));
+  baizeDir = path.join(tmpRoot, 'baize-home');
+  skillsDir = path.join(baizeDir, '.claude', 'skills');
+  fs.mkdirSync(skillsDir, { recursive: true });
+
+  // npm shim: the pipeline's step4 must never hit the network; the fail flag
+  // lets a test exercise rollback-on-npm-install-failure.
+  shimDir = path.join(tmpRoot, 'shim-bin');
+  fs.mkdirSync(shimDir, { recursive: true });
+  failFlag = path.join(shimDir, 'npm-fail');
+  fs.writeFileSync(path.join(shimDir, 'npm'), [
+    '#!/bin/sh',
+    `if [ -e "${failFlag}" ]; then echo "simulated npm failure" >&2; exit 1; fi`,
+    'exit 0',
+    '',
+  ].join('\n'), { mode: 0o755 });
+});
+
+afterAll(() => {
+  fs.rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+describe('baize upgrade <name> --file <tgz> (K4)', () => {
+  test('upgrades through the real 9-step pipeline from a local tarball', () => {
+    const name = 'file-upgrade-happy';
+    const skillDir = installV1(name);
+    const tgz = buildTarball(name, '2.0.0', { aContent: 'v2' });
+
+    const { status, body } = runFileUpgrade(name, tgz);
+
+    expect(status).toBe(0);
+    expect(body.success).toBe(true);
+    expect(body.from).toBe('1.0.0');
+    expect(body.to).toBe('2.0.0');
+    expect(body.source).toMatchObject({ type: 'local-tarball' });
+    // Pipeline actually ran (steps 1-9 present) — not a shortcut path
+    const stepNames = body.steps.map((s) => s.name);
+    expect(stepNames).toEqual(expect.arrayContaining(['stop_service', 'backup', 'smart_merge', 'npm_install', 'commit_baseline']));
+    // New files landed
+    expect(readFile(skillDir, 'a.js')).toBe('v2');
+    expect(JSON.parse(readFile(skillDir, 'package.json')).version).toBe('2.0.0');
+    // Authoritative baseline advanced to the tarball content
+    const manifest = loadManifest(skillDir);
+    expect(manifest.files['a.js']).toBeDefined();
+    // components.json bumped
+    const components = JSON.parse(readFile(path.join(baizeDir, '.baize'), 'components.json'));
+    expect(components[name].version).toBe('2.0.0');
+    expect(components[name].upgradedAt).toBeTruthy();
+    fs.rmSync(tgz, { force: true });
+  });
+
+  test('rejects a tarball whose version is not higher (version_not_higher)', () => {
+    const name = 'file-upgrade-gate';
+    installV1(name);
+    const tgz = buildTarball(name, '1.0.0', { aContent: 'should-not-land' });
+
+    const { status, body } = runFileUpgrade(name, tgz);
+
+    expect(status).toBe(1);
+    expect(body.success).toBe(false);
+    expect(body.error).toBe('version_not_higher');
+    expect(body.local).toBe('1.0.0');
+    expect(body.incoming).toBe('1.0.0');
+    // Installation untouched
+    expect(readFile(path.join(skillsDir, name), 'a.js')).toBe('v1');
+    const components = JSON.parse(readFile(path.join(baizeDir, '.baize'), 'components.json'));
+    expect(components[name].version).toBe('1.0.0');
+    fs.rmSync(tgz, { force: true });
+  });
+
+  test('rejects a downgrade the same way', () => {
+    const name = 'file-upgrade-downgrade';
+    installV1(name);
+    const tgz = buildTarball(name, '0.9.0', { aContent: 'old-code' });
+
+    const { status, body } = runFileUpgrade(name, tgz);
+
+    expect(status).toBe(1);
+    expect(body.error).toBe('version_not_higher');
+    expect(body.incoming).toBe('0.9.0');
+    expect(readFile(path.join(skillsDir, name), 'a.js')).toBe('v1');
+    fs.rmSync(tgz, { force: true });
+  });
+
+  test('rejects a tarball whose package name mismatches the installed component', () => {
+    const name = 'file-upgrade-mismatch';
+    installV1(name);
+    const tgz = buildTarball(name, '2.0.0', { pkgName: 'some-other-package' });
+
+    const { status, body } = runFileUpgrade(name, tgz);
+
+    expect(status).toBe(1);
+    expect(body.success).toBe(false);
+    expect(body.error).toMatch(/manifest name mismatch/);
+    expect(readFile(path.join(skillsDir, name), 'a.js')).toBe('v1');
+    fs.rmSync(tgz, { force: true });
+  });
+
+  test('rolls back the installation when npm install fails mid-pipeline', () => {
+    const name = 'file-upgrade-rollback';
+    const skillDir = installV1(name);
+    const tgz = buildTarball(name, '2.0.0', { aContent: 'v2' });
+
+    fs.writeFileSync(failFlag, '');
+    try {
+      const { status, body } = runFileUpgrade(name, tgz);
+      expect(status).toBe(1);
+      expect(body.success).toBe(false);
+      expect(body.failedStep).toBe(4);
+      expect(body.rollback?.performed).toBe(true);
+      // Original code restored from .backup
+      expect(readFile(skillDir, 'a.js')).toBe('v1');
+      expect(JSON.parse(readFile(skillDir, 'package.json')).version).toBe('1.0.0');
+    } finally {
+      fs.rmSync(failFlag, { force: true });
+    }
+    fs.rmSync(tgz, { force: true });
+  });
+
+  test('--check compares versions without touching the installation', () => {
+    const name = 'file-upgrade-check';
+    installV1(name);
+    const tgz = buildTarball(name, '2.0.0');
+
+    const { status, body } = runFileUpgrade(name, tgz, { check: true });
+
+    expect(status).toBe(0);
+    expect(body).toMatchObject({ action: 'check', success: true, hasUpdate: true, current: '1.0.0', latest: '2.0.0' });
+    expect(readFile(path.join(skillsDir, name), 'a.js')).toBe('v1');
+    fs.rmSync(tgz, { force: true });
+  });
+});

package/test/upgrade-local-version.test.js

@@ -0,0 +1,70 @@
+/**
+ * K6: getLocalVersion must read skillDir/package.json version first (SKILL.md
+ * frontmatter is stale by design — it historically stayed at 0.1.0 while
+ * package.json advanced, breaking upgrade version gating). SKILL.md remains
+ * the fallback for components that never shipped a package.json.
+ */
+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 { getLocalVersion } from '../cli/lib/upgrade.js';
+
+let tmp;
+
+beforeEach(() => {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'local-version-'));
+});
+
+afterEach(() => {
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+function write(rel, content) {
+  const full = path.join(tmp, rel);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content);
+}
+
+describe('getLocalVersion reads package.json first (K6)', () => {
+  test('package.json version wins over SKILL.md frontmatter', () => {
+    write('SKILL.md', '---\nname: a2a\nversion: 0.1.0\n---\n# A2A\n');
+    write('package.json', JSON.stringify({ name: 'x', version: '0.2.0' }));
+    expect(getLocalVersion(tmp)).toEqual({ success: true, version: '0.2.0' });
+  });
+
+  test('falls back to SKILL.md frontmatter when package.json is absent', () => {
+    write('SKILL.md', '---\nname: a2a\nversion: 1.2.3\n---\n# A2A\n');
+    expect(getLocalVersion(tmp)).toEqual({ success: true, version: '1.2.3' });
+  });
+
+  test('falls back to SKILL.md when package.json version is invalid semver', () => {
+    write('SKILL.md', '---\nname: a2a\nversion: 3.4.5\n---\n# A2A\n');
+    write('package.json', JSON.stringify({ name: 'x', version: 'not-a-version' }));
+    expect(getLocalVersion(tmp)).toEqual({ success: true, version: '3.4.5' });
+  });
+
+  test('falls back to SKILL.md when package.json is unparseable', () => {
+    write('SKILL.md', '---\nname: a2a\nversion: 3.4.5\n---\n# A2A\n');
+    write('package.json', '{broken');
+    expect(getLocalVersion(tmp)).toEqual({ success: true, version: '3.4.5' });
+  });
+
+  test('prerelease versions in package.json are accepted', () => {
+    write('package.json', JSON.stringify({ name: 'x', version: '0.2.0-beta.1' }));
+    expect(getLocalVersion(tmp)).toEqual({ success: true, version: '0.2.0-beta.1' });
+  });
+
+  test('fails when neither source has a version', () => {
+    write('SKILL.md', '---\nname: a2a\n---\n# A2A\n');
+    const result = getLocalVersion(tmp);
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/Version not found/);
+  });
+
+  test('fails for a missing skill dir', () => {
+    const missing = path.join(tmp, 'nope');
+    const result = getLocalVersion(missing);
+    expect(result.success).toBe(false);
+  });
+});

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

@@ -827,6 +827,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 +1035,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' });