@cursorpool-dev/cli 0.5.6

package/node_modules/@cursor-pool/extension/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@cursor-pool/extension",
+  "version": "0.5.6",
+  "displayName": "Cursor Pool 平台模式",
+  "publisher": "cursor-pool",
+  "engines": {
+    "vscode": "^1.90.0"
+  },
+  "activationEvents": [
+    "onView:cursorPool.statusPanel",
+    "onCommand:cursorPool.openClient",
+    "onCommand:cursorPool.reportStatus"
+  ],
+  "type": "module",
+  "main": "./dist/extension.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./src/extension.ts",
+    "./api": "./src/api.ts",
+    "./panel": "./src/panel.ts",
+    "./runtime": "./src/runtime.ts"
+  },
+  "dependencies": {
+    "@cursor-pool/service": "0.5.6",
+    "@cursor-pool/shared": "0.5.6"
+  },
+  "contributes": {
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "cursorPoolClient",
+          "title": "Cursor Pool 平台模式",
+          "icon": "resources/cursor-pool.svg"
+        }
+      ]
+    },
+    "views": {
+      "cursorPoolClient": [
+        {
+          "id": "cursorPool.statusPanel",
+          "name": "用户端",
+          "type": "webview"
+        }
+      ]
+    },
+    "commands": [
+      {
+        "command": "cursorPool.openClient",
+        "title": "Cursor Pool: 打开用户端"
+      },
+      {
+        "command": "cursorPool.openConsole",
+        "title": "Cursor Pool: Open Web Console"
+      },
+      {
+        "command": "cursorPool.reportStatus",
+        "title": "Cursor Pool: Report Status"
+      }
+    ]
+  },
+  "scripts": {
+    "test": "tsx --test test/*.test.ts"
+  }
+}

package/node_modules/@cursor-pool/extension/resources/cursor-pool.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M4 7.5 12 3l8 4.5v9L12 21l-8-4.5v-9Z"/>
+  <path d="M8.5 9.5h7"/>
+  <path d="M8.5 14.5h4.5"/>
+  <path d="M16 13.5l2 2-2 2"/>
+</svg>

package/node_modules/@cursor-pool/extension/src/api.ts

@@ -0,0 +1,545 @@
+import { arch, hostname, platform as osPlatform } from 'node:os';
+import { readRuntimeInfo, writeRuntimeInfo, type RuntimeInfo } from './runtime';
+import { startServer } from '@cursor-pool/service';
+import { readClientConfig } from '@cursor-pool/shared/clientConfig';
+
+const DEFAULT_SERVICE_PORT = 56393;
+
+export type ServiceState = 'running' | 'stopped';
+export type PlatformUserSummary = {
+  id: string;
+  email: string;
+};
+export type PlatformDeviceSummary = {
+  id: string;
+  status: string;
+  lastHeartbeatAt: string;
+};
+export type PlatformModeReleaseReason =
+  | 'product-missing'
+  | 'product-unavailable'
+  | 'insufficient-credits'
+  | 'invalid-token'
+  | 'device-inactive';
+export type PlatformModeSnapshot =
+  | { state: 'inactive'; releaseReason?: PlatformModeReleaseReason; releasedAt?: string }
+  | { state: 'active'; productId: string; startedAt: string };
+export type PlatformModeResult =
+  | PlatformModeSnapshot
+  | { state: 'logged-out' }
+  | { state: 'offline' }
+  | { state: 'invalid-token' }
+  | { state: 'product-not-selected' }
+  | { state: 'product-not-found'; productId: string }
+  | { state: 'product-unavailable'; productId: string }
+  | {
+      state: 'insufficient-credits';
+      productId: string;
+      requiredCredits: number;
+      currentCredits: number;
+    };
+export type PlatformStatus =
+  | { state: 'logged-out' }
+  | {
+      state: 'logged-in';
+      user: PlatformUserSummary;
+      device: PlatformDeviceSummary;
+      mode?: PlatformModeSnapshot;
+    }
+  | {
+      state: 'offline';
+      user?: PlatformUserSummary;
+      device?: PlatformDeviceSummary;
+      mode?: PlatformModeSnapshot;
+    }
+  | {
+      state: 'invalid-token';
+      user?: PlatformUserSummary;
+      device?: PlatformDeviceSummary;
+      mode?: PlatformModeSnapshot;
+    };
+export type PlatformProductSummary = {
+  id: string;
+  name: string;
+  description: string;
+  status: 'available' | 'unavailable';
+  minCredits: number;
+  usageLabel: string;
+};
+export type PlatformCatalog =
+  | { state: 'logged-out'; products: [] }
+  | {
+      state: 'logged-in';
+      account: { credits: number };
+      mode?: PlatformModeSnapshot;
+      selectedProductId?: string;
+      products: PlatformProductSummary[];
+    }
+  | { state: 'offline'; mode?: PlatformModeSnapshot; products: [] }
+  | { state: 'invalid-token'; mode?: PlatformModeSnapshot; products: [] };
+export type PlatformSelectionResult =
+  | { state: 'selected'; selectedProductId: string }
+  | { state: 'logged-out' }
+  | { state: 'offline' }
+  | { state: 'invalid-token' }
+  | { state: 'product-not-found'; productId: string }
+  | { state: 'product-unavailable'; productId: string };
+export type ExtensionServiceStatus = {
+  service: ServiceState;
+  runtime: RuntimeInfo | null;
+};
+
+export type PlatformLoginInput = {
+  runtimeFile?: string;
+  fallbackPort?: number;
+  email: string;
+  password: string;
+};
+
+export type PlatformSelectionInput = {
+  runtimeFile?: string;
+  fallbackPort?: number;
+  productId: string;
+};
+
+export type RuntimeResolutionOptions = {
+  runtimeFile?: string;
+  fallbackPort?: number;
+};
+
+const localExtensionServices = new Map<string, Awaited<ReturnType<typeof startServer>>>();
+
+export function buildExtensionDeviceInfo() {
+  return {
+    name: hostname(),
+    os: osPlatform(),
+    arch: arch(),
+    extensionVersion: '0.5.6',
+  };
+}
+
+function serviceUrl(runtime: RuntimeInfo, path: string) {
+  return `http://${runtime.host}:${runtime.port}${path}`;
+}
+
+async function probeRuntime(runtime: RuntimeInfo): Promise<RuntimeInfo | null> {
+  try {
+    const response = await fetch(serviceUrl(runtime, '/health'));
+    const health = (await response.json()) as { ok?: unknown; runtimeId?: unknown };
+    if (!response.ok || health.ok !== true || typeof health.runtimeId !== 'string') {
+      return null;
+    }
+    if (runtime.runtimeId && health.runtimeId !== runtime.runtimeId) {
+      return null;
+    }
+    return { ...runtime, runtimeId: health.runtimeId };
+  } catch {
+    return null;
+  }
+}
+
+async function resolveHealthyRuntime(options: RuntimeResolutionOptions = {}): Promise<RuntimeInfo | null> {
+  const runtime = await readRuntimeInfo({ runtimeFile: options.runtimeFile });
+  const allowFallback = options.runtimeFile === undefined || options.fallbackPort !== undefined;
+
+  if (runtime) {
+    const healthyRuntime = await probeRuntime(runtime);
+    if (healthyRuntime) {
+      return healthyRuntime;
+    }
+  }
+
+  if (!allowFallback) {
+    return null;
+  }
+
+  const fallbackRuntime: RuntimeInfo = {
+    host: '127.0.0.1',
+    port: options.fallbackPort ?? DEFAULT_SERVICE_PORT,
+    runtimeId: '',
+  };
+  const healthyFallback = await probeRuntime(fallbackRuntime);
+  if (!healthyFallback) {
+    return null;
+  }
+
+  await writeRuntimeInfo(healthyFallback, { runtimeFile: options.runtimeFile });
+  return healthyFallback;
+}
+
+export async function ensureLocalService(
+  runtimeFile?: string,
+  options: { platformApiBaseUrl?: string } = {},
+): Promise<RuntimeInfo> {
+  const healthy = await resolveHealthyRuntime({ runtimeFile });
+  if (healthy) {
+    return healthy;
+  }
+
+  const key = runtimeFile ?? '~/.cursor-pool/runtime.json';
+  const existing = localExtensionServices.get(key);
+  if (existing) {
+    return { host: existing.host, port: existing.port, runtimeId: existing.runtimeId };
+  }
+
+  const clientConfig = await readClientConfig();
+  const service = await startServer({
+    runtimeFile,
+    platformApiBaseUrl:
+      options.platformApiBaseUrl ?? process.env.CURSOR_POOL_API_BASE_URL ?? clientConfig.apiBaseUrl,
+  });
+  localExtensionServices.set(key, service);
+  return { host: service.host, port: service.port, runtimeId: service.runtimeId };
+}
+
+async function resolveRuntimeForRequest(options: RuntimeResolutionOptions = {}): Promise<RuntimeInfo | null> {
+  const runtime = await readRuntimeInfo({ runtimeFile: options.runtimeFile });
+  const allowFallback = options.runtimeFile === undefined || options.fallbackPort !== undefined;
+
+  if (runtime && !allowFallback) {
+    return runtime;
+  }
+
+  return resolveHealthyRuntime(options);
+}
+
+function isUserSummary(value: unknown): value is PlatformUserSummary {
+  const user = value as PlatformUserSummary;
+  return typeof user?.id === 'string' && typeof user.email === 'string';
+}
+
+function isDeviceSummary(value: unknown): value is PlatformDeviceSummary {
+  const device = value as PlatformDeviceSummary;
+  return (
+    typeof device?.id === 'string' &&
+    typeof device.status === 'string' &&
+    typeof device.lastHeartbeatAt === 'string'
+  );
+}
+
+function isProductSummary(value: unknown): value is PlatformProductSummary {
+  const product = value as PlatformProductSummary;
+  return (
+    typeof product?.id === 'string' &&
+    typeof product.name === 'string' &&
+    typeof product.description === 'string' &&
+    (product.status === 'available' || product.status === 'unavailable') &&
+    Number.isInteger(product.minCredits) &&
+    product.minCredits >= 0 &&
+    typeof product.usageLabel === 'string'
+  );
+}
+
+function isPlatformModeReleaseReason(value: unknown): value is PlatformModeReleaseReason {
+  return (
+    value === 'product-missing' ||
+    value === 'product-unavailable' ||
+    value === 'insufficient-credits' ||
+    value === 'invalid-token' ||
+    value === 'device-inactive'
+  );
+}
+
+function normalizePlatformMode(value: unknown): PlatformModeSnapshot | null {
+  const mode = value as PlatformModeSnapshot;
+  if (mode?.state === 'inactive') {
+    return {
+      state: 'inactive',
+      ...(isPlatformModeReleaseReason(mode.releaseReason) && typeof mode.releasedAt === 'string'
+        ? { releaseReason: mode.releaseReason, releasedAt: mode.releasedAt }
+        : {}),
+    };
+  }
+  if (
+    mode?.state === 'active' &&
+    typeof mode.productId === 'string' &&
+    typeof mode.startedAt === 'string'
+  ) {
+    return { state: 'active', productId: mode.productId, startedAt: mode.startedAt };
+  }
+  return null;
+}
+
+function normalizePlatformModeResult(value: unknown): PlatformModeResult {
+  const mode = normalizePlatformMode(value);
+  if (mode) {
+    return mode;
+  }
+
+  const result = value as PlatformModeResult;
+  if (
+    result?.state === 'logged-out' ||
+    result?.state === 'offline' ||
+    result?.state === 'invalid-token' ||
+    result?.state === 'product-not-selected'
+  ) {
+    return { state: result.state };
+  }
+  if (
+    (result?.state === 'product-not-found' || result?.state === 'product-unavailable') &&
+    typeof result.productId === 'string'
+  ) {
+    return { state: result.state, productId: result.productId };
+  }
+  if (
+    result?.state === 'insufficient-credits' &&
+    typeof result.productId === 'string' &&
+    Number.isFinite(result.requiredCredits) &&
+    Number.isFinite(result.currentCredits)
+  ) {
+    return {
+      state: 'insufficient-credits',
+      productId: result.productId,
+      requiredCredits: result.requiredCredits,
+      currentCredits: result.currentCredits,
+    };
+  }
+
+  return { state: 'offline' };
+}
+
+function isPlatformStatus(value: unknown): value is PlatformStatus {
+  const status = value as PlatformStatus;
+  if (status?.state === 'logged-out') {
+    return true;
+  }
+
+  if (status?.state === 'logged-in') {
+    return (
+      isUserSummary(status.user) &&
+      isDeviceSummary(status.device) &&
+      (status.mode === undefined || normalizePlatformMode(status.mode) !== null)
+    );
+  }
+
+  if (status?.state === 'offline' || status?.state === 'invalid-token') {
+    return (
+      (status.user === undefined || isUserSummary(status.user)) &&
+      (status.device === undefined || isDeviceSummary(status.device)) &&
+      (status.mode === undefined || normalizePlatformMode(status.mode) !== null)
+    );
+  }
+
+  return false;
+}
+
+function normalizePlatformCatalog(value: unknown): PlatformCatalog {
+  const catalog = value as PlatformCatalog;
+  if (catalog?.state === 'logged-out') {
+    return { state: 'logged-out', products: [] };
+  }
+
+  if (catalog?.state === 'offline') {
+    const mode = normalizePlatformMode(catalog.mode);
+    return { state: 'offline', ...(mode ? { mode } : {}), products: [] };
+  }
+
+  if (catalog?.state === 'invalid-token') {
+    const mode = normalizePlatformMode(catalog.mode);
+    return { state: 'invalid-token', ...(mode ? { mode } : {}), products: [] };
+  }
+
+  if (
+    catalog?.state === 'logged-in' &&
+    typeof catalog.account?.credits === 'number' &&
+    Number.isFinite(catalog.account.credits) &&
+    Array.isArray(catalog.products)
+  ) {
+    return {
+      state: 'logged-in',
+      account: { credits: catalog.account.credits },
+      ...(normalizePlatformMode(catalog.mode) ? { mode: normalizePlatformMode(catalog.mode) ?? undefined } : {}),
+      ...(typeof catalog.selectedProductId === 'string'
+        ? { selectedProductId: catalog.selectedProductId }
+        : {}),
+      products: catalog.products.filter(isProductSummary),
+    };
+  }
+
+  return { state: 'offline', products: [] };
+}
+
+function normalizePlatformSelectionResult(value: unknown): PlatformSelectionResult {
+  const result = value as PlatformSelectionResult;
+  if (result?.state === 'selected' && typeof result.selectedProductId === 'string') {
+    return { state: 'selected', selectedProductId: result.selectedProductId };
+  }
+  if (result?.state === 'logged-out' || result?.state === 'offline' || result?.state === 'invalid-token') {
+    return { state: result.state };
+  }
+  if (
+    (result?.state === 'product-not-found' || result?.state === 'product-unavailable') &&
+    typeof result.productId === 'string'
+  ) {
+    return { state: result.state, productId: result.productId };
+  }
+  return { state: 'offline' };
+}
+
+function platformLoginErrorMessage(code: unknown) {
+  if (code === 'PASSWORD_LOGIN_INVALID') {
+    return '登录失败：账号或密码不正确';
+  }
+  if (code === 'PASSWORD_LOGIN_NOT_CONFIGURED') {
+    return '登录失败：这个账号还没有设置网页登录密码，请先在用户端完成注册或重置密码';
+  }
+  if (code === 'DEVICE_LIMIT_REACHED') {
+    return '登录失败：设备数量已达上限，请先在用户端移除旧设备';
+  }
+  return '登录失败：本地服务没有连上平台 API，或账号密码不正确';
+}
+
+async function postJson<T>(
+  options: RuntimeResolutionOptions,
+  path: string,
+  body?: Record<string, unknown>,
+) {
+  const runtime = await resolveRuntimeForRequest(options);
+  if (!runtime) {
+    throw new Error('Cursor Pool service runtime is unavailable');
+  }
+
+  const response = await fetch(serviceUrl(runtime, path), {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body ?? {}),
+  });
+
+  if (!response.ok) {
+    if (response.status === 400 && path === '/platform/login') {
+      const errorBody = await response.json().catch(() => ({})) as { code?: unknown };
+      throw new Error(platformLoginErrorMessage(errorBody.code));
+    }
+    throw new Error(`本地服务请求失败：${response.status}`);
+  }
+
+  return (await response.json()) as T;
+}
+
+export async function getServiceStatus(
+  runtimeFile?: string,
+  options: Omit<RuntimeResolutionOptions, 'runtimeFile'> = {},
+): Promise<ExtensionServiceStatus> {
+  const runtime = await resolveHealthyRuntime({ runtimeFile, ...options });
+  if (!runtime) {
+    return { service: 'stopped', runtime: null };
+  }
+
+  try {
+    const response = await fetch(serviceUrl(runtime, '/extension/status'), {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ connected: true }),
+    });
+    if (!response.ok) {
+      return { service: 'stopped', runtime };
+    }
+    return { service: 'running', runtime };
+  } catch {
+    return { service: 'stopped', runtime };
+  }
+}
+
+export async function getPlatformStatus(
+  runtimeFile?: string,
+  options: Omit<RuntimeResolutionOptions, 'runtimeFile'> = {},
+): Promise<PlatformStatus> {
+  const runtime = await resolveRuntimeForRequest({ runtimeFile, ...options });
+  if (!runtime) {
+    return { state: 'logged-out' };
+  }
+
+  try {
+    const response = await fetch(serviceUrl(runtime, '/platform/status'));
+    if (!response.ok) {
+      return { state: 'offline' };
+    }
+
+    const status = (await response.json()) as unknown;
+    return isPlatformStatus(status) ? status : { state: 'offline' };
+  } catch {
+    return { state: 'offline' };
+  }
+}
+
+export async function getPlatformCatalog(
+  runtimeFile?: string,
+  options: Omit<RuntimeResolutionOptions, 'runtimeFile'> = {},
+): Promise<PlatformCatalog> {
+  const runtime = await resolveRuntimeForRequest({ runtimeFile, ...options });
+  if (!runtime) {
+    return { state: 'logged-out', products: [] };
+  }
+
+  try {
+    const response = await fetch(serviceUrl(runtime, '/platform/catalog'));
+    if (!response.ok) {
+      return { state: 'offline', products: [] };
+    }
+
+    return normalizePlatformCatalog(await response.json());
+  } catch {
+    return { state: 'offline', products: [] };
+  }
+}
+
+export async function startMode(
+  runtimeFile?: string,
+  options: Omit<RuntimeResolutionOptions, 'runtimeFile'> = {},
+): Promise<PlatformModeResult> {
+  try {
+    return normalizePlatformModeResult(await postJson<unknown>({ runtimeFile, ...options }, '/mode/start'));
+  } catch {
+    return { state: 'offline' };
+  }
+}
+
+export async function stopMode(
+  runtimeFile?: string,
+  options: Omit<RuntimeResolutionOptions, 'runtimeFile'> = {},
+): Promise<PlatformModeResult> {
+  try {
+    return normalizePlatformModeResult(await postJson<unknown>({ runtimeFile, ...options }, '/mode/stop'));
+  } catch {
+    return { state: 'offline' };
+  }
+}
+
+export async function loginPlatform(options: PlatformLoginInput): Promise<PlatformStatus> {
+  return postJson<PlatformStatus>(options, '/platform/login', {
+    email: options.email,
+    password: options.password,
+    device: buildExtensionDeviceInfo(),
+  });
+}
+
+export async function selectPlatformProduct(
+  options: PlatformSelectionInput,
+): Promise<PlatformSelectionResult> {
+  const runtime = await resolveRuntimeForRequest(options);
+  if (!runtime) {
+    return { state: 'offline' };
+  }
+
+  try {
+    const response = await fetch(serviceUrl(runtime, '/platform/selection'), {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ productId: options.productId }),
+    });
+    if (!response.ok) {
+      return { state: 'offline' };
+    }
+
+    return normalizePlatformSelectionResult(await response.json());
+  } catch {
+    return { state: 'offline' };
+  }
+}
+
+export async function logoutPlatform(
+  runtimeFile?: string,
+  options: Omit<RuntimeResolutionOptions, 'runtimeFile'> = {},
+): Promise<PlatformStatus> {
+  return postJson<PlatformStatus>({ runtimeFile, ...options }, '/platform/logout');
+}