@autobest-ui/agent 1.0.0

package/plugins/autobest-delivery/mcp-server/tests/runner.test.mjs

@@ -0,0 +1,354 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { PathPolicyError, resolveWorkspacePaths } from '../src/paths.mjs';
+import {
+  activeBlockedRunCount,
+  checkEnvironment,
+  resolveBlockedRun,
+  runFeatureE2E
+} from '../src/runner.mjs';
+import { startFixtureServer } from './fixture-server.mjs';
+
+const testsRoot = path.dirname(fileURLToPath(import.meta.url));
+const fixtureScenario = path.join(testsRoot, 'fixtures', 'basic.feature.mjs');
+
+async function createWorkspace() {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'autobest-delivery-'));
+  const scenarioPath = path.join(root, 'feature', 'e2e', 'e2e.feature.mjs');
+  await fs.mkdir(path.dirname(scenarioPath), { recursive: true });
+  await fs.copyFile(fixtureScenario, scenarioPath);
+  return { root, scenarioPath };
+}
+
+test('checkEnvironment 能启动插件自带浏览器', async () => {
+  const result = await checkEnvironment();
+  assert.equal(result.ready, true, result.error);
+  assert.match(result.browserVersion, /^\d+\./);
+  assert.match(result.browserStorage, /autobest-delivery/);
+});
+
+test('checkEnvironment 能报告浏览器运行时缺失', async () => {
+  const result = await checkEnvironment({
+    load: async () => {
+      throw new Error('缺少浏览器可执行文件');
+    }
+  });
+  assert.equal(result.ready, false);
+  assert.match(result.error, /缺少浏览器可执行文件/);
+});
+
+test('runFeatureE2E 能执行冻结场景并写入可审查证据', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspace = await createWorkspace();
+  t.after(() => fs.rm(workspace.root, { recursive: true, force: true }));
+  const before = await fs.readFile(workspace.scenarioPath, 'utf8');
+  const protectedFiles = {
+    'package.json': '{"private":true}\n',
+    'yarn.lock': '# sentinel\n',
+    'config/build.json': '{"sentinel":true}\n',
+    'node_modules/sentinel.txt': 'unchanged\n'
+  };
+  for (const [relativePath, content] of Object.entries(protectedFiles)) {
+    const target = path.join(workspace.root, relativePath);
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await fs.writeFile(target, content, 'utf8');
+  }
+
+  const result = await runFeatureE2E({
+    workspaceRoot: workspace.root,
+    scenarioPath: path.relative(workspace.root, workspace.scenarioPath),
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/e2e/runs/iteration-01',
+    iteration: 1,
+    timeoutMs: 15000
+  });
+
+  assert.equal(result.status, 'passed');
+  assert.equal(result.checks.length, 2);
+  assert.equal(result.checks.every(item => item.isPass), true);
+  assert.deepEqual(
+    result.checks.map(item => [
+      item.reportModule,
+      item.reportGroup,
+      item.reportTitle,
+      item.reportMethod
+    ]),
+    [
+      ['运行器测试页', 'fixture-heading', '页面标题', '检查页面标题是否正确显示。'],
+      ['运行器测试页', 'fixture-result', '运行结果', '检查操作后的运行结果是否正确显示。']
+    ]
+  );
+  assert.equal(result.captures.length, 1);
+  assert.equal(await fs.readFile(workspace.scenarioPath, 'utf8'), before);
+  for (const [relativePath, content] of Object.entries(protectedFiles)) {
+    assert.equal(await fs.readFile(path.join(workspace.root, relativePath), 'utf8'), content);
+  }
+  await fs.access(path.join(workspace.root, result.resultPath));
+  await fs.access(path.join(workspace.root, result.tracePath));
+  await fs.access(path.join(workspace.root, result.captures[0]));
+});
+
+test('报告 schema v1 拒绝缺少通用分组字段的检查', async t => {
+  const workspace = await createWorkspace();
+  t.after(() => fs.rm(workspace.root, { recursive: true, force: true }));
+  await fs.writeFile(
+    workspace.scenarioPath,
+    `export const metadata = { reportSchemaVersion: 1, visualMappings: [] };
+export default async function ({ check }) {
+  await check({
+    id: 'missing-report-group',
+    specSnippet: '检查必须声明报告分组。',
+    scene: 'initial',
+    errorType: '功能缺陷',
+    expect: '分组字段完整'
+  }, async () => '不应执行');
+}\n`,
+    'utf8'
+  );
+
+  const result = await runFeatureE2E({
+    workspaceRoot: workspace.root,
+    scenarioPath: path.relative(workspace.root, workspace.scenarioPath),
+    baseUrl: 'http://127.0.0.1:1',
+    outputDir: 'feature/e2e/runs/missing-report-group',
+    timeoutMs: 10000
+  });
+
+  assert.equal(result.status, 'blocked');
+  assert.match(result.blockers[0].detail, /reportModule/);
+});
+
+test('runFeatureE2E 将已完成的断言失败报告为 failed', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspace = await createWorkspace();
+  t.after(() => fs.rm(workspace.root, { recursive: true, force: true }));
+  await fs.writeFile(
+    workspace.scenarioPath,
+    `export default async function ({ page, expect, check, baseUrl }) {
+  await page.goto(baseUrl);
+  await check({
+    id: 'expected-failure',
+    specSnippet: '缺少内容时检查应失败。',
+    scene: 'initial',
+    errorType: '功能缺陷',
+    expect: '不存在的内容可见'
+  }, async () => expect(page.getByText('不存在的内容')).toBeVisible());
+}\n`,
+    'utf8'
+  );
+
+  const result = await runFeatureE2E({
+    workspaceRoot: workspace.root,
+    scenarioPath: path.relative(workspace.root, workspace.scenarioPath),
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/e2e/runs/failed',
+    timeoutMs: 10000
+  });
+
+  assert.equal(result.status, 'failed');
+  assert.equal(result.checks[0].isPass, false);
+});
+
+test('runFeatureE2E 在隔离 scene 阻塞后继续执行后续 scene', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspace = await createWorkspace();
+  t.after(() => fs.rm(workspace.root, { recursive: true, force: true }));
+  await fs.writeFile(
+    workspace.scenarioPath,
+    `export const metadata = { scenes: ['blocked-selection', 'later-content'] };
+export default async function ({ scene }) {
+  await scene('blocked-selection', async ({ page, baseUrl }) => {
+    await page.goto(baseUrl);
+    throw new Error('Year 2020 option not found');
+  });
+  await scene('later-content', async ({ page, expect, check, baseUrl }) => {
+    await page.goto(baseUrl);
+    await check({
+      id: 'later-heading',
+      specSnippet: '后续独立场景仍应执行。',
+      scene: 'later-content',
+      errorType: '功能缺陷',
+      expect: '后续标题可见'
+    }, async () => {
+      await expect(page.getByRole('heading', { name: '交付测试页' })).toBeVisible();
+      return '后续场景已执行';
+    });
+  });
+}\n`,
+    'utf8'
+  );
+
+  const result = await runFeatureE2E({
+    workspaceRoot: workspace.root,
+    scenarioPath: path.relative(workspace.root, workspace.scenarioPath),
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/e2e/runs/isolated-scenes',
+    timeoutMs: 10000
+  });
+
+  assert.equal(result.status, 'blocked');
+  assert.equal(result.blockers.length, 1);
+  assert.equal(result.blockers[0].kind, 'scenario');
+  assert.equal(result.blockers[0].scene, 'blocked-selection');
+  assert.deepEqual(result.checks.map(item => item.id), ['later-heading']);
+  assert.equal(result.checks[0].isPass, true);
+});
+
+test('runFeatureE2E 在 scene 尚未记录检查时保留原始 blocker', async t => {
+  const workspace = await createWorkspace();
+  t.after(() => fs.rm(workspace.root, { recursive: true, force: true }));
+  await fs.writeFile(
+    workspace.scenarioPath,
+    `export const metadata = { scenes: ['year-selection'] };
+export default async function ({ scene }) {
+  await scene('year-selection', async () => {
+    throw new Error('Year 2020 option not found');
+  });
+}\n`,
+    'utf8'
+  );
+
+  const result = await runFeatureE2E({
+    workspaceRoot: workspace.root,
+    scenarioPath: path.relative(workspace.root, workspace.scenarioPath),
+    baseUrl: 'http://127.0.0.1:1',
+    outputDir: 'feature/e2e/runs/blocked-before-check',
+    timeoutMs: 10000
+  });
+
+  assert.equal(result.status, 'blocked');
+  assert.equal(result.checks.length, 0);
+  assert.deepEqual(result.blockers, [{
+    kind: 'scenario',
+    scene: 'year-selection',
+    detail: 'Year 2020 option not found'
+  }]);
+});
+
+test('runFeatureE2E 将无效场景语法报告为 blocked', async t => {
+  const workspace = await createWorkspace();
+  t.after(() => fs.rm(workspace.root, { recursive: true, force: true }));
+  await fs.writeFile(workspace.scenarioPath, 'export default function ( {', 'utf8');
+
+  const result = await runFeatureE2E({
+    workspaceRoot: workspace.root,
+    scenarioPath: path.relative(workspace.root, workspace.scenarioPath),
+    baseUrl: 'http://127.0.0.1:1',
+    outputDir: 'feature/e2e/runs/invalid',
+    timeoutMs: 1000
+  });
+
+  assert.equal(result.status, 'blocked');
+  assert.equal(result.blockers[0].kind, 'scenario');
+});
+
+test('runFeatureE2E 拒绝包导入和 Node 全局变量', async t => {
+  const workspace = await createWorkspace();
+  t.after(() => fs.rm(workspace.root, { recursive: true, force: true }));
+  await fs.writeFile(
+    workspace.scenarioPath,
+    "import fs from 'node:fs';\nexport default async function () { return fs; }\n",
+    'utf8'
+  );
+
+  const result = await runFeatureE2E({
+    workspaceRoot: workspace.root,
+    scenarioPath: path.relative(workspace.root, workspace.scenarioPath),
+    baseUrl: 'http://127.0.0.1:1',
+    outputDir: 'feature/e2e/runs/import',
+    timeoutMs: 1000
+  });
+
+  assert.equal(result.status, 'blocked');
+  assert.match(result.blockers[0].detail, /不得使用 import/);
+});
+
+test('runFeatureE2E 超时后关闭浏览器并保持可复用', async t => {
+  const workspace = await createWorkspace();
+  t.after(() => fs.rm(workspace.root, { recursive: true, force: true }));
+  await fs.writeFile(
+    workspace.scenarioPath,
+    'export default async function () { await new Promise(() => {}); }\n',
+    'utf8'
+  );
+
+  const result = await runFeatureE2E({
+    workspaceRoot: workspace.root,
+    scenarioPath: path.relative(workspace.root, workspace.scenarioPath),
+    baseUrl: 'http://127.0.0.1:1',
+    outputDir: 'feature/e2e/runs/timeout',
+    timeoutMs: 100
+  });
+
+  assert.equal(result.status, 'blocked');
+  assert.equal(result.blockers[0].kind, 'environment');
+  assert.match(result.blockers[0].detail, /超时/);
+  assert.equal((await checkEnvironment()).ready, true);
+});
+
+test('Blocked 运行可保留浏览器并记录人工 skip 决议', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspace = await createWorkspace();
+  t.after(() => fs.rm(workspace.root, { recursive: true, force: true }));
+  await fs.writeFile(
+    workspace.scenarioPath,
+    `export default async function ({ page, baseUrl }) {
+  await page.goto(baseUrl);
+  throw new Error('等待人工确认');
+}\n`,
+    'utf8'
+  );
+
+  const result = await runFeatureE2E({
+    workspaceRoot: workspace.root,
+    scenarioPath: path.relative(workspace.root, workspace.scenarioPath),
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/e2e/runs/human-decision',
+    timeoutMs: 10000,
+    headed: false,
+    keepBrowserOpenOnBlock: true,
+    blockedSessionTtlMs: 60000
+  });
+
+  assert.equal(result.status, 'blocked');
+  assert.match(result.blockedSessionId, /^[0-9a-f-]{36}$/);
+  assert.equal(result.blockedSessionExpiresAt !== null, true);
+  assert.equal(activeBlockedRunCount(), 1);
+
+  const decision = await resolveBlockedRun({
+    sessionId: result.blockedSessionId,
+    decision: 'skip',
+    note: '用户接受未完成的 E2E 证据。'
+  });
+  assert.equal(decision.status, 'resolved');
+  assert.equal(decision.effect, 'continue-with-waiver');
+  assert.equal(activeBlockedRunCount(), 0);
+
+  const recorded = JSON.parse(
+    await fs.readFile(path.join(workspace.root, decision.decisionPath), 'utf8')
+  );
+  assert.equal(recorded.decision, 'skip');
+  assert.equal(recorded.runnerResult, result.resultPath);
+});
+
+test('工作区策略拒绝场景和输出路径越界', async t => {
+  const workspace = await createWorkspace();
+  t.after(() => fs.rm(workspace.root, { recursive: true, force: true }));
+
+  await assert.rejects(
+    resolveWorkspacePaths({
+      workspaceRoot: workspace.root,
+      scenarioPath: workspace.scenarioPath,
+      outputDir: '../outside'
+    }),
+    PathPolicyError
+  );
+});

package/plugins/autobest-delivery/scripts/export-delivery-report.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import { exportDeliveryReport } from '../mcp-server/src/report.mjs';
+
+function usage() {
+  return '用法：node scripts/export-delivery-report.mjs <功能目录> [--output <功能目录内的 xlsx 路径>] [--workspace-root <工作区>] [--grouping <功能目录内的语义分组 JSON>]';
+}
+
+function parseArgs(argv) {
+  const values = [...argv];
+  const featureDir = values.shift();
+  if (!featureDir || featureDir.startsWith('--')) {
+    throw new Error(usage());
+  }
+  const options = { featureDir };
+  while (values.length > 0) {
+    const flag = values.shift();
+    const value = values.shift();
+    if (!value) {
+      throw new Error(`${flag} 缺少参数\n${usage()}`);
+    }
+    if (flag === '--output') {
+      options.outputPath = value;
+    } else if (flag === '--workspace-root') {
+      options.workspaceRoot = value;
+    } else if (flag === '--grouping') {
+      options.groupingPath = value;
+    } else {
+      throw new Error(`未知参数：${flag}\n${usage()}`);
+    }
+  }
+  return options;
+}
+
+try {
+  const result = await exportDeliveryReport(parseArgs(process.argv.slice(2)));
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+}

package/plugins/autobest-delivery/scripts/setup.mjs

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { cp, mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const PLUGIN_NAME = 'autobest-delivery';
+const MARKETPLACE_NAME = 'autobest-team';
+const PLUGIN_SELECTOR = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+const sourcePluginRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const packageRoot = path.resolve(sourcePluginRoot, '..', '..');
+const agentHome = path.resolve(
+  process.env.AUTOBEST_AGENT_HOME || path.join(os.homedir(), '.autobest-agent')
+);
+const marketplaceRoot = path.join(agentHome, 'marketplaces', MARKETPLACE_NAME);
+const marketplacePath = path.join(marketplaceRoot, '.agents', 'plugins', 'marketplace.json');
+const installedPluginRoot = path.join(marketplaceRoot, 'plugins', PLUGIN_NAME);
+const npmCommand = process.env.AUTOBEST_AGENT_NPM_COMMAND ||
+  (process.platform === 'win32' ? 'npm.cmd' : 'npm');
+const codexCommand = process.env.AUTOBEST_AGENT_CODEX_COMMAND ||
+  (process.platform === 'win32' ? 'codex.exe' : 'codex');
+
+const marketplace = {
+  name: MARKETPLACE_NAME,
+  interface: {
+    displayName: 'Autobest Team'
+  },
+  plugins: [
+    {
+      name: PLUGIN_NAME,
+      source: {
+        source: 'local',
+        path: `./plugins/${PLUGIN_NAME}`
+      },
+      policy: {
+        installation: 'AVAILABLE',
+        authentication: 'ON_INSTALL'
+      },
+      category: 'Productivity'
+    }
+  ]
+};
+
+function printHelp() {
+  process.stdout.write(`Autobest Delivery 插件安装器
+
+用法：
+  autobest-delivery-setup [install]
+  autobest-delivery-setup uninstall
+  autobest-delivery-setup --help
+
+命令：
+  install     安装或更新插件（默认）
+  uninstall   卸载插件并删除 Autobest 专用市场目录
+`);
+}
+
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      env: process.env,
+      stdio: 'inherit',
+      ...options
+    });
+
+    child.once('error', error => {
+      reject(new Error(`无法执行 ${command}：${error.message}`, { cause: error }));
+    });
+    child.once('exit', code => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${command} ${args.join(' ')} 执行失败，状态码为 ${code}`));
+    });
+  });
+}
+
+function runJson(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.once('error', error => {
+      reject(new Error(`无法执行 ${command}：${error.message}`, { cause: error }));
+    });
+    child.once('exit', code => {
+      if (code !== 0) {
+        reject(new Error(
+          `${command} ${args.join(' ')} 执行失败，状态码为 ${code}${stderr ? `\n${stderr.trim()}` : ''}`
+        ));
+        return;
+      }
+      try {
+        resolve(JSON.parse(stdout));
+      } catch (error) {
+        reject(new Error(`${command} 未返回有效 JSON，请升级 Codex CLI。`, { cause: error }));
+      }
+    });
+  });
+}
+
+function isExcludedSourcePath(source) {
+  const relative = path.relative(sourcePluginRoot, source);
+  if (!relative) {
+    return false;
+  }
+  return relative.split(path.sep).some(part => part === 'node_modules' || part === '.runtime');
+}
+
+async function readPackageVersion() {
+  const packageJson = JSON.parse(await readFile(path.join(packageRoot, 'package.json'), 'utf8'));
+  if (typeof packageJson.version !== 'string' || !packageJson.version) {
+    throw new Error('npm 包 package.json 缺少有效的 version。');
+  }
+  return packageJson.version;
+}
+
+async function preparePlugin() {
+  const stagingParent = path.join(agentHome, '.staging');
+  await mkdir(stagingParent, { recursive: true });
+  const stagingRoot = await mkdtemp(path.join(stagingParent, `${PLUGIN_NAME}-`));
+  const stagedPluginRoot = path.join(stagingRoot, PLUGIN_NAME);
+
+  try {
+    await cp(sourcePluginRoot, stagedPluginRoot, {
+      recursive: true,
+      filter: source => !isExcludedSourcePath(source)
+    });
+
+    const manifestPath = path.join(stagedPluginRoot, '.codex-plugin', 'plugin.json');
+    const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+    manifest.version = `${await readPackageVersion()}+codex.npm`;
+    await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+
+    const serverRoot = path.join(stagedPluginRoot, 'mcp-server');
+    await run(npmCommand, ['ci'], { cwd: serverRoot });
+
+    const playwrightCommand = path.join(
+      serverRoot,
+      'node_modules',
+      '.bin',
+      process.platform === 'win32' ? 'playwright.cmd' : 'playwright'
+    );
+    const browserRoot = path.join(serverRoot, '.runtime', 'ms-playwright');
+    const existingBrowserRoot = path.join(
+      installedPluginRoot,
+      'mcp-server',
+      '.runtime',
+      'ms-playwright'
+    );
+    try {
+      await cp(existingBrowserRoot, browserRoot, { recursive: true });
+    } catch (error) {
+      if (!error || error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+    await run(playwrightCommand, ['install', 'chromium'], {
+      cwd: serverRoot,
+      env: {
+        ...process.env,
+        PLAYWRIGHT_BROWSERS_PATH: browserRoot
+      }
+    });
+
+    return { stagingRoot, stagedPluginRoot };
+  } catch (error) {
+    await rm(stagingRoot, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+async function replaceInstalledPlugin(stagedPluginRoot, stagingRoot) {
+  await mkdir(path.dirname(installedPluginRoot), { recursive: true });
+  const backupRoot = `${installedPluginRoot}.previous`;
+  await rm(backupRoot, { recursive: true, force: true });
+
+  let hasBackup = false;
+  try {
+    await rename(installedPluginRoot, backupRoot);
+    hasBackup = true;
+  } catch (error) {
+    if (!error || error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  try {
+    await rename(stagedPluginRoot, installedPluginRoot);
+    await rm(backupRoot, { recursive: true, force: true });
+  } catch (error) {
+    if (hasBackup) {
+      await rename(backupRoot, installedPluginRoot);
+    }
+    throw error;
+  } finally {
+    await rm(stagingRoot, { recursive: true, force: true });
+  }
+}
+
+async function writeMarketplace() {
+  await mkdir(path.dirname(marketplacePath), { recursive: true });
+  await writeFile(marketplacePath, `${JSON.stringify(marketplace, null, 2)}\n`, 'utf8');
+}
+
+async function getCodexState() {
+  const [marketplacesResult, pluginsResult] = await Promise.all([
+    runJson(codexCommand, ['plugin', 'marketplace', 'list', '--json']),
+    runJson(codexCommand, ['plugin', 'list', '--json'])
+  ]);
+  return {
+    marketplaces: Array.isArray(marketplacesResult.marketplaces)
+      ? marketplacesResult.marketplaces
+      : [],
+    installed: Array.isArray(pluginsResult.installed) ? pluginsResult.installed : []
+  };
+}
+
+async function configureCodex() {
+  const state = await getCodexState();
+  const installed = state.installed.some(plugin => plugin.pluginId === PLUGIN_SELECTOR);
+  const configuredMarketplace = state.marketplaces.find(item => item.name === MARKETPLACE_NAME);
+
+  if (installed) {
+    await run(codexCommand, ['plugin', 'remove', PLUGIN_SELECTOR, '--json']);
+  }
+
+  if (configuredMarketplace && path.resolve(configuredMarketplace.root) !== marketplaceRoot) {
+    await run(codexCommand, ['plugin', 'marketplace', 'remove', MARKETPLACE_NAME, '--json']);
+  }
+
+  if (!configuredMarketplace || path.resolve(configuredMarketplace.root) !== marketplaceRoot) {
+    await run(codexCommand, ['plugin', 'marketplace', 'add', marketplaceRoot, '--json']);
+  }
+
+  await run(codexCommand, ['plugin', 'add', PLUGIN_SELECTOR, '--json']);
+}
+
+async function install() {
+  process.stdout.write('正在准备 Autobest Delivery 独立运行时，这可能需要几分钟...\n');
+  const prepared = await preparePlugin();
+  await replaceInstalledPlugin(prepared.stagedPluginRoot, prepared.stagingRoot);
+  await writeMarketplace();
+  await configureCodex();
+  process.stdout.write(`Autobest Delivery 插件已安装：${installedPluginRoot}\n`);
+  process.stdout.write('请重启 Codex，并在新会话中使用插件。\n');
+}
+
+function assertSafeMarketplaceRoot() {
+  const expected = path.join(agentHome, 'marketplaces', MARKETPLACE_NAME);
+  if (marketplaceRoot !== expected || path.basename(marketplaceRoot) !== MARKETPLACE_NAME) {
+    throw new Error(`拒绝删除非预期路径：${marketplaceRoot}`);
+  }
+}
+
+async function uninstall() {
+  const state = await getCodexState();
+  if (state.installed.some(plugin => plugin.pluginId === PLUGIN_SELECTOR)) {
+    await run(codexCommand, ['plugin', 'remove', PLUGIN_SELECTOR, '--json']);
+  }
+
+  const configuredMarketplace = state.marketplaces.find(item => item.name === MARKETPLACE_NAME);
+  if (configuredMarketplace && path.resolve(configuredMarketplace.root) === marketplaceRoot) {
+    await run(codexCommand, ['plugin', 'marketplace', 'remove', MARKETPLACE_NAME, '--json']);
+  }
+
+  assertSafeMarketplaceRoot();
+  await rm(marketplaceRoot, { recursive: true, force: true });
+  process.stdout.write('Autobest Delivery 插件及其专用本地市场已卸载。\n');
+}
+
+const command = process.argv[2] || 'install';
+
+if (command === '--help' || command === '-h' || command === 'help') {
+  printHelp();
+} else if (command === 'install') {
+  await install();
+} else if (command === 'uninstall') {
+  await uninstall();
+} else {
+  process.stderr.write(`未知命令：${command}\n\n`);
+  printHelp();
+  process.exitCode = 1;
+}