@cursorpool-dev/cli 0.5.6

package/node_modules/@cursor-pool/extension/test/panel.test.ts

@@ -0,0 +1,1785 @@
+import assert from 'node:assert/strict';
+import { createServer, type Server } from 'node:http';
+import { access, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { registerExtensionCommands } from '../src/extension';
+import {
+  getPlatformCatalog,
+  getPlatformStatus,
+  getServiceStatus,
+  loginPlatform,
+  logoutPlatform,
+  selectPlatformProduct,
+  startMode,
+  stopMode,
+} from '../src/api';
+import { buildPanelHtml, createPanelViewModel, registerStatusPanel } from '../src/panel';
+import { readRuntimeInfo } from '../src/runtime';
+
+const extensionRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+async function listen(server: Server) {
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+
+  const address = server.address();
+  assert.equal(typeof address, 'object');
+  assert.ok(address);
+  return address.port;
+}
+
+async function close(server: Server) {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => (error ? reject(error) : resolve()));
+  });
+}
+
+async function createRuntimeFixture() {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+
+  return {
+    tempDir,
+    runtimeFile,
+    cleanup: () => rm(tempDir, { recursive: true, force: true }),
+  };
+}
+
+test('sidebar WebView can open with rendered status HTML', async () => {
+  const subscriptions: unknown[] = [];
+  const registered: {
+    id: string;
+    provider: { resolveWebviewView: (view: { webview: { html: string } }) => unknown };
+  }[] = [];
+  const fakeVscode = {
+    window: {
+      registerWebviewViewProvider(id: string, provider: { resolveWebviewView: (view: unknown) => unknown }) {
+        registered.push({ id, provider: provider as (typeof registered)[number]['provider'] });
+        return { dispose() {} };
+      },
+    },
+  };
+
+  registerStatusPanel({ subscriptions }, fakeVscode, {
+    status: {
+      patch: 'applied',
+      service: 'running',
+      compat: 'supported',
+      mode: 'stopped',
+    },
+  });
+
+  assert.equal(registered[0]?.id, 'cursorPool.statusPanel');
+  assert.equal(subscriptions.length, 1);
+
+  const view = { webview: { html: '' } };
+  await registered[0].provider.resolveWebviewView(view);
+
+  assert.match(view.webview.html, /Cursor Pool/);
+  assert.match(view.webview.html, /本地服务[\s\S]*running/);
+  assert.doesNotMatch(view.webview.html, /补丁状态/);
+  assert.doesNotMatch(view.webview.html, /兼容状态/);
+});
+
+test('sidebar WebView enables scripts while preserving existing options', async () => {
+  const registered: {
+    provider: {
+      resolveWebviewView: (view: {
+        webview: { html: string; options?: Record<string, unknown> };
+      }) => unknown;
+    };
+  }[] = [];
+  const fakeVscode = {
+    window: {
+      registerWebviewViewProvider(_id: string, provider: { resolveWebviewView: (view: unknown) => unknown }) {
+        registered.push({ provider: provider as (typeof registered)[number]['provider'] });
+        return { dispose() {} };
+      },
+    },
+  };
+
+  registerStatusPanel({ subscriptions: [] }, fakeVscode, {
+    status: {
+      patch: 'applied',
+      service: 'running',
+      compat: 'supported',
+      mode: 'stopped',
+    },
+  });
+
+  const view = {
+    webview: {
+      html: '',
+      options: { retainContextWhenHidden: true },
+    },
+  };
+  await registered[0].provider.resolveWebviewView(view);
+
+  assert.deepEqual(view.webview.options, {
+    retainContextWhenHidden: true,
+    enableScripts: true,
+  });
+});
+
+test('extension package main points to an existing JavaScript host entrypoint', async () => {
+  const manifest = JSON.parse(await readFile(join(extensionRoot, 'package.json'), 'utf8')) as {
+    main?: string;
+  };
+
+  assert.match(manifest.main ?? '', /\.js$/);
+  await access(join(extensionRoot, manifest.main ?? ''));
+});
+
+test('extension manifest exposes command-based status reporting activation', async () => {
+  const manifest = JSON.parse(await readFile(join(extensionRoot, 'package.json'), 'utf8')) as {
+    activationEvents?: string[];
+    contributes?: { commands?: { command: string; title: string }[] };
+  };
+
+  assert.equal(manifest.activationEvents?.includes('onStartupFinished'), false);
+  assert.equal(manifest.activationEvents?.includes('onCommand:cursorPool.openClient'), true);
+  assert.equal(manifest.activationEvents?.includes('onCommand:cursorPool.reportStatus'), true);
+  assert.equal(
+    manifest.contributes?.commands?.some(
+      (command) =>
+        command.command === 'cursorPool.openClient' &&
+        command.title === 'Cursor Pool: 打开用户端',
+    ),
+    true,
+  );
+  assert.equal(
+    manifest.contributes?.commands?.some(
+      (command) =>
+        command.command === 'cursorPool.reportStatus' &&
+        command.title === 'Cursor Pool: Report Status',
+    ),
+    true,
+  );
+});
+
+test('extension manifest exposes Cursor Pool as a first-class client sidebar', async () => {
+  const manifest = JSON.parse(await readFile(join(extensionRoot, 'package.json'), 'utf8')) as {
+    displayName?: string;
+    contributes?: {
+      viewsContainers?: { activitybar?: { id: string; title: string; icon: string }[] };
+      views?: Record<string, { id: string; name: string; type?: string }[]>;
+    };
+  };
+
+  assert.equal(manifest.displayName, 'Cursor Pool 平台模式');
+  assert.equal(
+    manifest.contributes?.viewsContainers?.activitybar?.some(
+      (container) =>
+        container.id === 'cursorPoolClient' &&
+        container.title === 'Cursor Pool 平台模式' &&
+        container.icon === 'resources/cursor-pool.svg',
+    ),
+    true,
+  );
+  assert.equal(
+    manifest.contributes?.views?.cursorPoolClient?.some(
+      (view) => view.id === 'cursorPool.statusPanel' && view.name === '用户端' && view.type === 'webview',
+    ),
+    true,
+  );
+});
+
+test('extension API preserves inactive platform mode release reason', async () => {
+  const fixture = await createRuntimeFixture();
+  const server = createServer((_request, response) => {
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({
+      state: 'logged-in',
+      account: { credits: 80 },
+      mode: {
+        state: 'inactive',
+        releaseReason: 'insufficient-credits',
+        releasedAt: '2026-05-31T00:05:00.000Z',
+      },
+      products: [],
+    }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    const catalog = await getPlatformCatalog(fixture.runtimeFile);
+
+    assert.equal(catalog.state, 'logged-in');
+    assert.equal(catalog.mode?.state, 'inactive');
+    assert.equal(catalog.mode?.releaseReason, 'insufficient-credits');
+    assert.equal(catalog.mode?.releasedAt, '2026-05-31T00:05:00.000Z');
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('real extension host entrypoint handles panel controls from WebView messages', async () => {
+  const fixture = await createRuntimeFixture();
+  const requests: string[] = [];
+  let renderedHtml = '';
+  const server = createServer((request, response) => {
+    requests.push(`${request.method} ${request.url}`);
+    response.writeHead(200, { 'content-type': 'application/json' });
+
+    if (request.url === '/health') {
+      response.end(JSON.stringify({ ok: true, runtimeId: 'extension-runtime' }));
+      return;
+    }
+
+    if (request.url === '/extension/status') {
+      response.end(JSON.stringify({ ok: true, status: { connected: true } }));
+      return;
+    }
+
+    if (request.url === '/mode/start') {
+      response.end(JSON.stringify({ ok: true, mode: 'started' }));
+      return;
+    }
+
+    if (request.url === '/mode/stop') {
+      response.end(JSON.stringify({ ok: true, mode: 'stopped' }));
+      return;
+    }
+
+    if (request.url === '/platform/login') {
+      response.end(JSON.stringify({
+        state: 'logged-in',
+        user: { id: 'usr_1', email: 'dev@example.com' },
+        device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:00Z' },
+      }));
+      return;
+    }
+
+    if (request.url === '/platform/logout') {
+      response.end(JSON.stringify({ state: 'logged-out' }));
+      return;
+    }
+
+    if (request.url === '/platform/status') {
+      response.end(JSON.stringify({
+        state: 'logged-in',
+        user: { id: 'usr_1', email: 'dev@example.com' },
+        device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:00Z' },
+      }));
+      return;
+    }
+
+    if (request.url === '/platform/catalog') {
+      response.end(JSON.stringify({
+        state: 'logged-in',
+        account: { credits: 1000 },
+        mode: {
+          state: 'inactive',
+          releaseReason: 'insufficient-credits',
+          releasedAt: '2026-05-31T00:05:00.000Z',
+        },
+        selectedProductId: 'prod_basic',
+        products: [
+          {
+            id: 'prod_basic',
+            name: '基础组',
+            description: '开发态基础商品，用于验证扩展展示。',
+            status: 'available',
+            minCredits: 100,
+            usageLabel: '按请求消耗，倍率 1x',
+          },
+        ],
+      }));
+      return;
+    }
+
+    if (request.url === '/platform/selection') {
+      response.end(JSON.stringify({ state: 'selected', selectedProductId: 'prod_basic' }));
+      return;
+    }
+
+    response.end(JSON.stringify({ ok: true }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    const manifest = JSON.parse(await readFile(join(extensionRoot, 'package.json'), 'utf8')) as {
+      main: string;
+    };
+    const extensionHost = (await import(
+      `${pathToFileURL(join(extensionRoot, manifest.main)).href}?test=${Date.now()}-${Math.random()}`
+    )) as {
+      activate: (
+        context: { subscriptions: unknown[] },
+        vscode: unknown,
+        options: { runtimeFile: string },
+      ) => Promise<void>;
+    };
+    const handlers: ((message: { command: string; productId?: string }) => unknown)[] = [];
+    const registeredCommands: Record<string, () => unknown> = {};
+    const executedCommands: string[] = [];
+    const messages: string[] = [];
+    let webviewResolved: Promise<void> = Promise.resolve();
+    const fakeVscode = {
+      commands: {
+        registerCommand(command: string, handler: () => unknown) {
+          registeredCommands[command] = handler;
+          return { dispose() {} };
+        },
+        executeCommand(command: string) {
+          executedCommands.push(command);
+          registeredCommands[command]?.();
+        },
+      },
+      window: {
+        registerWebviewViewProvider(
+          _id: string,
+          provider: {
+            resolveWebviewView: (view: {
+              webview: {
+                html: string;
+                options?: Record<string, unknown>;
+                onDidReceiveMessage: (handler: (message: { command: string; productId?: string }) => unknown) => void;
+              };
+            }) => unknown;
+          },
+        ) {
+          const view = {
+            webview: {
+              html: '',
+              onDidReceiveMessage(handler) {
+                handlers.push(handler);
+              },
+            },
+          };
+          webviewResolved = Promise.resolve(provider.resolveWebviewView(view)).then(() => {
+            renderedHtml = view.webview.html;
+          });
+          return { dispose() {} };
+        },
+        showInformationMessage(message: string) {
+          messages.push(message);
+        },
+      },
+    };
+
+    await extensionHost.activate({ subscriptions: [] }, fakeVscode, { runtimeFile: fixture.runtimeFile });
+    await webviewResolved;
+
+    assert.equal(handlers.length, 1);
+    assert.match(renderedHtml, /本地服务[\s\S]*running/);
+    assert.match(renderedHtml, /登录账号[\s\S]*dev@example\.com/);
+    assert.match(renderedHtml, /积分余额[\s\S]*1000/);
+    assert.match(renderedHtml, /基础组/);
+    assert.doesNotMatch(renderedHtml, /平台状态/);
+    assert.doesNotMatch(renderedHtml, /当前设备/);
+    assert.doesNotMatch(renderedHtml, /号池接管/);
+    assert.doesNotMatch(renderedHtml, /当前商品[\s\S]*prod_basic/);
+    assert.match(renderedHtml, /data-command="takeover\/enable"/);
+    await handlers[0]({ command: 'takeover/enable' });
+    await handlers[0]({ command: 'takeover/disable' });
+    await handlers[0]({ command: 'platform/select-product', productId: 'prod_basic' });
+    await handlers[0]({
+      command: 'platform/login',
+      email: 'dev@example.com',
+      password: 'correct-password',
+    });
+    await handlers[0]({ command: 'platform/refresh' });
+    await handlers[0]({ command: 'platform/logout' });
+    await handlers[0]({ command: 'cursorPool.openConsole' });
+    await registeredCommands['cursorPool.openClient']();
+    await registeredCommands['cursorPool.reportStatus']();
+
+    assert.deepEqual(requests, [
+      'GET /health',
+      'POST /extension/status',
+      'GET /platform/status',
+      'GET /platform/catalog',
+      'POST /mode/start',
+      'GET /health',
+      'POST /extension/status',
+      'GET /platform/status',
+      'GET /platform/catalog',
+      'POST /mode/stop',
+      'GET /health',
+      'POST /extension/status',
+      'GET /platform/status',
+      'GET /platform/catalog',
+      'POST /platform/selection',
+      'GET /health',
+      'POST /extension/status',
+      'GET /platform/status',
+      'GET /platform/catalog',
+      'POST /platform/login',
+      'GET /health',
+      'POST /extension/status',
+      'GET /platform/status',
+      'GET /platform/catalog',
+      'GET /health',
+      'POST /extension/status',
+      'GET /platform/status',
+      'GET /platform/catalog',
+      'POST /platform/logout',
+      'GET /health',
+      'POST /extension/status',
+      'GET /platform/status',
+      'GET /platform/catalog',
+      'GET /health',
+      'POST /extension/status',
+    ]);
+    assert.deepEqual(executedCommands, [
+      'workbench.action.webview.openDeveloperTools',
+      'workbench.view.extension.cursorPoolClient',
+    ]);
+    assert.deepEqual(messages, [
+      'Cursor Pool service: running',
+    ]);
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('status is read from runtime file', async () => {
+  const fixture = await createRuntimeFixture();
+
+  try {
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port: 43999, runtimeId: 'extension-test' }),
+      'utf8',
+    );
+
+    assert.deepEqual(await readRuntimeInfo({ runtimeFile: fixture.runtimeFile }), {
+      host: '127.0.0.1',
+      port: 43999,
+      runtimeId: 'extension-test',
+    });
+  } finally {
+    await fixture.cleanup();
+  }
+});
+
+test('panel only displays service and user-facing account status', () => {
+  const viewModel = createPanelViewModel({
+    patch: 'missing',
+    service: 'stopped',
+    compat: 'unsupported',
+    mode: 'unknown',
+  });
+  const html = buildPanelHtml(viewModel);
+
+  assert.deepEqual(viewModel.rows, [
+    { label: 'patch', value: 'missing' },
+    { label: 'service', value: 'stopped' },
+    { label: 'compat', value: 'unsupported' },
+    { label: 'mode', value: 'unknown' },
+    { label: 'platform', value: 'logged-out' },
+  ]);
+  assert.match(html, /本地服务[\s\S]*stopped/);
+  assert.doesNotMatch(html, /补丁状态/);
+  assert.doesNotMatch(html, /兼容状态/);
+  assert.doesNotMatch(html, /号池接管/);
+  assert.doesNotMatch(html, /平台状态/);
+  assert.doesNotMatch(html, /data-command="mode\/start"/);
+  assert.doesNotMatch(html, /data-command="mode\/stop"/);
+});
+
+test('panel frames Cursor Pool as platform mode entry instead of full web console', () => {
+  const html = buildPanelHtml(createPanelViewModel({
+    patch: 'unknown',
+    service: 'running',
+    compat: 'unknown',
+    mode: 'inactive',
+    platform: 'logged-out',
+  }));
+
+  assert.equal(html.includes('Cursor Pool 号池客户端'), true);
+  assert.equal(html.includes('本地服务'), true);
+  assert.equal(html.includes('号池登录'), true);
+  assert.equal(html.includes('账号/邮箱'), true);
+  assert.equal(html.includes('登录码'), false);
+  assert.equal(html.includes('启动平台模式'), false);
+  assert.equal(html.includes('充值'), false);
+  assert.equal(html.includes('使用记录'), false);
+  assert.equal(html.includes('账本'), false);
+  assert.equal(html.includes('管理后台'), false);
+});
+
+test('panel displays platform logged-in user and device status', () => {
+  const viewModel = createPanelViewModel({
+    patch: 'applied',
+    service: 'running',
+    compat: 'supported',
+    mode: 'active prod_basic',
+    platform: 'logged-in',
+    user: 'user@example.test',
+    device: 'active device-1',
+    catalog: 'logged-in',
+    credits: '1000',
+    selectedProductId: 'prod_basic',
+    products: [
+      {
+        id: 'prod_basic',
+        name: '基础组',
+        description: '开发态基础商品，用于验证扩展展示。',
+        status: 'available',
+        minCredits: 100,
+        usageLabel: '按请求消耗，倍率 1x',
+      },
+    ],
+  });
+  const html = buildPanelHtml(viewModel);
+
+  assert.deepEqual(viewModel.rows, [
+    { label: 'patch', value: 'applied' },
+    { label: 'service', value: 'running' },
+    { label: 'compat', value: 'supported' },
+    { label: 'mode', value: 'active prod_basic' },
+    { label: 'platform', value: 'logged-in' },
+    { label: 'user', value: 'user@example.test' },
+    { label: 'device', value: 'active device-1' },
+    { label: 'catalog', value: 'logged-in' },
+    { label: 'credits', value: '1000' },
+    { label: 'current product', value: 'prod_basic' },
+  ]);
+  assert.match(html, /登录账号[\s\S]*user@example\.test/);
+  assert.match(html, /积分余额[\s\S]*1000/);
+  assert.match(html, /当前使用[\s\S]*基础组/);
+  assert.match(html, /可用商品/);
+  assert.match(html, /class="product-list"/);
+  assert.match(html, /class="product-row is-selected"/);
+  assert.doesNotMatch(html, /平台状态/);
+  assert.doesNotMatch(html, /号池接管/);
+  assert.doesNotMatch(html, /当前设备/);
+  assert.doesNotMatch(html, /已选择商品/);
+  assert.doesNotMatch(html, /当前商品[\s\S]*prod_basic/);
+  assert.match(html, /基础组/);
+  assert.match(html, /available/);
+  assert.match(html, /准入 100/);
+  assert.match(html, /按请求消耗，倍率 1x/);
+  assert.doesNotMatch(html, /<p>开发态基础商品，用于验证扩展展示。<\/p>/);
+  assert.doesNotMatch(html, /data-command="product\//);
+});
+
+test('panel keeps five products in a compact scrollable product list', () => {
+  const products = Array.from({ length: 5 }, (_, index) => ({
+    id: `prod_${index + 1}`,
+    name: `商品 ${index + 1}`,
+    description: `这是第 ${index + 1} 个商品的说明，不能把面板撑成长卡片。`,
+    status: 'available' as const,
+    minCredits: (index + 1) * 100,
+    usageLabel: `倍率 ${index + 1}x`,
+  }));
+  const html = buildPanelHtml(createPanelViewModel({
+    patch: 'applied',
+    service: 'running',
+    compat: 'supported',
+    mode: 'active prod_3',
+    platform: 'logged-in',
+    catalog: 'logged-in',
+    credits: '1000',
+    selectedProductId: 'prod_3',
+    products,
+  }));
+
+  assert.match(html, /class="product-list"/);
+  assert.match(html, /\.product-list \{[\s\S]*max-height: 260px/);
+  assert.equal((html.match(/class="product-row/g) ?? []).length, 5);
+  assert.equal((html.match(/class="product-description"/g) ?? []).length, 5);
+  assert.doesNotMatch(html, /<p>这是第 1 个商品的说明/);
+});
+
+test('panel HTML only renders product selection controls for available products', () => {
+  const html = buildPanelHtml(
+    createPanelViewModel({
+      patch: 'applied',
+      service: 'running',
+      compat: 'supported',
+      mode: 'stopped',
+      platform: 'logged-in',
+      catalog: 'logged-in',
+      products: [
+        {
+          id: 'prod_basic',
+          name: '基础组',
+          description: '开发态基础商品，用于验证扩展展示。',
+          status: 'available',
+          minCredits: 100,
+          usageLabel: '按请求消耗，倍率 1x',
+        },
+        {
+          id: 'prod_pro',
+          name: '高级组',
+          description: '开发态高级商品，用于验证多商品展示。',
+          status: 'unavailable',
+          minCredits: 500,
+          usageLabel: '按请求消耗，倍率 2x',
+        },
+      ],
+    }),
+  );
+
+  assert.match(html, /data-product-id="prod_basic"/);
+  assert.doesNotMatch(html, /data-product-id="prod_pro"/);
+});
+
+test('panel keeps active platform mode out of rendered status list', () => {
+  const html = buildPanelHtml(createPanelViewModel({
+    patch: 'applied',
+    service: 'running',
+    compat: 'supported',
+    mode: 'active prod_basic',
+    platform: 'logged-in',
+    user: 'user@example.test',
+    device: 'active device-1',
+  }));
+
+  assert.doesNotMatch(html, /号池接管/);
+  assert.doesNotMatch(html, /active prod_basic/);
+});
+
+test('sidebar view model shows inactive mode release reason', () => {
+  const viewModel = createPanelViewModel({
+    patch: 'applied',
+    service: 'running',
+    compat: 'supported',
+    mode: 'inactive insufficient-credits',
+    platform: 'logged-in',
+  });
+  const html = buildPanelHtml(viewModel);
+
+  assert.doesNotMatch(html, /号池接管/);
+  assert.doesNotMatch(html, /inactive insufficient-credits/);
+});
+
+test('panel HTML renders platform login form when logged out', () => {
+  const html = buildPanelHtml(
+    createPanelViewModel({
+      patch: 'applied',
+      service: 'running',
+      compat: 'supported',
+      mode: 'stopped',
+      platform: 'logged-out',
+    }),
+  );
+
+  assert.doesNotMatch(html, /name="apiBaseUrl"/);
+  assert.doesNotMatch(html, /登录码/);
+  assert.match(html, /name="email"/);
+  assert.match(html, /name="password"/);
+  assert.match(html, /data-command="platform\/login"/);
+  assert.match(html, /data-command="platform\/refresh"/);
+});
+
+test('panel HTML renders logout for logged-in and invalid-token states', () => {
+  const loggedIn = buildPanelHtml(
+    createPanelViewModel({
+      patch: 'applied',
+      service: 'running',
+      compat: 'supported',
+      mode: 'started',
+      platform: 'logged-in',
+      user: 'dev@example.com',
+      device: 'active dev_1',
+      heartbeat: '2026-05-30T00:00:00Z',
+    }),
+  );
+  const invalidToken = buildPanelHtml(
+    createPanelViewModel({
+      patch: 'applied',
+      service: 'running',
+      compat: 'supported',
+      mode: 'started',
+      platform: 'invalid-token',
+      user: 'dev@example.com',
+      device: 'active dev_1',
+    }),
+  );
+
+  assert.match(loggedIn, /data-command="platform\/logout"/);
+  assert.match(loggedIn, /data-command="platform\/refresh"/);
+  assert.doesNotMatch(invalidToken, /平台状态/);
+  assert.match(invalidToken, /data-command="platform\/logout"/);
+});
+
+test('panel HTML wires data-command buttons to VS Code WebView messages', () => {
+  const html = buildPanelHtml(
+    createPanelViewModel({
+      patch: 'applied',
+      service: 'running',
+      compat: 'supported',
+      mode: 'stopped',
+    }),
+  );
+
+  assert.match(html, /acquireVsCodeApi/);
+  assert.match(html, /postMessage/);
+  assert.match(html, /dataset\.command/);
+  assert.doesNotMatch(html, /data-command="mode\/start"/);
+  assert.doesNotMatch(html, /data-command="mode\/stop"/);
+  assert.match(html, /data-command="platform\/login"/);
+});
+
+test('status panel handles platform login logout and refresh messages', async () => {
+  const statuses = [
+    { state: 'logged-out' as const },
+    {
+      state: 'logged-in' as const,
+      user: { id: 'usr_1', email: 'dev@example.com' },
+      device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:00Z' },
+    },
+    { state: 'logged-out' as const },
+  ];
+  let statusIndex = 0;
+  const calls: string[] = [];
+  const executedCommands: string[] = [];
+  const handlers: ((
+    message: { command: string; email?: string; password?: string; productId?: string },
+  ) => unknown)[] = [];
+  const rendered: string[] = [];
+  const registered: {
+    provider: {
+      resolveWebviewView: (view: {
+        webview: {
+          html: string;
+          options?: Record<string, unknown>;
+          onDidReceiveMessage: (
+            handler: (message: { command: string; email?: string; password?: string; productId?: string }) => unknown,
+          ) => void;
+        };
+      }) => unknown;
+    };
+  }[] = [];
+  const fakeVscode = {
+    window: {
+      registerWebviewViewProvider(_id: string, provider: { resolveWebviewView: (view: unknown) => unknown }) {
+        registered.push({ provider: provider as (typeof registered)[number]['provider'] });
+        return { dispose() {} };
+      },
+    },
+    commands: {
+      executeCommand(command: string) {
+        executedCommands.push(command);
+      },
+    },
+  };
+
+  registerStatusPanel({ subscriptions: [] }, fakeVscode, {
+    runtimeFile: 'runtime.json',
+    getServiceStatus: async () => ({ service: 'running' as const, runtime: null }),
+    getPlatformStatus: async () => statuses[Math.min(statusIndex, statuses.length - 1)],
+    loginPlatform: async (input) => {
+      calls.push(`login:${input.email}:${input.password}`);
+      statusIndex = 1;
+      return statuses[1];
+    },
+    logoutPlatform: async () => {
+      calls.push('logout');
+      statusIndex = 2;
+      return statuses[2];
+    },
+    selectPlatformProduct: async (input) => {
+      calls.push(`select:${input.productId}`);
+      return { state: 'selected' as const, selectedProductId: input.productId };
+    },
+    startMode: async () => {
+      calls.push('start');
+      return { state: 'active' as const, productId: 'prod_basic', startedAt: '2026-05-31T00:00:00.000Z' };
+    },
+    stopMode: async () => {
+      calls.push('stop');
+      return { state: 'inactive' as const };
+    },
+  });
+
+  const view = {
+    webview: {
+      html: '',
+      onDidReceiveMessage(
+        handler: (message: { command: string; email?: string; password?: string; productId?: string }) => unknown,
+      ) {
+        handlers.push(handler);
+      },
+    },
+  };
+
+  await registered[0].provider.resolveWebviewView(view);
+  rendered.push(view.webview.html);
+  await handlers[0]({ command: 'takeover/enable' });
+  rendered.push(view.webview.html);
+  await handlers[0]({ command: 'takeover/disable' });
+  rendered.push(view.webview.html);
+  await handlers[0]({ command: 'platform/login', email: 'dev@example.com', password: 'correct-password' });
+  rendered.push(view.webview.html);
+  await handlers[0]({ command: 'platform/refresh' });
+  rendered.push(view.webview.html);
+  await handlers[0]({ command: 'platform/select-product', productId: 'prod_basic' });
+  rendered.push(view.webview.html);
+  await handlers[0]({ command: 'platform/logout' });
+  rendered.push(view.webview.html);
+
+  assert.doesNotMatch(rendered[0], /平台状态/);
+  assert.match(rendered[1], /已开启平台接管/);
+  assert.match(rendered[2], /已切回官方模式/);
+  assert.doesNotMatch(rendered[3], /平台状态/);
+  assert.match(rendered[3], /登录账号[\s\S]*dev@example\.com/);
+  assert.doesNotMatch(rendered[3], /当前设备/);
+  assert.match(rendered[4], /平台状态已刷新/);
+  assert.equal(calls.includes('select:prod_basic'), true);
+  assert.doesNotMatch(rendered[5], /已选择商品/);
+  assert.doesNotMatch(rendered[6], /平台状态/);
+  assert.deepEqual(calls, ['start', 'stop', 'login:dev@example.com:correct-password', 'select:prod_basic', 'logout']);
+  assert.deepEqual(executedCommands, ['workbench.action.reloadWindow', 'workbench.action.reloadWindow']);
+});
+
+test('status panel renders platform mode start errors', async () => {
+  const handlers: ((message: { command?: string }) => unknown)[] = [];
+  const view = {
+    webview: {
+      html: '',
+      onDidReceiveMessage(handler: (message: { command?: string }) => unknown) {
+        handlers.push(handler);
+      },
+    },
+  };
+
+  const provider = registerStatusPanel({}, {
+    window: {
+      registerWebviewViewProvider(_id: string, registeredProvider: { resolveWebviewView: (view: unknown) => unknown }) {
+        return registeredProvider;
+      },
+    },
+  }, {
+    status: {
+      patch: 'applied',
+      service: 'running',
+      compat: 'supported',
+      mode: 'inactive',
+      platform: 'logged-in',
+      user: 'dev@example.com',
+    },
+    startMode: async () => ({ state: 'product-not-selected' as const }),
+  });
+
+  await provider.resolveWebviewView(view);
+  await handlers[0]({ command: 'takeover/enable' });
+
+  assert.match(view.webview.html, /开启平台接管前请先选择商品/);
+});
+
+test('status panel shows login validation errors with static status', async () => {
+  let loginCalls = 0;
+  const handlers: ((message: { command: string; email?: string; password?: string }) => unknown)[] = [];
+  const registered: {
+    provider: {
+      resolveWebviewView: (view: {
+        webview: {
+          html: string;
+          onDidReceiveMessage: (
+            handler: (message: { command: string; email?: string; password?: string }) => unknown,
+          ) => void;
+        };
+      }) => unknown;
+    };
+  }[] = [];
+  const fakeVscode = {
+    window: {
+      registerWebviewViewProvider(_id: string, provider: { resolveWebviewView: (view: unknown) => unknown }) {
+        registered.push({ provider: provider as (typeof registered)[number]['provider'] });
+        return { dispose() {} };
+      },
+    },
+  };
+
+  registerStatusPanel({ subscriptions: [] }, fakeVscode, {
+    status: {
+      patch: 'applied',
+      service: 'running',
+      compat: 'supported',
+      mode: 'stopped',
+      platform: 'logged-out',
+    },
+    loginPlatform: async () => {
+      loginCalls += 1;
+      return {
+        state: 'logged-in',
+        user: { id: 'usr_1', email: 'dev@example.com' },
+        device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:00Z' },
+      };
+    },
+  });
+
+  const view = {
+    webview: {
+      html: '',
+      onDidReceiveMessage(
+        handler: (message: { command: string; email?: string; password?: string }) => unknown,
+      ) {
+        handlers.push(handler);
+      },
+    },
+  };
+
+  await registered[0].provider.resolveWebviewView(view);
+  await handlers[0]({ command: 'platform/login', password: 'correct-password' });
+
+  assert.match(view.webview.html, /请输入账号\/邮箱/);
+  await handlers[0]({ command: 'platform/login', email: 'dev@example.com' });
+  assert.match(view.webview.html, /请输入密码/);
+  assert.equal(loginCalls, 0);
+});
+
+test('status panel clears stale login errors when refresh sees logged-in status', async () => {
+  let status: { state: 'logged-out' } | {
+    state: 'logged-in';
+    user: { id: string; email: string };
+    device: { id: string; status: string; lastHeartbeatAt: string };
+  } = { state: 'logged-out' };
+  const handlers: ((message: { command: string; email?: string; password?: string }) => unknown)[] = [];
+  const registered: {
+    provider: {
+      resolveWebviewView: (view: {
+        webview: {
+          html: string;
+          onDidReceiveMessage: (
+            handler: (message: { command: string; email?: string; password?: string }) => unknown,
+          ) => void;
+        };
+      }) => unknown;
+    };
+  }[] = [];
+  const fakeVscode = {
+    window: {
+      registerWebviewViewProvider(_id: string, provider: { resolveWebviewView: (view: unknown) => unknown }) {
+        registered.push({ provider: provider as (typeof registered)[number]['provider'] });
+        return { dispose() {} };
+      },
+    },
+  };
+
+  registerStatusPanel({ subscriptions: [] }, fakeVscode, {
+    runtimeFile: '/tmp/runtime.json',
+    getServiceStatus: async () => ({ service: 'running' as const, runtime: null }),
+    getPlatformStatus: async () => status,
+    getPlatformCatalog: async () => ({
+      state: 'logged-in' as const,
+      account: { credits: 1000 },
+      mode: { state: 'inactive' as const },
+      products: [],
+    }),
+    loginPlatform: async () => {
+      throw new Error('登录失败：账号或密码不正确');
+    },
+  });
+
+  const view = {
+    webview: {
+      html: '',
+      onDidReceiveMessage(
+        handler: (message: { command: string; email?: string; password?: string }) => unknown,
+      ) {
+        handlers.push(handler);
+      },
+    },
+  };
+
+  await registered[0].provider.resolveWebviewView(view);
+  await handlers[0]({ command: 'platform/login', email: 'dev@example.com', password: 'wrong-password' });
+  assert.match(view.webview.html, /登录失败：账号或密码不正确/);
+
+  status = {
+    state: 'logged-in',
+    user: { id: 'usr_1', email: 'dev@example.com' },
+    device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:00Z' },
+  };
+  await handlers[0]({ command: 'platform/refresh' });
+
+  assert.match(view.webview.html, /登录账号[\s\S]*dev@example\.com/);
+  assert.doesNotMatch(view.webview.html, /登录失败：账号或密码不正确/);
+});
+
+test('status panel suppresses failed login feedback when platform is already logged in', async () => {
+  const handlers: ((message: { command: string; email?: string; password?: string }) => unknown)[] = [];
+  const registered: {
+    provider: {
+      resolveWebviewView: (view: {
+        webview: {
+          html: string;
+          onDidReceiveMessage: (
+            handler: (message: { command: string; email?: string; password?: string }) => unknown,
+          ) => void;
+        };
+      }) => unknown;
+    };
+  }[] = [];
+  const fakeVscode = {
+    window: {
+      registerWebviewViewProvider(_id: string, provider: { resolveWebviewView: (view: unknown) => unknown }) {
+        registered.push({ provider: provider as (typeof registered)[number]['provider'] });
+        return { dispose() {} };
+      },
+    },
+  };
+
+  registerStatusPanel({ subscriptions: [] }, fakeVscode, {
+    runtimeFile: '/tmp/runtime.json',
+    getServiceStatus: async () => ({ service: 'running' as const, runtime: null }),
+    getPlatformStatus: async () => ({
+      state: 'logged-in' as const,
+      user: { id: 'usr_1', email: 'dev@example.com' },
+      device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:00Z' },
+    }),
+    getPlatformCatalog: async () => ({
+      state: 'logged-in' as const,
+      account: { credits: 1000 },
+      mode: { state: 'inactive' as const },
+      products: [],
+    }),
+    loginPlatform: async () => {
+      throw new Error('登录失败：账号或密码不正确');
+    },
+  });
+
+  const view = {
+    webview: {
+      html: '',
+      onDidReceiveMessage(
+        handler: (message: { command: string; email?: string; password?: string }) => unknown,
+      ) {
+        handlers.push(handler);
+      },
+    },
+  };
+
+  await registered[0].provider.resolveWebviewView(view);
+  await handlers[0]({ command: 'platform/login', email: 'dev@example.com', password: 'wrong-password' });
+
+  assert.match(view.webview.html, /登录账号[\s\S]*dev@example\.com/);
+  assert.doesNotMatch(view.webview.html, /登录失败：账号或密码不正确/);
+});
+
+test('status panel starts local service before login when service is stopped', async () => {
+  const calls: string[] = [];
+  const handlers: ((message: { command: string; email?: string; password?: string }) => unknown)[] = [];
+  const registered: {
+    provider: {
+      resolveWebviewView: (view: {
+        webview: {
+          html: string;
+          onDidReceiveMessage: (
+            handler: (message: { command: string; email?: string; password?: string }) => unknown,
+          ) => void;
+        };
+      }) => unknown;
+    };
+  }[] = [];
+  const fakeVscode = {
+    window: {
+      registerWebviewViewProvider(_id: string, provider: { resolveWebviewView: (view: unknown) => unknown }) {
+        registered.push({ provider: provider as (typeof registered)[number]['provider'] });
+        return { dispose() {} };
+      },
+    },
+  };
+
+  registerStatusPanel({ subscriptions: [] }, fakeVscode, {
+    runtimeFile: '/tmp/runtime.json',
+    getServiceStatus: async () => ({ service: 'stopped' as const, runtime: null }),
+    getPlatformStatus: async () => ({ state: 'logged-out' as const }),
+    getPlatformCatalog: async () => ({ state: 'logged-out' as const, products: [] }),
+    ensureService: async (runtimeFile) => {
+      calls.push(`ensure:${runtimeFile}`);
+    },
+    loginPlatform: async (input) => {
+      calls.push(`login:${input.email}:${input.password}`);
+      return {
+        state: 'logged-in' as const,
+        user: { id: 'usr_1', email: input.email },
+        device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:00Z' },
+      };
+    },
+  });
+
+  const view = {
+    webview: {
+      html: '',
+      onDidReceiveMessage(
+        handler: (message: { command: string; email?: string; password?: string }) => unknown,
+      ) {
+        handlers.push(handler);
+      },
+    },
+  };
+
+  await registered[0].provider.resolveWebviewView(view);
+  await handlers[0]({ command: 'platform/login', email: 'dev@example.com', password: 'correct-password' });
+
+  assert.deepEqual(calls, ['ensure:/tmp/runtime.json', 'login:dev@example.com:correct-password']);
+});
+
+test('status panel renders errors when mode start message handling fails', async () => {
+  const handlers: ((message: { command: string }) => unknown)[] = [];
+  const registered: {
+    provider: {
+      resolveWebviewView: (view: {
+        webview: {
+          html: string;
+          onDidReceiveMessage: (handler: (message: { command: string }) => unknown) => void;
+        };
+      }) => unknown;
+    };
+  }[] = [];
+  const fakeVscode = {
+    window: {
+      registerWebviewViewProvider(_id: string, provider: { resolveWebviewView: (view: unknown) => unknown }) {
+        registered.push({ provider: provider as (typeof registered)[number]['provider'] });
+        return { dispose() {} };
+      },
+    },
+  };
+
+  registerStatusPanel({ subscriptions: [] }, fakeVscode, {
+    status: {
+      patch: 'applied',
+      service: 'running',
+      compat: 'supported',
+      mode: 'stopped',
+      platform: 'logged-out',
+    },
+    startMode: async () => {
+      throw new Error('mode start failed');
+    },
+  });
+
+  const view = {
+    webview: {
+      html: '',
+      onDidReceiveMessage(handler: (message: { command: string }) => unknown) {
+        handlers.push(handler);
+      },
+    },
+  };
+
+  await registered[0].provider.resolveWebviewView(view);
+  await assert.doesNotReject(async () => {
+    await handlers[0]({ command: 'mode/start' });
+  });
+
+  assert.match(view.webview.html, /mode start failed/);
+});
+
+test('extension activation registers console and report status command handlers', async () => {
+  const subscriptions: unknown[] = [];
+  const registeredCommands: { command: string; handler: () => unknown }[] = [];
+  const executedCommands: string[] = [];
+  const messages: string[] = [];
+  const fakeVscode = {
+    commands: {
+      executeCommand(command: string) {
+        executedCommands.push(command);
+      },
+      registerCommand(command: string, handler: () => unknown) {
+        registeredCommands.push({ command, handler });
+        return { dispose() {} };
+      },
+    },
+    window: {
+      showInformationMessage(message: string) {
+        messages.push(message);
+      },
+    },
+  };
+
+  registerExtensionCommands({ subscriptions }, fakeVscode, {
+    getServiceStatus: async () => ({ service: 'running' as const, runtime: null }),
+  });
+
+  assert.deepEqual(
+    registeredCommands.map((registered) => registered.command),
+    ['cursorPool.openClient', 'cursorPool.openConsole', 'cursorPool.reportStatus'],
+  );
+  assert.equal(subscriptions.length, 3);
+
+  registeredCommands[0].handler();
+  registeredCommands[1].handler();
+  await registeredCommands[2].handler();
+
+  assert.deepEqual(executedCommands, ['workbench.view.extension.cursorPoolClient']);
+  assert.deepEqual(messages, [
+    '请在网页端查看充值、记录、设备和账号信息。',
+    'Cursor Pool service: running',
+  ]);
+});
+
+test('API reports local service status from runtime and posts extension status', async () => {
+  const fixture = await createRuntimeFixture();
+  const requests: { method?: string; url?: string; body: string }[] = [];
+  const server = createServer((request, response) => {
+    let body = '';
+    request.setEncoding('utf8');
+    request.on('data', (chunk) => {
+      body += chunk;
+    });
+    request.on('end', () => {
+      requests.push({ method: request.method, url: request.url, body });
+
+      if (request.method === 'GET' && request.url === '/health') {
+        response.writeHead(200, { 'content-type': 'application/json' });
+        response.end(JSON.stringify({ ok: true, runtimeId: 'extension-runtime' }));
+        return;
+      }
+
+      if (request.method === 'POST' && request.url === '/extension/status') {
+        response.writeHead(200, { 'content-type': 'application/json' });
+        response.end(JSON.stringify({ ok: true, status: { connected: true } }));
+        return;
+      }
+
+      response.writeHead(404, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({ ok: false }));
+    });
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    const status = await getServiceStatus(fixture.runtimeFile);
+
+    assert.equal(status.service, 'running');
+    assert.equal(status.runtime?.port, port);
+    assert.equal(requests.some((request) => request.method === 'GET' && request.url === '/health'), true);
+    assert.equal(
+      requests.some((request) => request.method === 'POST' && request.url === '/extension/status'),
+      true,
+    );
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('API recovers sidebar status when runtime file points to a stale service port', async () => {
+  const fixture = await createRuntimeFixture();
+  const requests: string[] = [];
+  const server = createServer((request, response) => {
+    requests.push(`${request.method} ${request.url}`);
+
+    if (request.method === 'GET' && request.url === '/health') {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({ ok: true, runtimeId: 'fallback-runtime' }));
+      return;
+    }
+
+    if (request.method === 'POST' && request.url === '/extension/status') {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({ ok: true, status: { connected: true } }));
+      return;
+    }
+
+    if (request.method === 'GET' && request.url === '/platform/status') {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({
+        state: 'logged-in',
+        user: { id: 'user-1', email: 'user@example.test' },
+        device: {
+          id: 'device-1',
+          status: 'active',
+          lastHeartbeatAt: '2026-05-30T08:00:00.000Z',
+        },
+        mode: {
+          state: 'active',
+          productId: 'prod_basic',
+          startedAt: '2026-05-31T00:00:00.000Z',
+        },
+      }));
+      return;
+    }
+
+    response.writeHead(404, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ ok: false }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port: 1, runtimeId: 'stale-runtime' }),
+      'utf8',
+    );
+
+    const service = await getServiceStatus(fixture.runtimeFile, { fallbackPort: port });
+    const platform = await getPlatformStatus(fixture.runtimeFile, { fallbackPort: port });
+    const healedRuntime = JSON.parse(await readFile(fixture.runtimeFile, 'utf8')) as {
+      host: string;
+      port: number;
+      runtimeId: string;
+    };
+
+    assert.equal(service.service, 'running');
+    assert.equal(service.runtime?.port, port);
+    assert.equal(platform.state, 'logged-in');
+    assert.equal(platform.state === 'logged-in' ? platform.user.email : '', 'user@example.test');
+    assert.deepEqual(healedRuntime, {
+      host: '127.0.0.1',
+      port,
+      runtimeId: 'fallback-runtime',
+    });
+    assert.deepEqual(requests, [
+      'GET /health',
+      'POST /extension/status',
+      'GET /health',
+      'GET /platform/status',
+    ]);
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('API reads platform status from local runtime service', async () => {
+  const fixture = await createRuntimeFixture();
+  const requests: string[] = [];
+  const server = createServer((request, response) => {
+    requests.push(`${request.method} ${request.url}`);
+
+    if (request.method === 'GET' && request.url === '/platform/status') {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(
+        JSON.stringify({
+          state: 'logged-in',
+          user: { id: 'user-1', email: 'user@example.test' },
+          device: {
+            id: 'device-1',
+            status: 'active',
+            lastHeartbeatAt: '2026-05-30T08:00:00.000Z',
+          },
+          mode: { state: 'inactive' },
+        }),
+      );
+      return;
+    }
+
+    response.writeHead(404, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ ok: false }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    assert.deepEqual(await getPlatformStatus(fixture.runtimeFile), {
+      state: 'logged-in',
+      user: { id: 'user-1', email: 'user@example.test' },
+      device: {
+        id: 'device-1',
+        status: 'active',
+        lastHeartbeatAt: '2026-05-30T08:00:00.000Z',
+      },
+      mode: { state: 'inactive' },
+    });
+    assert.deepEqual(requests, ['GET /platform/status']);
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('API maps platform login error codes from local service', async () => {
+  const fixture = await createRuntimeFixture();
+  const server = createServer((_request, response) => {
+    response.writeHead(400, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ ok: false, error: 'platform login failed', code: 'DEVICE_LIMIT_REACHED' }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    await assert.rejects(
+      loginPlatform({
+        runtimeFile: fixture.runtimeFile,
+        email: 'dev@example.com',
+        password: 'correct-password',
+      }),
+      /设备数量已达上限/,
+    );
+  } finally {
+    await close(server);
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('API reads platform catalog from local runtime service', async () => {
+  const fixture = await createRuntimeFixture();
+  const requests: string[] = [];
+  const server = createServer((request, response) => {
+    requests.push(`${request.method} ${request.url}`);
+
+    if (request.method === 'GET' && request.url === '/platform/catalog') {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end(
+        JSON.stringify({
+          state: 'logged-in',
+          account: { credits: 1000 },
+          selectedProductId: 'prod_basic',
+          mode: { state: 'active', productId: 'prod_basic', startedAt: '2026-05-31T00:00:00.000Z' },
+          products: [
+            {
+              id: 'prod_basic',
+              name: '基础组',
+              description: '开发态基础商品，用于验证扩展展示。',
+              status: 'available',
+              minCredits: 100,
+              usageLabel: '按请求消耗，倍率 1x',
+            },
+            {
+              id: 'prod_bad',
+              name: 'Bad',
+              description: 'Bad product',
+              status: 'available',
+              minCredits: -1,
+              usageLabel: 'bad',
+            },
+          ],
+        }),
+      );
+      return;
+    }
+
+    response.writeHead(404, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ ok: false }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    assert.deepEqual(await getPlatformCatalog(fixture.runtimeFile), {
+      state: 'logged-in',
+      account: { credits: 1000 },
+      selectedProductId: 'prod_basic',
+      mode: { state: 'active', productId: 'prod_basic', startedAt: '2026-05-31T00:00:00.000Z' },
+      products: [
+        {
+          id: 'prod_basic',
+          name: '基础组',
+          description: '开发态基础商品，用于验证扩展展示。',
+          status: 'available',
+          minCredits: 100,
+          usageLabel: '按请求消耗，倍率 1x',
+        },
+      ],
+    });
+    assert.deepEqual(requests, ['GET /platform/catalog']);
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('API selects a platform product through local service', async () => {
+  const fixture = await createRuntimeFixture();
+  const requests: { method?: string; url?: string; body: Record<string, unknown> }[] = [];
+  const server = createServer((request, response) => {
+    let rawBody = '';
+    request.setEncoding('utf8');
+    request.on('data', (chunk) => {
+      rawBody += chunk;
+    });
+    request.on('end', () => {
+      requests.push({
+        method: request.method,
+        url: request.url,
+        body: rawBody ? (JSON.parse(rawBody) as Record<string, unknown>) : {},
+      });
+
+      if (request.method === 'POST' && request.url === '/platform/selection') {
+        response.writeHead(200, { 'content-type': 'application/json' });
+        response.end(JSON.stringify({ state: 'selected', selectedProductId: 'prod_basic' }));
+        return;
+      }
+
+      response.writeHead(404, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({ ok: false }));
+    });
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    assert.deepEqual(await selectPlatformProduct({
+      runtimeFile: fixture.runtimeFile,
+      productId: 'prod_basic',
+    }), {
+      state: 'selected',
+      selectedProductId: 'prod_basic',
+    });
+    assert.deepEqual(requests, [
+      { method: 'POST', url: '/platform/selection', body: { productId: 'prod_basic' } },
+    ]);
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('API reports offline selection state when runtime is missing or response is malformed', async () => {
+  const fixture = await createRuntimeFixture();
+  let serverStarted = false;
+  const server = createServer((_request, response) => {
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ state: 'selected' }));
+  });
+
+  try {
+    assert.deepEqual(await selectPlatformProduct({
+      runtimeFile: fixture.runtimeFile,
+      productId: 'prod_basic',
+    }), { state: 'offline' });
+
+    const port = await listen(server);
+    serverStarted = true;
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+    assert.deepEqual(await selectPlatformProduct({
+      runtimeFile: fixture.runtimeFile,
+      productId: 'prod_basic',
+    }), { state: 'offline' });
+  } finally {
+    if (serverStarted) {
+      await close(server);
+    }
+    await fixture.cleanup();
+  }
+});
+
+test('API can login and logout through local service platform routes', async () => {
+  const fixture = await createRuntimeFixture();
+  const requests: { method?: string; url?: string; body: Record<string, unknown> }[] = [];
+  const server = createServer((request, response) => {
+    let rawBody = '';
+    request.setEncoding('utf8');
+    request.on('data', (chunk) => {
+      rawBody += chunk;
+    });
+    request.on('end', () => {
+      requests.push({
+        method: request.method,
+        url: request.url,
+        body: rawBody ? (JSON.parse(rawBody) as Record<string, unknown>) : {},
+      });
+
+      response.writeHead(200, { 'content-type': 'application/json' });
+      if (request.url === '/platform/login') {
+        response.end(
+          JSON.stringify({
+            state: 'logged-in',
+            user: { id: 'usr_1', email: 'dev@example.com' },
+            device: { id: 'dev_1', status: 'active', lastHeartbeatAt: '2026-05-30T00:00:00Z' },
+          }),
+        );
+        return;
+      }
+
+      if (request.url === '/platform/logout') {
+        response.end(JSON.stringify({ state: 'logged-out' }));
+        return;
+      }
+
+      response.end(JSON.stringify({ ok: true }));
+    });
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    const login = await loginPlatform({
+      runtimeFile: fixture.runtimeFile,
+      email: 'dev@example.com',
+      password: 'correct-password',
+    });
+    const logout = await logoutPlatform(fixture.runtimeFile);
+
+    assert.equal(login.state, 'logged-in');
+    assert.deepEqual(logout, { state: 'logged-out' });
+    assert.equal(requests[0]?.method, 'POST');
+    assert.equal(requests[0]?.url, '/platform/login');
+    assert.equal(requests[0]?.body.email, 'dev@example.com');
+    assert.equal(requests[0]?.body.password, 'correct-password');
+    assert.equal(Object.hasOwn(requests[0]?.body ?? {}, 'apiBaseUrl'), false);
+    assert.equal(Object.hasOwn(requests[0]?.body ?? {}, 'code'), false);
+    assert.equal(typeof (requests[0]?.body.device as Record<string, unknown>).name, 'string');
+    assert.equal(typeof (requests[0]?.body.device as Record<string, unknown>).os, 'string');
+    assert.equal(typeof (requests[0]?.body.device as Record<string, unknown>).arch, 'string');
+    assert.equal((requests[0]?.body.device as Record<string, unknown>).extensionVersion, '0.5.6');
+    assert.equal(requests[1]?.method, 'POST');
+    assert.equal(requests[1]?.url, '/platform/logout');
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('API reports logged-out platform state when runtime is missing', async () => {
+  const fixture = await createRuntimeFixture();
+
+  try {
+    assert.deepEqual(await getPlatformStatus(fixture.runtimeFile), { state: 'logged-out' });
+    assert.deepEqual(await getPlatformCatalog(fixture.runtimeFile), { state: 'logged-out', products: [] });
+  } finally {
+    await fixture.cleanup();
+  }
+});
+
+test('API reports offline platform state when service request fails', async () => {
+  const fixture = await createRuntimeFixture();
+  const server = createServer((_request, response) => {
+    response.writeHead(500, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ ok: false }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    assert.deepEqual(await getPlatformStatus(fixture.runtimeFile), { state: 'offline' });
+    assert.deepEqual(await getPlatformCatalog(fixture.runtimeFile), { state: 'offline', products: [] });
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('API reports offline platform state when service returns malformed status', async () => {
+  const fixture = await createRuntimeFixture();
+  const server = createServer((_request, response) => {
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ state: 'logged-in' }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    assert.deepEqual(await getPlatformStatus(fixture.runtimeFile), { state: 'offline' });
+    assert.deepEqual(await getPlatformCatalog(fixture.runtimeFile), { state: 'offline', products: [] });
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('API can trigger mode/start and mode/stop', async () => {
+  const fixture = await createRuntimeFixture();
+  const paths: string[] = [];
+  const server = createServer((request, response) => {
+    paths.push(`${request.method} ${request.url}`);
+    response.writeHead(200, { 'content-type': 'application/json' });
+
+    if (request.url === '/mode/start') {
+      response.end(JSON.stringify({
+        state: 'active',
+        productId: 'prod_basic',
+        startedAt: '2026-05-31T00:00:00.000Z',
+      }));
+      return;
+    }
+
+    response.end(JSON.stringify({ state: 'inactive' }));
+  });
+
+  try {
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+
+    assert.deepEqual(await startMode(fixture.runtimeFile), {
+      state: 'active',
+      productId: 'prod_basic',
+      startedAt: '2026-05-31T00:00:00.000Z',
+    });
+    assert.deepEqual(await stopMode(fixture.runtimeFile), { state: 'inactive' });
+    assert.deepEqual(paths, ['POST /mode/start', 'POST /mode/stop']);
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});
+
+test('API reports offline mode state when runtime is missing or mode response is malformed', async () => {
+  const fixture = await createRuntimeFixture();
+  const server = createServer((_request, response) => {
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ state: 'active' }));
+  });
+
+  try {
+    assert.deepEqual(await startMode(fixture.runtimeFile), { state: 'offline' });
+
+    const port = await listen(server);
+    await writeFile(
+      fixture.runtimeFile,
+      JSON.stringify({ host: '127.0.0.1', port, runtimeId: 'extension-runtime' }),
+      'utf8',
+    );
+    assert.deepEqual(await startMode(fixture.runtimeFile), { state: 'offline' });
+  } finally {
+    await close(server);
+    await fixture.cleanup();
+  }
+});