@cursorpool-dev/cli 0.5.6

package/src/diagnostics.ts

@@ -0,0 +1,558 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { DEFAULT_DIAGNOSTICS_FILE } from '@cursor-pool/shared/runtime';
+
+export type AgentCanaryDiagnostic = {
+  kind: 'agent-canary';
+  requestId: string;
+  requestType: 'agent';
+  source: 'cursor-agent-exec';
+  model: string;
+  receivedAt: string;
+  runtimeId: string;
+  gate: RequestGateDiagnostic;
+};
+
+export type AgentRequestCheckDiagnostic = {
+  kind: 'agent-request-check';
+  requestId: string;
+  requestType: 'agent';
+  source: 'cursor-agent-exec' | 'manual-check';
+  model: string;
+  receivedAt: string;
+  runtimeId: string;
+  decision: RequestGateDiagnostic;
+  route: RouteDiagnostic;
+};
+
+export type AgentRequestGatewayDiagnostic = {
+  kind: 'agent-request-gateway';
+  requestId: string;
+  requestType: 'agent';
+  source: 'cursor-agent-exec' | 'manual-check' | 'unknown';
+  model: string;
+  receivedAt: string;
+  runtimeId: string;
+  decision: GatewayDiagnostic;
+  forward: ForwardDiagnostic;
+};
+
+export type DiagnosticEntry =
+  | AgentCanaryDiagnostic
+  | AgentRequestCheckDiagnostic
+  | AgentRequestGatewayDiagnostic;
+
+export type RequestGateDiagnostic =
+  | { state: 'allowed'; productId: string; modeStartedAt: string }
+  | { state: 'blocked'; reason: string; releaseReason?: string; releasedAt?: string }
+  | { state: 'unknown' };
+
+export type RouteDiagnostic =
+  | { state: 'ready'; expiresAt: string }
+  | { state: 'expired'; expiresAt: string }
+  | { state: 'missing' }
+  | { state: 'unknown' };
+
+export type GatewayDiagnostic =
+  | { state: 'accepted'; productId: string; modeStartedAt: string; route: RouteDiagnostic }
+  | { state: 'route-missing'; productId: string; modeStartedAt: string; route: RouteDiagnostic }
+  | { state: 'route-expired'; productId: string; modeStartedAt: string; route: RouteDiagnostic }
+  | {
+      state: 'blocked';
+      reason: string;
+      releaseReason?: string;
+      releasedAt?: string;
+      route: { state: 'missing' };
+    }
+  | { state: 'unknown' };
+
+export type ForwardDiagnostic =
+  | { state: 'skipped'; reason: 'not-accepted' }
+  | { state: 'forwarded'; upstreamRequestId: string; acceptedAt: string }
+  | { state: 'rejected'; reason: string; retryAfterMs?: number }
+  | { state: 'not-configured' }
+  | { state: 'timeout' }
+  | { state: 'network-error' }
+  | { state: 'unknown' };
+
+export type DiagnosticsOptions = {
+  diagnosticsFile?: string;
+  limit?: number;
+  json?: boolean;
+};
+
+export type ClearDiagnosticsOptions = {
+  diagnosticsFile?: string;
+};
+
+const DEFAULT_LIMIT = 10;
+const MAX_FIELD_LENGTH = 256;
+
+function resolveDiagnosticsFile(diagnosticsFile = DEFAULT_DIAGNOSTICS_FILE) {
+  if (diagnosticsFile.startsWith('~/')) {
+    return join(homedir(), diagnosticsFile.slice(2));
+  }
+
+  return diagnosticsFile;
+}
+
+function assertPositiveLimit(limit: number) {
+  if (!Number.isInteger(limit) || limit <= 0) {
+    throw new Error('--limit must be a positive integer');
+  }
+}
+
+function isSafeDiagnosticString(value: unknown): value is string {
+  return (
+    typeof value === 'string' &&
+    value.length > 0 &&
+    value.length <= MAX_FIELD_LENGTH &&
+    !/[\u0000-\u001f\u007f]/.test(value)
+  );
+}
+
+function isSafeTimestamp(value: unknown): value is string {
+  return isSafeDiagnosticString(value) && !Number.isNaN(Date.parse(value));
+}
+
+function isSafeGateToken(value: unknown): value is string {
+  return isSafeDiagnosticString(value) && !/[\s=]/.test(value);
+}
+
+function isSafeGateTimestamp(value: unknown): value is string {
+  return isSafeTimestamp(value) && isSafeGateToken(value);
+}
+
+function isSafeMetadataToken(value: unknown): value is string {
+  return isSafeGateToken(value) && !isSecretLike(value);
+}
+
+function isSecretLike(value: string) {
+  return /secret|token|key|authorization|cookie|cursor/i.test(value);
+}
+
+function sanitizeRequestCheckModel(value: unknown) {
+  if (!isSafeDiagnosticString(value) || isSecretLike(value)) {
+    return 'unknown';
+  }
+
+  return value;
+}
+
+function sanitizeGateDiagnostic(value: unknown): RequestGateDiagnostic {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return { state: 'unknown' };
+  }
+
+  const gate = value as Record<string, unknown>;
+  if (gate.state === 'allowed') {
+    if (!isSafeGateToken(gate.productId) || !isSafeGateTimestamp(gate.modeStartedAt)) {
+      return { state: 'unknown' };
+    }
+
+    return {
+      state: 'allowed',
+      productId: gate.productId,
+      modeStartedAt: gate.modeStartedAt,
+    };
+  }
+
+  if (gate.state === 'blocked') {
+    if (!isSafeGateToken(gate.reason)) {
+      return { state: 'unknown' };
+    }
+
+    return {
+      state: 'blocked',
+      reason: gate.reason,
+      ...(isSafeGateToken(gate.releaseReason)
+        ? { releaseReason: gate.releaseReason }
+        : {}),
+      ...(isSafeGateTimestamp(gate.releasedAt) ? { releasedAt: gate.releasedAt } : {}),
+    };
+  }
+
+  return { state: 'unknown' };
+}
+
+function sanitizeRouteDiagnostic(value: unknown): RouteDiagnostic {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return { state: 'unknown' };
+  }
+
+  const route = value as Record<string, unknown>;
+  if (route.state === 'missing') {
+    return { state: 'missing' };
+  }
+
+  if (route.state === 'ready' || route.state === 'expired') {
+    if (!isSafeGateTimestamp(route.expiresAt)) {
+      return { state: 'unknown' };
+    }
+
+    return {
+      state: route.state,
+      expiresAt: route.expiresAt,
+    };
+  }
+
+  return { state: 'unknown' };
+}
+
+function sanitizeGatewayDiagnostic(value: unknown): GatewayDiagnostic {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return { state: 'unknown' };
+  }
+
+  const decision = value as Record<string, unknown>;
+  if (
+    decision.state === 'accepted' ||
+    decision.state === 'route-missing' ||
+    decision.state === 'route-expired'
+  ) {
+    if (!isSafeGateToken(decision.productId) || !isSafeGateTimestamp(decision.modeStartedAt)) {
+      return { state: 'unknown' };
+    }
+
+    const route = sanitizeRouteDiagnostic(decision.route);
+    if (decision.state === 'accepted' && route.state === 'ready') {
+      return {
+        state: 'accepted',
+        productId: decision.productId,
+        modeStartedAt: decision.modeStartedAt,
+        route,
+      };
+    }
+
+    if (decision.state === 'route-missing' && route.state === 'missing') {
+      return {
+        state: 'route-missing',
+        productId: decision.productId,
+        modeStartedAt: decision.modeStartedAt,
+        route,
+      };
+    }
+
+    if (decision.state === 'route-expired' && route.state === 'expired') {
+      return {
+        state: 'route-expired',
+        productId: decision.productId,
+        modeStartedAt: decision.modeStartedAt,
+        route,
+      };
+    }
+
+    return { state: 'unknown' };
+  }
+
+  if (decision.state === 'blocked') {
+    const blocked = sanitizeGateDiagnostic(decision);
+    if (blocked.state === 'blocked') {
+      return { ...blocked, route: { state: 'missing' } };
+    }
+  }
+
+  return { state: 'unknown' };
+}
+
+function sanitizeForwardDiagnostic(value: unknown): ForwardDiagnostic {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return { state: 'unknown' };
+  }
+
+  const forward = value as Record<string, unknown>;
+  if (forward.state === 'skipped') {
+    return forward.reason === 'not-accepted' ? { state: 'skipped', reason: 'not-accepted' } : { state: 'unknown' };
+  }
+
+  if (forward.state === 'forwarded') {
+    if (!isSafeGateToken(forward.upstreamRequestId) || !isSafeGateTimestamp(forward.acceptedAt)) {
+      return { state: 'unknown' };
+    }
+    return {
+      state: 'forwarded',
+      upstreamRequestId: forward.upstreamRequestId,
+      acceptedAt: forward.acceptedAt,
+    };
+  }
+
+  if (forward.state === 'rejected') {
+    if (!isSafeGateToken(forward.reason)) {
+      return { state: 'unknown' };
+    }
+    const retryAfterMs = forward.retryAfterMs;
+    return {
+      state: 'rejected',
+      reason: forward.reason,
+      ...(Number.isInteger(retryAfterMs) && retryAfterMs >= 0 && retryAfterMs <= 86_400_000
+        ? { retryAfterMs }
+        : {}),
+    };
+  }
+
+  if (forward.state === 'not-configured' || forward.state === 'timeout' || forward.state === 'network-error') {
+    return { state: forward.state };
+  }
+
+  return { state: 'unknown' };
+}
+
+function sanitizeRequestCheckDiagnostic(record: Record<string, unknown>): AgentRequestCheckDiagnostic | null {
+  if (
+    !isSafeMetadataToken(record.requestId) ||
+    record.requestType !== 'agent' ||
+    (record.source !== 'cursor-agent-exec' && record.source !== 'manual-check') ||
+    !isSafeTimestamp(record.receivedAt) ||
+    !isSafeMetadataToken(record.runtimeId)
+  ) {
+    return null;
+  }
+
+  return {
+    kind: 'agent-request-check',
+    requestId: record.requestId,
+    requestType: 'agent',
+    source: record.source,
+    model: sanitizeRequestCheckModel(record.model),
+    receivedAt: record.receivedAt,
+    runtimeId: record.runtimeId,
+    decision: sanitizeGateDiagnostic(record.decision),
+    route: sanitizeRouteDiagnostic(record.route),
+  };
+}
+
+function sanitizeRequestGatewayDiagnostic(record: Record<string, unknown>): AgentRequestGatewayDiagnostic | null {
+  if (
+    !isSafeMetadataToken(record.requestId) ||
+    record.requestType !== 'agent' ||
+    (record.source !== 'cursor-agent-exec' &&
+      record.source !== 'manual-check' &&
+      record.source !== 'unknown') ||
+    !isSafeTimestamp(record.receivedAt) ||
+    !isSafeMetadataToken(record.runtimeId)
+  ) {
+    return null;
+  }
+
+  return {
+    kind: 'agent-request-gateway',
+    requestId: record.requestId,
+    requestType: 'agent',
+    source: record.source,
+    model: sanitizeRequestCheckModel(record.model),
+    receivedAt: record.receivedAt,
+    runtimeId: record.runtimeId,
+    decision: sanitizeGatewayDiagnostic(record.decision),
+    forward: sanitizeForwardDiagnostic(record.forward),
+  };
+}
+
+function sanitizeCanaryDiagnostic(record: Record<string, unknown>): AgentCanaryDiagnostic | null {
+  if (
+    !isSafeMetadataToken(record.requestId) ||
+    record.requestType !== 'agent' ||
+    record.source !== 'cursor-agent-exec' ||
+    !isSafeTimestamp(record.receivedAt) ||
+    !isSafeMetadataToken(record.runtimeId)
+  ) {
+    return null;
+  }
+
+  return {
+    kind: 'agent-canary',
+    requestId: record.requestId,
+    requestType: 'agent',
+    source: 'cursor-agent-exec',
+    model: sanitizeRequestCheckModel(record.model),
+    receivedAt: record.receivedAt,
+    runtimeId: record.runtimeId,
+    gate: sanitizeGateDiagnostic(record.gate),
+  };
+}
+
+function sanitizeDiagnostic(input: unknown): DiagnosticEntry | null {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    return null;
+  }
+
+  const record = input as Record<string, unknown>;
+
+  if (record.kind === 'agent-request-check') {
+    return sanitizeRequestCheckDiagnostic(record);
+  }
+
+  if (record.kind === 'agent-request-gateway') {
+    return sanitizeRequestGatewayDiagnostic(record);
+  }
+
+  return sanitizeCanaryDiagnostic(record);
+}
+
+async function readDiagnosticsEntries(diagnosticsFile: string) {
+  try {
+    const content = await readFile(diagnosticsFile, 'utf8');
+
+    return content
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .flatMap((line) => {
+        try {
+          const diagnostic = sanitizeDiagnostic(JSON.parse(line));
+          return diagnostic ? [diagnostic] : [];
+        } catch {
+          return [];
+        }
+      });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return null;
+    }
+
+    throw error;
+  }
+}
+
+function formatHuman(entries: DiagnosticEntry[]) {
+  if (entries.length === 0) {
+    return 'diagnostics: empty';
+  }
+
+  return [
+    `diagnostics: ${entries.length} ${entries.length === 1 ? 'entry' : 'entries'}`,
+    ...entries.map((entry) => {
+      const state =
+        entry.kind === 'agent-canary'
+          ? formatGate(entry.gate)
+          : entry.kind === 'agent-request-check'
+            ? `${formatDecision(entry.decision)} ${formatRoute(entry.route)}`
+            : `${formatGateway(entry.decision)} ${formatForward(entry.forward)}`;
+      return `${entry.receivedAt} kind=${entry.kind} requestId=${entry.requestId} source=${entry.source} requestType=${entry.requestType} model=${entry.model} runtimeId=${entry.runtimeId} ${state}`;
+    }),
+  ].join('\n');
+}
+
+function formatGate(gate: RequestGateDiagnostic) {
+  if (gate.state === 'allowed') {
+    return `gate=allowed productId=${gate.productId}`;
+  }
+
+  if (gate.state === 'blocked') {
+    return [
+      `gate=blocked reason=${gate.reason}`,
+      ...(gate.releaseReason !== undefined ? [`releaseReason=${gate.releaseReason}`] : []),
+      ...(gate.releasedAt !== undefined ? [`releasedAt=${gate.releasedAt}`] : []),
+    ].join(' ');
+  }
+
+  return 'gate=unknown';
+}
+
+function formatDecision(decision: RequestGateDiagnostic) {
+  if (decision.state === 'allowed') {
+    return `decision=allowed productId=${decision.productId}`;
+  }
+
+  if (decision.state === 'blocked') {
+    return [
+      `decision=blocked reason=${decision.reason}`,
+      ...(decision.releaseReason !== undefined ? [`releaseReason=${decision.releaseReason}`] : []),
+      ...(decision.releasedAt !== undefined ? [`releasedAt=${decision.releasedAt}`] : []),
+    ].join(' ');
+  }
+
+  return 'decision=unknown';
+}
+
+function formatRoute(route: RouteDiagnostic) {
+  if (route.state === 'ready' || route.state === 'expired') {
+    return `route=${route.state} expiresAt=${route.expiresAt}`;
+  }
+
+  return `route=${route.state}`;
+}
+
+function formatGateway(decision: GatewayDiagnostic) {
+  if (
+    decision.state === 'accepted' ||
+    decision.state === 'route-missing' ||
+    decision.state === 'route-expired'
+  ) {
+    return [
+      `decision=${decision.state}`,
+      `productId=${decision.productId}`,
+      formatRoute(decision.route),
+    ].join(' ');
+  }
+
+  if (decision.state === 'blocked') {
+    return [
+      `decision=blocked reason=${decision.reason}`,
+      ...(decision.releaseReason !== undefined ? [`releaseReason=${decision.releaseReason}`] : []),
+      ...(decision.releasedAt !== undefined ? [`releasedAt=${decision.releasedAt}`] : []),
+      'route=missing',
+    ].join(' ');
+  }
+
+  return 'decision=unknown';
+}
+
+function formatForward(forward: ForwardDiagnostic) {
+  if (forward.state === 'skipped') {
+    return 'forward=skipped reason=not-accepted';
+  }
+
+  if (forward.state === 'forwarded') {
+    return `forward=forwarded upstreamRequestId=${forward.upstreamRequestId} acceptedAt=${forward.acceptedAt}`;
+  }
+
+  if (forward.state === 'rejected') {
+    return [
+      `forward=rejected reason=${forward.reason}`,
+      ...(forward.retryAfterMs !== undefined ? [`retryAfterMs=${forward.retryAfterMs}`] : []),
+    ].join(' ');
+  }
+
+  return `forward=${forward.state}`;
+}
+
+export async function diagnostics(options: DiagnosticsOptions = {}) {
+  const limit = options.limit ?? DEFAULT_LIMIT;
+  assertPositiveLimit(limit);
+
+  const diagnosticsFile = resolveDiagnosticsFile(options.diagnosticsFile);
+  const entries = await readDiagnosticsEntries(diagnosticsFile);
+
+  if (entries === null) {
+    return options.json ? '[]' : 'diagnostics: missing';
+  }
+
+  const limitedEntries = entries.slice(-limit).map((entry) => sanitizeDiagnostic(entry));
+  const sanitizedEntries = limitedEntries.filter(
+    (entry): entry is DiagnosticEntry => entry !== null,
+  );
+
+  if (options.json) {
+    return JSON.stringify(sanitizedEntries, null, 2);
+  }
+
+  return formatHuman(sanitizedEntries);
+}
+
+export async function clearDiagnostics(options: ClearDiagnosticsOptions = {}) {
+  const diagnosticsFile = resolveDiagnosticsFile(options.diagnosticsFile);
+
+  try {
+    await readFile(diagnosticsFile, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return 'diagnostics: missing';
+    }
+
+    throw error;
+  }
+
+  await writeFile(diagnosticsFile, '', 'utf8');
+  return 'diagnostics: cleared';
+}

package/src/environment.ts

@@ -0,0 +1,18 @@
+import { arch, platform } from 'node:process';
+
+export type CliEnvironment = {
+  platform: NodeJS.Platform;
+  arch: string;
+};
+
+export type DetectEnvironmentOptions = {
+  platform?: NodeJS.Platform;
+  arch?: string;
+};
+
+export function detectEnvironment(options: DetectEnvironmentOptions = {}): CliEnvironment {
+  return {
+    platform: options.platform ?? platform,
+    arch: options.arch ?? arch,
+  };
+}

package/src/extensionBundle.ts

@@ -0,0 +1,111 @@
+import { cp, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import type { ExtensionState } from './trial';
+
+export type BundleExtensionOptions = {
+  sourceDir?: string;
+  installPath?: string;
+};
+
+export type BundleExtensionResult = {
+  state: ExtensionState;
+  installPath: string;
+};
+
+export const DEFAULT_EXTENSION_INSTALL_PATH = '~/.cursor-pool/extensions/cursor-pool-status';
+const require = createRequire(import.meta.url);
+const DEFAULT_EXTENSION_SOURCE_DIR = dirname(require.resolve('@cursor-pool/extension/package.json'));
+
+function resolveHomePath(path: string) {
+  return path.startsWith('~/') ? join(homedir(), path.slice(2)) : path;
+}
+
+export function resolveExtensionInstallPath(
+  installPath = DEFAULT_EXTENSION_INSTALL_PATH,
+) {
+  return resolveHomePath(installPath);
+}
+
+function assertSafeExtensionBundlePath(installPath: string) {
+  const resolvedInstallPath = resolve(installPath);
+  const parentSegments = dirname(resolvedInstallPath).split(/[\\/]+/).filter(Boolean);
+  const hasExtensionsParent = parentSegments.includes('extensions');
+
+  if (basename(resolvedInstallPath) !== 'cursor-pool-status' || !hasExtensionsParent) {
+    throw new Error(
+      `Unsafe extension install path for recursive removal: ${installPath}. Expected an extensions/cursor-pool-status bundle path.`,
+    );
+  }
+}
+
+async function exists(path: string) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return false;
+    }
+    throw error;
+  }
+}
+
+function buildRuntimeManifest(sourceManifest: Record<string, unknown>) {
+  return {
+    name: 'cursorpool',
+    version: typeof sourceManifest.version === 'string' ? sourceManifest.version : '0.5.6',
+    displayName: 'Cursor Pool 平台模式',
+    publisher: 'cursor-pool',
+    type: sourceManifest.type,
+    engines: sourceManifest.engines ?? { vscode: '^1.90.0' },
+    activationEvents: sourceManifest.activationEvents,
+    main: sourceManifest.main,
+    contributes: sourceManifest.contributes,
+  };
+}
+
+export async function getExtensionState(installPath = DEFAULT_EXTENSION_INSTALL_PATH) {
+  const resolvedInstallPath = resolveExtensionInstallPath(installPath);
+  const manifestPath = join(resolvedInstallPath, 'package.json');
+  const entryPath = join(resolvedInstallPath, 'dist/extension.js');
+  return (await exists(manifestPath)) && (await exists(entryPath)) ? 'bundled' : 'missing';
+}
+
+export async function bundleExtension(
+  options: BundleExtensionOptions = {},
+): Promise<BundleExtensionResult> {
+  const sourceDir = options.sourceDir ?? DEFAULT_EXTENSION_SOURCE_DIR;
+  const installPath = resolveExtensionInstallPath(options.installPath);
+  const manifestPath = join(sourceDir, 'package.json');
+  const entryPath = join(sourceDir, 'dist/extension.js');
+  const resourcesPath = join(sourceDir, 'resources');
+
+  if (!(await exists(manifestPath)) || !(await exists(entryPath))) {
+    return { state: 'missing', installPath };
+  }
+
+  assertSafeExtensionBundlePath(installPath);
+  await rm(installPath, { recursive: true, force: true });
+  await mkdir(installPath, { recursive: true });
+  const sourceManifest = JSON.parse(await readFile(manifestPath, 'utf8')) as Record<string, unknown>;
+  await writeFile(
+    join(installPath, 'package.json'),
+    `${JSON.stringify(buildRuntimeManifest(sourceManifest), null, 2)}\n`,
+    'utf8',
+  );
+  await mkdir(join(installPath, 'dist'), { recursive: true });
+  await cp(entryPath, join(installPath, 'dist/extension.js'));
+  if (await exists(resourcesPath)) {
+    await cp(resourcesPath, join(installPath, 'resources'), { recursive: true });
+  }
+
+  return { state: 'bundled', installPath };
+}
+
+export async function removeExtensionBundle(installPath = DEFAULT_EXTENSION_INSTALL_PATH) {
+  const resolvedInstallPath = resolveExtensionInstallPath(installPath);
+  assertSafeExtensionBundlePath(resolvedInstallPath);
+  await rm(resolvedInstallPath, { recursive: true, force: true });
+}