@cursorpool-dev/cli 0.5.6

package/node_modules/@cursor-pool/extension/dist/extension.js

@@ -0,0 +1,2910 @@
+// packages/extension/src/api.ts
+import { arch, hostname, platform as osPlatform } from "node:os";
+
+// packages/service/src/health.ts
+function buildHealth(runtime) {
+  return {
+    ok: true,
+    host: runtime.host,
+    port: runtime.port,
+    runtimeId: runtime.runtimeId
+  };
+}
+
+// packages/shared/src/metadata.ts
+var SAFE_METADATA_KEYS = [
+  "requestId",
+  "model",
+  "requestType",
+  "source",
+  "cursorVersion",
+  "clientVersion",
+  "entrypoint"
+];
+function sanitizeRequestMetadata(input) {
+  const output = {};
+  for (const key of SAFE_METADATA_KEYS) {
+    if (input[key] !== void 0) {
+      output[key] = input[key];
+    }
+  }
+  return output;
+}
+
+// packages/service/src/metadata.ts
+var EXTENSION_STATUS_KEYS = ["connected", "cursorVersion", "clientVersion"];
+function sanitizeServiceMetadata(input) {
+  return {
+    model: "unknown",
+    ...sanitizeRequestMetadata(input)
+  };
+}
+function sanitizeExtensionStatus(input) {
+  const output = {};
+  for (const key of EXTENSION_STATUS_KEYS) {
+    if (input[key] !== void 0) {
+      output[key] = input[key];
+    }
+  }
+  return output;
+}
+
+// packages/service/src/platformSession.ts
+import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var DEFAULT_PLATFORM_SESSION_FILE = "~/.cursor-pool/session.json";
+var SAFE_POOL_TOKEN_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
+var SECRET_LIKE_PATTERN = /(api[_-]?key|authorization|bearer|cursor[_-]?auth|provider[_-]?secret|secret|token|sk-[A-Za-z0-9])/i;
+function resolvePlatformSessionFile(sessionFile = DEFAULT_PLATFORM_SESSION_FILE) {
+  if (sessionFile.startsWith("~/")) {
+    return join(homedir(), sessionFile.slice(2));
+  }
+  return sessionFile;
+}
+function cleanApiBaseUrl(apiBaseUrl) {
+  return apiBaseUrl.replace(/\/+$/, "");
+}
+function isSafePoolToken(value) {
+  return typeof value === "string" && SAFE_POOL_TOKEN_PATTERN.test(value) && !SECRET_LIKE_PATTERN.test(value);
+}
+function cleanPoolTokens(values) {
+  return values.filter(isSafePoolToken);
+}
+function sanitizePoolSessionSummary(value) {
+  return {
+    id: value.id,
+    productId: value.productId,
+    providerType: value.providerType,
+    status: value.status,
+    startedAt: value.startedAt,
+    expiresAt: value.expiresAt,
+    routeTokenExpiresAt: value.routeTokenExpiresAt,
+    routeStrategy: "platform-gateway",
+    bannedModels: cleanPoolTokens(value.bannedModels),
+    ...value.availableModels !== void 0 ? { availableModels: cleanPoolTokens(value.availableModels) } : {},
+    capabilities: {
+      streaming: value.capabilities.streaming,
+      usageEstimate: value.capabilities.usageEstimate,
+      hardSpendLimit: value.capabilities.hardSpendLimit
+    }
+  };
+}
+function asStatus(session) {
+  return {
+    state: "logged-in",
+    user: session.user,
+    device: session.device,
+    mode: platformModeFromSession(session)
+  };
+}
+function isPlatformModeReleaseReason(value) {
+  return value === "product-missing" || value === "product-unavailable" || value === "insufficient-credits" || value === "invalid-token" || value === "device-inactive";
+}
+function inactiveModeFromSession(session) {
+  if (isPlatformModeReleaseReason(session?.lastModeReleaseReason) && typeof session.lastModeReleasedAt === "string") {
+    return {
+      state: "inactive",
+      releaseReason: session.lastModeReleaseReason,
+      releasedAt: session.lastModeReleasedAt
+    };
+  }
+  return { state: "inactive" };
+}
+function platformModeFromSession(session) {
+  if (session?.platformMode === "active" && typeof session.activeProductId === "string" && typeof session.platformModeStartedAt === "string") {
+    return {
+      state: "active",
+      productId: session.activeProductId,
+      startedAt: session.platformModeStartedAt
+    };
+  }
+  return inactiveModeFromSession(session);
+}
+function clearPlatformMode(session) {
+  const {
+    platformMode: _platformMode,
+    activeProductId: _activeProductId,
+    platformModeStartedAt: _platformModeStartedAt,
+    poolSession: _poolSession,
+    routeToken: _routeToken,
+    ...inactiveSession
+  } = session;
+  return inactiveSession;
+}
+function clearModeRelease(session) {
+  const {
+    lastModeReleaseReason: _lastModeReleaseReason,
+    lastModeReleasedAt: _lastModeReleasedAt,
+    ...activeSession
+  } = session;
+  return activeSession;
+}
+function releasePlatformMode(session, reason) {
+  const releasedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    session: {
+      ...clearPlatformMode(session),
+      lastModeReleaseReason: reason,
+      lastModeReleasedAt: releasedAt
+    },
+    mode: { state: "inactive", releaseReason: reason, releasedAt }
+  };
+}
+async function releaseActivePlatformMode(session, reason, options) {
+  const mode = platformModeFromSession(session);
+  if (mode.state !== "active") {
+    return { session, mode };
+  }
+  const released = releasePlatformMode(session, reason);
+  await writePlatformSession(released.session, options);
+  return released;
+}
+async function releaseForInactiveDevice(session, options) {
+  if (session.device.status === "active") {
+    return { session, mode: platformModeFromSession(session) };
+  }
+  return releaseActivePlatformMode(session, "device-inactive", options);
+}
+function isUserSummary(value) {
+  const user = value;
+  return typeof user?.id === "string" && typeof user.email === "string";
+}
+function isDeviceSummary(value) {
+  const device = value;
+  return typeof device?.id === "string" && typeof device.status === "string" && typeof device.lastHeartbeatAt === "string";
+}
+function isProductSummary(value) {
+  const product = value;
+  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 sanitizeProductSummary(value) {
+  if (!isProductSummary(value)) {
+    return void 0;
+  }
+  return {
+    id: value.id,
+    name: value.name,
+    description: value.description,
+    status: value.status,
+    minCredits: value.minCredits,
+    usageLabel: value.usageLabel
+  };
+}
+function isPoolSessionSummary(value) {
+  const session = value;
+  return typeof session?.id === "string" && typeof session.productId === "string" && typeof session.providerType === "string" && (session.status === "active" || session.status === "refresh-required" || session.status === "stopping" || session.status === "stopped" || session.status === "expired" || session.status === "failed") && typeof session.startedAt === "string" && typeof session.expiresAt === "string" && typeof session.routeTokenExpiresAt === "string" && session.routeStrategy === "platform-gateway" && Array.isArray(session.bannedModels) && session.bannedModels.every((model) => typeof model === "string") && (session.availableModels === void 0 || Array.isArray(session.availableModels) && session.availableModels.every((model) => typeof model === "string")) && typeof session.capabilities?.streaming === "boolean" && typeof session.capabilities.usageEstimate === "boolean" && typeof session.capabilities.hardSpendLimit === "boolean";
+}
+function isLocalRouteTokenState(value) {
+  const route = value;
+  return typeof route?.token === "string" && typeof route.expiresAt === "string";
+}
+function isPlatformSession(value) {
+  const session = value;
+  return typeof session?.apiBaseUrl === "string" && typeof session.deviceToken === "string" && typeof session.createdAt === "string" && isUserSummary(session.user) && isDeviceSummary(session.device) && (session.selectedProductId === void 0 || typeof session.selectedProductId === "string") && (session.platformMode === void 0 || session.platformMode === "active" || session.platformMode === "inactive") && (session.activeProductId === void 0 || typeof session.activeProductId === "string") && (session.platformModeStartedAt === void 0 || typeof session.platformModeStartedAt === "string") && (session.lastModeReleaseReason === void 0 || isPlatformModeReleaseReason(session.lastModeReleaseReason)) && (session.lastModeReleasedAt === void 0 || typeof session.lastModeReleasedAt === "string") && (session.poolSession === void 0 || isPoolSessionSummary(session.poolSession)) && (session.routeToken === void 0 || isLocalRouteTokenState(session.routeToken));
+}
+async function readPlatformSessionSnapshot(options = {}) {
+  const sessionFile = resolvePlatformSessionFile(options.sessionFile);
+  try {
+    const session = JSON.parse(await readFile(sessionFile, "utf8"));
+    return isPlatformSession(session) ? { state: "valid", session } : { state: "invalid" };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { state: "missing" };
+    }
+    if (error instanceof SyntaxError) {
+      return { state: "invalid" };
+    }
+    throw error;
+  }
+}
+async function readPlatformGatewayForwardContext(options = {}) {
+  const snapshot = await readPlatformSessionSnapshot(options);
+  if (snapshot.state !== "valid") {
+    return {};
+  }
+  return {
+    apiBaseUrl: snapshot.session.apiBaseUrl,
+    deviceToken: snapshot.session.deviceToken,
+    routeToken: snapshot.session.routeToken?.token,
+    poolSessionId: snapshot.session.poolSession?.id
+  };
+}
+async function readPlatformSession(options = {}) {
+  const snapshot = await readPlatformSessionSnapshot(options);
+  return snapshot.state === "valid" ? snapshot.session : null;
+}
+async function writePlatformSession(session, options = {}) {
+  const sessionFile = resolvePlatformSessionFile(options.sessionFile);
+  await mkdir(dirname(sessionFile), { recursive: true, mode: 448 });
+  await writeFile(sessionFile, `${JSON.stringify(session, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  await chmod(sessionFile, 384);
+}
+async function clearPlatformSession(options = {}) {
+  await rm(resolvePlatformSessionFile(options.sessionFile), { force: true });
+}
+async function requestJson(url, options = {}) {
+  const headers = {};
+  if (options.body) {
+    headers["content-type"] = "application/json";
+  }
+  if (options.token) {
+    headers.authorization = `Bearer ${options.token}`;
+  }
+  const response = await fetch(url, {
+    method: options.method ?? "GET",
+    headers,
+    body: options.body ? JSON.stringify(options.body) : void 0
+  });
+  if (!response.ok) {
+    const error = new Error(`Request failed with status ${response.status}`);
+    error.status = response.status;
+    try {
+      const body = await response.json();
+      const detail = body.detail;
+      if (typeof detail?.code === "string" && /^[A-Z0-9_:-]{1,96}$/.test(detail.code)) {
+        error.platformCode = detail.code;
+      }
+    } catch {
+    }
+    throw error;
+  }
+  return await response.json();
+}
+async function exchangeDeviceToken(request) {
+  return requestJson(`${cleanApiBaseUrl(request.apiBaseUrl)}/auth/device-token`, {
+    method: "POST",
+    body: {
+      code: request.code,
+      device: request.device
+    }
+  });
+}
+async function exchangePasswordDeviceToken(request) {
+  return requestJson(`${cleanApiBaseUrl(request.apiBaseUrl)}/auth/password-device-token`, {
+    method: "POST",
+    body: {
+      email: request.email,
+      password: request.password,
+      device: request.device
+    }
+  });
+}
+async function fetchMe(session) {
+  return requestJson(`${cleanApiBaseUrl(session.apiBaseUrl)}/me`, {
+    token: session.deviceToken
+  });
+}
+async function fetchAccountSummary(session) {
+  return requestJson(`${cleanApiBaseUrl(session.apiBaseUrl)}/account/summary`, {
+    token: session.deviceToken
+  });
+}
+async function fetchProducts(session) {
+  const response = await requestJson(`${cleanApiBaseUrl(session.apiBaseUrl)}/products`, {
+    token: session.deviceToken
+  });
+  return {
+    products: Array.isArray(response.products) ? response.products.flatMap((product) => {
+      const sanitized = sanitizeProductSummary(product);
+      return sanitized ? [sanitized] : [];
+    }) : []
+  };
+}
+async function postHeartbeat(request) {
+  return requestJson(`${cleanApiBaseUrl(request.session.apiBaseUrl)}/devices/heartbeat`, {
+    method: "POST",
+    body: request.payload,
+    token: request.session.deviceToken
+  });
+}
+async function postLogout(request) {
+  await requestJson(`${cleanApiBaseUrl(request.session.apiBaseUrl)}/auth/logout`, {
+    method: "POST",
+    token: request.session.deviceToken
+  });
+}
+async function startPoolSession(request) {
+  return requestJson(
+    `${cleanApiBaseUrl(request.session.apiBaseUrl)}/pool-sessions/start`,
+    {
+      method: "POST",
+      token: request.session.deviceToken,
+      body: {
+        productId: request.productId,
+        ...request.client ? { client: request.client } : {}
+      }
+    }
+  );
+}
+async function stopPoolSession(request) {
+  return requestJson(
+    `${cleanApiBaseUrl(request.session.apiBaseUrl)}/pool-sessions/${request.poolSessionId}/stop`,
+    {
+      method: "POST",
+      token: request.session.deviceToken,
+      body: {
+        reason: request.reason
+      }
+    }
+  );
+}
+function poolFailureToModeResult(reason, product, currentCredits) {
+  if (reason === "INSUFFICIENT_CREDITS") {
+    return {
+      state: "insufficient-credits",
+      productId: product.id,
+      requiredCredits: product.minCredits,
+      currentCredits
+    };
+  }
+  if (reason === "DEVICE_INVALID") {
+    return { state: "device-inactive" };
+  }
+  if (reason === "PRODUCT_UNAVAILABLE") {
+    return { state: "product-unavailable", productId: product.id };
+  }
+  if (reason === "PROVIDER_UNAVAILABLE") {
+    return { state: "provider-unavailable" };
+  }
+  if (reason === "RATE_LIMITED") {
+    return { state: "provider-rate-limited" };
+  }
+  if (reason === "MODEL_BANNED") {
+    return { state: "model-banned" };
+  }
+  return { state: "manual-review-required" };
+}
+async function statusFromRequestError(error, session, options = {}) {
+  if (error.status === 401) {
+    const currentSession = await readPlatformSession(options) ?? session;
+    const { mode } = options.releaseActiveModeOnUnauthorized ? await releaseActivePlatformMode(currentSession, "invalid-token", options) : { mode: platformModeFromSession(currentSession) };
+    return { state: "invalid-token", user: currentSession.user, device: currentSession.device, mode };
+  }
+  return { state: "offline", user: session.user, device: session.device, mode: platformModeFromSession(session) };
+}
+async function loginWithCode(options) {
+  const tokenResponse = await (options.exchangeDeviceToken ?? exchangeDeviceToken)({
+    code: options.code,
+    apiBaseUrl: options.apiBaseUrl,
+    device: options.device ?? {}
+  });
+  const session = {
+    apiBaseUrl: cleanApiBaseUrl(options.apiBaseUrl),
+    deviceToken: tokenResponse.deviceToken,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    user: tokenResponse.user,
+    device: tokenResponse.device
+  };
+  await writePlatformSession(session, { sessionFile: options.sessionFile });
+  return asStatus(session);
+}
+async function loginWithPassword(options) {
+  const tokenResponse = await (options.exchangePasswordDeviceToken ?? exchangePasswordDeviceToken)({
+    email: options.email,
+    password: options.password,
+    apiBaseUrl: options.apiBaseUrl,
+    device: options.device ?? {}
+  });
+  const session = {
+    apiBaseUrl: cleanApiBaseUrl(options.apiBaseUrl),
+    deviceToken: tokenResponse.deviceToken,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    user: tokenResponse.user,
+    device: tokenResponse.device
+  };
+  await writePlatformSession(session, { sessionFile: options.sessionFile });
+  return asStatus(session);
+}
+async function platformStatus(options = {}) {
+  const session = await readPlatformSession(options);
+  if (!session) {
+    return { state: "logged-out" };
+  }
+  let me;
+  try {
+    me = await fetchMe(session);
+  } catch (error) {
+    return statusFromRequestError(error, session, {
+      ...options,
+      releaseActiveModeOnUnauthorized: true
+    });
+  }
+  const currentSession = await readPlatformSession(options);
+  if (!currentSession) {
+    return { state: "logged-out" };
+  }
+  const updatedSession = { ...currentSession, user: me.user, device: me.device };
+  await writePlatformSession(updatedSession, options);
+  const released = await releaseForInactiveDevice(updatedSession, options);
+  return {
+    state: "logged-in",
+    user: released.session.user,
+    device: released.session.device,
+    mode: released.mode
+  };
+}
+async function platformCatalog(options = {}) {
+  const session = await readPlatformSession(options);
+  if (!session) {
+    return { state: "logged-out", products: [] };
+  }
+  const [account, products] = await Promise.allSettled([
+    fetchAccountSummary(session),
+    fetchProducts(session)
+  ]);
+  const failures = [account, products].filter((result) => result.status === "rejected");
+  if (failures.some((result) => result.reason.status === 401)) {
+    const { mode: mode2 } = await releaseActivePlatformMode(session, "invalid-token", options);
+    return { state: "invalid-token", mode: mode2, products: [] };
+  }
+  if (failures.length > 0) {
+    return { state: "offline", products: [] };
+  }
+  const catalogProducts = products.value.products;
+  const selectedProductId = catalogProducts.some((product) => product.id === session.selectedProductId) ? session.selectedProductId : void 0;
+  let updatedSession = session;
+  let mode = platformModeFromSession(session);
+  let shouldWriteSession = false;
+  if (session.selectedProductId && !selectedProductId) {
+    const { selectedProductId: _staleSelection, ...sessionWithoutStaleSelection } = session;
+    if (mode.state === "active") {
+      const released = releasePlatformMode(sessionWithoutStaleSelection, "product-missing");
+      updatedSession = released.session;
+      mode = released.mode;
+    } else {
+      updatedSession = clearPlatformMode(sessionWithoutStaleSelection);
+      mode = { state: "inactive" };
+    }
+    shouldWriteSession = true;
+  } else if (mode.state === "active") {
+    const activeProduct = catalogProducts.find((product) => product.id === mode.productId);
+    const releaseReason = !activeProduct ? "product-missing" : activeProduct.status !== "available" ? "product-unavailable" : account.value.credits < activeProduct.minCredits ? "insufficient-credits" : void 0;
+    if (releaseReason) {
+      const released = releasePlatformMode(updatedSession, releaseReason);
+      updatedSession = released.session;
+      mode = released.mode;
+      shouldWriteSession = true;
+    }
+  }
+  if (shouldWriteSession) {
+    await writePlatformSession(updatedSession, options);
+  }
+  return {
+    state: "logged-in",
+    account: { credits: account.value.credits },
+    mode,
+    ...selectedProductId ? { selectedProductId } : {},
+    products: catalogProducts
+  };
+}
+async function selectPlatformProduct(options) {
+  const session = await readPlatformSession(options);
+  if (!session) {
+    return { state: "logged-out" };
+  }
+  const catalog = await platformCatalog(options);
+  if (catalog.state === "invalid-token" || catalog.state === "offline") {
+    return { state: catalog.state };
+  }
+  if (catalog.state === "logged-out") {
+    return { state: "logged-out" };
+  }
+  const currentSession = await readPlatformSession(options);
+  if (!currentSession) {
+    return { state: "logged-out" };
+  }
+  const product = catalog.products.find((candidate) => candidate.id === options.productId);
+  if (!product) {
+    return { state: "product-not-found", productId: options.productId };
+  }
+  if (product.status !== "available") {
+    return { state: "product-unavailable", productId: options.productId };
+  }
+  await writePlatformSession({ ...currentSession, selectedProductId: options.productId }, options);
+  return { state: "selected", selectedProductId: options.productId };
+}
+async function startPlatformMode(options = {}) {
+  const session = await readPlatformSession(options);
+  if (!session) {
+    return { state: "logged-out" };
+  }
+  const catalog = await platformCatalog(options);
+  if (catalog.state === "logged-out" || catalog.state === "offline" || catalog.state === "invalid-token") {
+    return { state: catalog.state };
+  }
+  const currentSession = await readPlatformSession(options);
+  if (!currentSession) {
+    return { state: "logged-out" };
+  }
+  if (!currentSession.selectedProductId) {
+    return { state: "product-not-selected" };
+  }
+  const product = catalog.products.find((candidate) => candidate.id === currentSession.selectedProductId);
+  if (!product) {
+    return { state: "product-not-found", productId: currentSession.selectedProductId };
+  }
+  if (product.status !== "available") {
+    return { state: "product-unavailable", productId: product.id };
+  }
+  if (catalog.account.credits < product.minCredits) {
+    return {
+      state: "insufficient-credits",
+      productId: product.id,
+      requiredCredits: product.minCredits,
+      currentCredits: catalog.account.credits
+    };
+  }
+  let pool;
+  try {
+    pool = await (options.startPoolSession ?? startPoolSession)({
+      session: currentSession,
+      productId: product.id
+    });
+  } catch {
+    return { state: "offline" };
+  }
+  if (pool.state === "failed") {
+    return poolFailureToModeResult(pool.reason, product, catalog.account.credits);
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writePlatformSession({
+    ...clearModeRelease(currentSession),
+    platformMode: "active",
+    activeProductId: product.id,
+    platformModeStartedAt: startedAt,
+    poolSession: sanitizePoolSessionSummary(pool.session),
+    routeToken: {
+      token: pool.routeToken,
+      expiresAt: pool.session.routeTokenExpiresAt
+    }
+  }, options);
+  return { state: "active", productId: product.id, startedAt };
+}
+async function refreshPlatformRoute(options = {}) {
+  const session = await readPlatformSession(options);
+  if (!session || session.device.status !== "active" || session.platformMode !== "active" || !session.activeProductId) {
+    return { state: "not-refreshable" };
+  }
+  let pool;
+  try {
+    pool = await (options.startPoolSession ?? startPoolSession)({
+      session,
+      productId: session.activeProductId
+    });
+  } catch {
+    return { state: "failed", reason: "offline" };
+  }
+  if (pool.state === "failed") {
+    return { state: "failed", reason: poolFailureToModeResult(pool.reason, {
+      id: session.activeProductId,
+      name: session.activeProductId,
+      description: "",
+      status: "available",
+      minCredits: 0,
+      usageLabel: ""
+    }, 0).state };
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writePlatformSession({
+    ...clearModeRelease(session),
+    platformMode: "active",
+    activeProductId: session.activeProductId,
+    platformModeStartedAt: startedAt,
+    poolSession: sanitizePoolSessionSummary(pool.session),
+    routeToken: {
+      token: pool.routeToken,
+      expiresAt: pool.session.routeTokenExpiresAt
+    }
+  }, options);
+  return { state: "active", productId: session.activeProductId, startedAt };
+}
+async function stopPlatformMode(options = {}) {
+  const session = await readPlatformSession(options);
+  if (session) {
+    if (session.poolSession) {
+      try {
+        await (options.stopPoolSession ?? stopPoolSession)({
+          session,
+          poolSessionId: session.poolSession.id,
+          reason: "user-stop"
+        });
+      } catch {
+      }
+    }
+    await writePlatformSession(clearPlatformMode(session), options);
+  }
+  return { state: "inactive" };
+}
+async function sendHeartbeat(options = {}) {
+  const session = await readPlatformSession(options);
+  if (!session) {
+    return { state: "logged-out" };
+  }
+  let heartbeat;
+  try {
+    heartbeat = await (options.postHeartbeat ?? postHeartbeat)({
+      session,
+      payload: options.payload ?? {}
+    });
+  } catch (error) {
+    return statusFromRequestError(error, session, {
+      ...options,
+      releaseActiveModeOnUnauthorized: true
+    });
+  }
+  const currentSession = await readPlatformSession(options);
+  if (!currentSession) {
+    return { state: "logged-out" };
+  }
+  const updatedSession = { ...currentSession, device: heartbeat.device };
+  await writePlatformSession(updatedSession, options);
+  const released = await releaseForInactiveDevice(updatedSession, options);
+  return {
+    state: "logged-in",
+    user: released.session.user,
+    device: released.session.device,
+    mode: released.mode
+  };
+}
+async function logoutPlatform(options = {}) {
+  const session = await readPlatformSession(options);
+  if (session) {
+    try {
+      await (options.postLogout ?? postLogout)({ session });
+    } catch {
+    }
+  }
+  await clearPlatformSession(options);
+  return { state: "logged-out" };
+}
+
+// packages/service/src/runtime.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { randomUUID } from "node:crypto";
+
+// packages/shared/src/runtime.ts
+var DEFAULT_RUNTIME_FILE = "~/.cursor-pool/runtime.json";
+var DEFAULT_DIAGNOSTICS_FILE = "~/.cursor-pool/diagnostics.jsonl";
+
+// packages/service/src/runtime.ts
+function createRuntimeId() {
+  return randomUUID();
+}
+function resolveRuntimeFile(runtimeFile = DEFAULT_RUNTIME_FILE) {
+  if (runtimeFile.startsWith("~/")) {
+    return join2(homedir2(), runtimeFile.slice(2));
+  }
+  return runtimeFile;
+}
+async function writeRuntimeInfo(runtime, options = {}) {
+  const runtimeFile = resolveRuntimeFile(options.runtimeFile);
+  await mkdir2(dirname2(runtimeFile), { recursive: true });
+  await writeFile2(runtimeFile, `${JSON.stringify(runtime, null, 2)}
+`, "utf8");
+}
+async function readRuntimeInfo(options = {}) {
+  const runtimeFile = resolveRuntimeFile(options.runtimeFile);
+  try {
+    return JSON.parse(await readFile2(runtimeFile, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    if (error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// packages/service/src/requestCheck.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var SAFE_MODEL_PATTERN = /^[A-Za-z0-9._:-]{1,96}$/;
+var SECRET_PATTERN = /(api[_-]?key|authorization|bearer|cursor[_-]?auth|provider[_-]?secret|secret|token|sk-[A-Za-z0-9])/i;
+function isValidRequestId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 128;
+}
+function sanitizeSource(value) {
+  return value === "cursor-agent-exec" || value === "manual-check" ? value : "manual-check";
+}
+function sanitizeModel(value) {
+  if (typeof value !== "string" || !SAFE_MODEL_PATTERN.test(value) || SECRET_PATTERN.test(value)) {
+    return "unknown";
+  }
+  return value;
+}
+function sanitizeAgentRequestCheck(input, options) {
+  const requestId = isValidRequestId(input.requestId) ? input.requestId : (options.requestId ?? randomUUID2)();
+  return {
+    requestId,
+    requestType: "agent",
+    source: sanitizeSource(input.source),
+    model: sanitizeModel(input.model),
+    receivedAt: (options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))(),
+    runtimeId: options.runtimeId,
+    decision: options.decision,
+    route: options.route ?? { state: "missing" }
+  };
+}
+function createRequestCheckStore() {
+  let latestCheck = null;
+  return {
+    record(check) {
+      latestCheck = check;
+      return check;
+    },
+    latest() {
+      return latestCheck;
+    }
+  };
+}
+
+// packages/service/src/server.ts
+import { createServer } from "node:http";
+
+// packages/service/src/canary.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+var isValidRequestId2 = (value) => typeof value === "string" && value.length > 0 && value.length <= 128;
+function sanitizeAgentCanary(input, options) {
+  const requestId = isValidRequestId2(input.requestId) ? input.requestId : (options.requestId ?? randomUUID3)();
+  const model = typeof input.model === "string" && input.model.length > 0 ? input.model : "unknown";
+  return {
+    requestId,
+    requestType: "agent",
+    source: "cursor-agent-exec",
+    model,
+    receivedAt: (options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))(),
+    runtimeId: options.runtimeId,
+    gate: options.gate
+  };
+}
+function createCanaryStore() {
+  let latestCanary = null;
+  return {
+    record(canary) {
+      latestCanary = canary;
+      return canary;
+    },
+    latest() {
+      return latestCanary;
+    }
+  };
+}
+
+// packages/service/src/diagnostics.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3, join as join3 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+
+// packages/service/src/requestGateway.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+var SAFE_MODEL_PATTERN2 = /^[A-Za-z0-9._:-]{1,96}$/;
+var SAFE_REQUEST_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
+var SAFE_FORWARD_TOKEN_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
+var SECRET_PATTERN2 = /(api[_-]?key|authorization|bearer|cursor[_-]?auth|provider[_-]?secret|secret|token|sk-[A-Za-z0-9])/i;
+var MAX_RETRY_AFTER_MS = 864e5;
+var MAX_FORWARD_CONTENT_LENGTH = 8e3;
+var FORWARD_REJECT_REASONS = /* @__PURE__ */ new Set([
+  "route-token-invalid",
+  "pool-session-expired",
+  "product-unavailable",
+  "model-banned",
+  "provider-unavailable",
+  "rate-limited",
+  "insufficient-credits",
+  "manual-review-required"
+]);
+function isValidRequestId3(value) {
+  return typeof value === "string" && SAFE_REQUEST_ID_PATTERN.test(value) && !SECRET_PATTERN2.test(value);
+}
+function sanitizeSource2(value) {
+  return value === "cursor-agent-exec" || value === "manual-check" ? value : "unknown";
+}
+function sanitizeModel2(value) {
+  if (typeof value !== "string" || !SAFE_MODEL_PATTERN2.test(value) || SECRET_PATTERN2.test(value)) {
+    return "unknown";
+  }
+  return value;
+}
+function isSafeForwardToken(value) {
+  return typeof value === "string" && SAFE_FORWARD_TOKEN_PATTERN.test(value) && !SECRET_PATTERN2.test(value);
+}
+function isSafeIsoTimestamp(value) {
+  return isSafeForwardToken(value) && !Number.isNaN(Date.parse(value));
+}
+function safeForwardContent(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const content = value.trim();
+  if (!content || SECRET_PATTERN2.test(content)) {
+    return void 0;
+  }
+  return content.slice(0, MAX_FORWARD_CONTENT_LENGTH);
+}
+function evaluateGatewayDecision(gate, route) {
+  if (gate.state === "blocked") {
+    return {
+      ...gate,
+      route: { state: "missing" }
+    };
+  }
+  if (route.state === "ready") {
+    return {
+      state: "accepted",
+      productId: gate.productId,
+      modeStartedAt: gate.modeStartedAt,
+      route
+    };
+  }
+  if (route.state === "expired") {
+    return {
+      state: "route-expired",
+      productId: gate.productId,
+      modeStartedAt: gate.modeStartedAt,
+      route
+    };
+  }
+  return {
+    state: "route-missing",
+    productId: gate.productId,
+    modeStartedAt: gate.modeStartedAt,
+    route
+  };
+}
+function sanitizeAgentGateway(input, options) {
+  const requestId = isValidRequestId3(input.requestId) ? input.requestId : (options.requestId ?? randomUUID4)();
+  return {
+    requestId,
+    requestType: "agent",
+    source: sanitizeSource2(input.source),
+    model: sanitizeModel2(input.model),
+    receivedAt: (options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))(),
+    runtimeId: options.runtimeId,
+    decision: options.decision,
+    forward: { state: "unknown" }
+  };
+}
+function sanitizeGatewayForward(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    return { state: "unknown" };
+  }
+  const forward = input;
+  if (forward.state === "skipped") {
+    return forward.reason === "not-accepted" ? { state: "skipped", reason: "not-accepted" } : { state: "unknown" };
+  }
+  if (forward.state === "forwarded") {
+    if (!isSafeForwardToken(forward.upstreamRequestId) || !isSafeIsoTimestamp(forward.acceptedAt)) {
+      return { state: "unknown" };
+    }
+    const content = safeForwardContent(forward.content);
+    return {
+      state: "forwarded",
+      upstreamRequestId: forward.upstreamRequestId,
+      acceptedAt: forward.acceptedAt,
+      ...content ? { content } : {}
+    };
+  }
+  if (forward.state === "rejected") {
+    if (typeof forward.reason !== "string" || !FORWARD_REJECT_REASONS.has(forward.reason)) {
+      return { state: "unknown" };
+    }
+    const retryAfterMs = forward.retryAfterMs;
+    return {
+      state: "rejected",
+      reason: forward.reason,
+      ...Number.isInteger(retryAfterMs) && retryAfterMs >= 0 && retryAfterMs <= MAX_RETRY_AFTER_MS ? { retryAfterMs } : {}
+    };
+  }
+  if (forward.state === "not-configured" || forward.state === "timeout" || forward.state === "network-error") {
+    return { state: forward.state };
+  }
+  return { state: "unknown" };
+}
+async function resolveGatewayForward(options) {
+  const { safe } = await resolveGatewayForwardResult(options);
+  return safe;
+}
+async function resolveGatewayForwardResult(options) {
+  if (options.gateway.decision.state !== "accepted") {
+    return {
+      result: { state: "not-configured" },
+      safe: { state: "skipped", reason: "not-accepted" }
+    };
+  }
+  if (!options.forwarder) {
+    return {
+      result: { state: "not-configured" },
+      safe: { state: "not-configured" }
+    };
+  }
+  try {
+    const result = await options.forwarder({
+      gateway: options.gateway,
+      routeToken: options.routeToken,
+      poolSessionId: options.poolSessionId,
+      productId: options.productId,
+      model: options.model,
+      requestId: options.requestId,
+      settlementMode: options.settlementMode,
+      ...options.openAiRequest ? { openAiRequest: options.openAiRequest } : {}
+    });
+    return {
+      result,
+      safe: sanitizeGatewayForward(result)
+    };
+  } catch {
+    return {
+      result: { state: "network-error" },
+      safe: { state: "network-error" }
+    };
+  }
+}
+function cleanApiBaseUrl2(apiBaseUrl) {
+  return apiBaseUrl.replace(/\/+$/, "");
+}
+function createGatewayHttpForwarder(options) {
+  return async (request) => {
+    if (!options.apiBaseUrl || !options.deviceToken) {
+      return { state: "not-configured" };
+    }
+    const response = await fetch(`${cleanApiBaseUrl2(options.apiBaseUrl)}/api/client/gateway/agent`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${options.deviceToken}`
+      },
+      body: JSON.stringify({
+        gateway: request.gateway,
+        routeToken: request.routeToken,
+        ...request.poolSessionId ? { poolSessionId: request.poolSessionId } : {},
+        productId: request.productId,
+        model: request.model,
+        requestId: request.requestId,
+        settlementMode: request.settlementMode ?? "provider_forwarded",
+        ...request.openAiRequest ? { openAiRequest: request.openAiRequest } : {}
+      })
+    });
+    if (!response.ok) {
+      return { state: "network-error" };
+    }
+    return await response.json();
+  };
+}
+async function completeGatewayForward(options) {
+  if (!options.apiBaseUrl || !options.deviceToken) {
+    return { state: "not-configured" };
+  }
+  try {
+    const response = await fetch(
+      `${cleanApiBaseUrl2(options.apiBaseUrl)}/api/client/gateway/agent/${encodeURIComponent(options.requestId)}/complete`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${options.deviceToken}`
+        },
+        body: JSON.stringify({
+          routeToken: options.routeToken,
+          poolSessionId: options.poolSessionId,
+          productId: options.productId
+        })
+      }
+    );
+    if (!response.ok) {
+      return { state: "network-error" };
+    }
+    return await response.json();
+  } catch {
+    return { state: "network-error" };
+  }
+}
+function createGatewayStore() {
+  let latestGateway = null;
+  return {
+    record(gateway) {
+      latestGateway = gateway;
+      return gateway;
+    },
+    latest() {
+      return latestGateway;
+    }
+  };
+}
+
+// packages/service/src/diagnostics.ts
+var DEFAULT_MAX_DIAGNOSTICS = 20;
+var BLOCKED_GATE_REASONS = /* @__PURE__ */ new Set([
+  "logged-out",
+  "mode-inactive",
+  "mode-released",
+  "device-inactive",
+  "invalid-session"
+]);
+var RELEASE_REASONS = /* @__PURE__ */ new Set([
+  "product-missing",
+  "product-unavailable",
+  "insufficient-credits",
+  "invalid-token",
+  "device-inactive"
+]);
+function resolveDiagnosticsFile(diagnosticsFile = DEFAULT_DIAGNOSTICS_FILE) {
+  if (diagnosticsFile.startsWith("~/")) {
+    return join3(homedir3(), diagnosticsFile.slice(2));
+  }
+  return diagnosticsFile;
+}
+function sanitizeCanaryForDiagnostics(input) {
+  return {
+    requestId: input.requestId,
+    requestType: "agent",
+    source: "cursor-agent-exec",
+    model: input.model,
+    receivedAt: input.receivedAt,
+    runtimeId: input.runtimeId,
+    gate: sanitizeGateForDiagnostics(input.gate)
+  };
+}
+function sanitizeRequestCheckForDiagnostics(input) {
+  return {
+    kind: "agent-request-check",
+    requestId: input.requestId,
+    requestType: "agent",
+    source: input.source === "cursor-agent-exec" ? "cursor-agent-exec" : "manual-check",
+    model: input.model,
+    receivedAt: input.receivedAt,
+    runtimeId: input.runtimeId,
+    decision: sanitizeGateForDiagnostics(input.decision),
+    route: sanitizeRouteForDiagnostics(input.route)
+  };
+}
+function sanitizeGatewayForDiagnostics(input) {
+  return {
+    kind: "agent-request-gateway",
+    requestId: input.requestId,
+    requestType: "agent",
+    source: input.source,
+    model: input.model,
+    receivedAt: input.receivedAt,
+    runtimeId: input.runtimeId,
+    decision: sanitizeGatewayDecisionForDiagnostics(input.decision),
+    forward: sanitizeGatewayForward(input.forward)
+  };
+}
+function sanitizeGatewayDecisionForDiagnostics(decision) {
+  return sanitizeHistoricalGatewayDecision(decision);
+}
+function sanitizeDiagnosticEntry(input) {
+  if (!isRecord(input)) {
+    return null;
+  }
+  if (input.kind === "agent-request-gateway") {
+    const decision = sanitizeHistoricalGatewayDecision(input.decision);
+    const forward = sanitizeGatewayForward(input.forward);
+    if (typeof input.requestId !== "string" || input.requestType !== "agent" || input.source !== "cursor-agent-exec" && input.source !== "manual-check" && input.source !== "unknown" || typeof input.model !== "string" || typeof input.receivedAt !== "string" || typeof input.runtimeId !== "string") {
+      return null;
+    }
+    return {
+      kind: "agent-request-gateway",
+      requestId: input.requestId,
+      requestType: "agent",
+      source: input.source,
+      model: input.model,
+      receivedAt: input.receivedAt,
+      runtimeId: input.runtimeId,
+      decision,
+      forward
+    };
+  }
+  if (input.kind === "agent-request-check") {
+    const decision = sanitizeHistoricalGate(input.decision);
+    const route = sanitizeHistoricalRoute(input.route);
+    if (typeof input.requestId !== "string" || input.requestType !== "agent" || input.source !== "cursor-agent-exec" && input.source !== "manual-check" || typeof input.model !== "string" || typeof input.receivedAt !== "string" || typeof input.runtimeId !== "string" || decision === null) {
+      return null;
+    }
+    return {
+      kind: "agent-request-check",
+      requestId: input.requestId,
+      requestType: "agent",
+      source: input.source,
+      model: input.model,
+      receivedAt: input.receivedAt,
+      runtimeId: input.runtimeId,
+      decision,
+      route
+    };
+  }
+  const gate = sanitizeHistoricalGate(input.gate);
+  if (typeof input.requestId !== "string" || input.requestType !== "agent" || input.source !== "cursor-agent-exec" || typeof input.model !== "string" || typeof input.receivedAt !== "string" || typeof input.runtimeId !== "string" || gate === null) {
+    return null;
+  }
+  return {
+    requestId: input.requestId,
+    requestType: "agent",
+    source: "cursor-agent-exec",
+    model: input.model,
+    receivedAt: input.receivedAt,
+    runtimeId: input.runtimeId,
+    gate
+  };
+}
+function sanitizeGateForDiagnostics(gate) {
+  if (gate.state === "allowed") {
+    return {
+      state: "allowed",
+      productId: gate.productId,
+      modeStartedAt: gate.modeStartedAt
+    };
+  }
+  return {
+    state: "blocked",
+    reason: gate.reason,
+    ...gate.releaseReason !== void 0 ? { releaseReason: gate.releaseReason } : {},
+    ...gate.releasedAt !== void 0 ? { releasedAt: gate.releasedAt } : {}
+  };
+}
+function sanitizeRouteForDiagnostics(route) {
+  if (route.state === "ready" || route.state === "expired") {
+    return { state: route.state, expiresAt: route.expiresAt };
+  }
+  return { state: "missing" };
+}
+function sanitizeHistoricalRoute(input) {
+  if (!isRecord(input)) {
+    return { state: "missing" };
+  }
+  if ((input.state === "ready" || input.state === "expired") && typeof input.expiresAt === "string") {
+    return { state: input.state, expiresAt: input.expiresAt };
+  }
+  return { state: "missing" };
+}
+function sanitizeHistoricalGate(input) {
+  if (!isRecord(input)) {
+    return null;
+  }
+  if (input.state === "allowed") {
+    if (typeof input.productId !== "string" || typeof input.modeStartedAt !== "string") {
+      return null;
+    }
+    return {
+      state: "allowed",
+      productId: input.productId,
+      modeStartedAt: input.modeStartedAt
+    };
+  }
+  if (input.state === "blocked") {
+    if (typeof input.reason !== "string" || !BLOCKED_GATE_REASONS.has(input.reason)) {
+      return null;
+    }
+    return {
+      state: "blocked",
+      reason: input.reason,
+      ...typeof input.releaseReason === "string" && RELEASE_REASONS.has(input.releaseReason) ? { releaseReason: input.releaseReason } : {},
+      ...typeof input.releasedAt === "string" ? { releasedAt: input.releasedAt } : {}
+    };
+  }
+  return null;
+}
+function sanitizeHistoricalGatewayDecision(input) {
+  if (!isRecord(input)) {
+    return { state: "unknown" };
+  }
+  if (input.state === "accepted") {
+    const route = sanitizeHistoricalRoute(input.route);
+    if (typeof input.productId === "string" && typeof input.modeStartedAt === "string" && route.state === "ready") {
+      return { state: "accepted", productId: input.productId, modeStartedAt: input.modeStartedAt, route };
+    }
+    return { state: "unknown" };
+  }
+  if (input.state === "route-missing") {
+    if (typeof input.productId === "string" && typeof input.modeStartedAt === "string") {
+      return {
+        state: "route-missing",
+        productId: input.productId,
+        modeStartedAt: input.modeStartedAt,
+        route: { state: "missing" }
+      };
+    }
+    return { state: "unknown" };
+  }
+  if (input.state === "route-expired") {
+    const route = sanitizeHistoricalRoute(input.route);
+    if (typeof input.productId === "string" && typeof input.modeStartedAt === "string" && route.state === "expired") {
+      return { state: "route-expired", productId: input.productId, modeStartedAt: input.modeStartedAt, route };
+    }
+    return { state: "unknown" };
+  }
+  if (input.state === "blocked") {
+    const gate = sanitizeHistoricalGate(input);
+    if (gate?.state === "blocked") {
+      return { ...gate, route: { state: "missing" } };
+    }
+    return { state: "unknown" };
+  }
+  return { state: "unknown" };
+}
+function isRecord(input) {
+  return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+async function readDiagnosticEntries(diagnosticsFile) {
+  try {
+    const content = await readFile3(diagnosticsFile, "utf8");
+    return content.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+      try {
+        const entry = sanitizeDiagnosticEntry(JSON.parse(line));
+        return entry === null ? [] : [entry];
+      } catch {
+        return [];
+      }
+    });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function appendAgentCanaryDiagnostic(canary, options = {}) {
+  const diagnosticsFile = resolveDiagnosticsFile(options.diagnosticsFile);
+  const maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_MAX_DIAGNOSTICS);
+  const entries = await readDiagnosticEntries(diagnosticsFile);
+  const nextEntries = [...entries, sanitizeCanaryForDiagnostics(canary)].slice(-maxEntries);
+  const content = `${nextEntries.map((entry) => JSON.stringify(entry)).join("\n")}
+`;
+  await mkdir3(dirname3(diagnosticsFile), { recursive: true });
+  await writeFile3(diagnosticsFile, content, "utf8");
+}
+async function appendAgentRequestCheckDiagnostic(check, options = {}) {
+  const diagnosticsFile = resolveDiagnosticsFile(options.diagnosticsFile);
+  const maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_MAX_DIAGNOSTICS);
+  const entries = await readDiagnosticEntries(diagnosticsFile);
+  const nextEntries = [...entries, sanitizeRequestCheckForDiagnostics(check)].slice(-maxEntries);
+  const content = `${nextEntries.map((entry) => JSON.stringify(entry)).join("\n")}
+`;
+  await mkdir3(dirname3(diagnosticsFile), { recursive: true });
+  await writeFile3(diagnosticsFile, content, "utf8");
+}
+async function appendAgentGatewayDiagnostic(gateway, options = {}) {
+  const diagnosticsFile = resolveDiagnosticsFile(options.diagnosticsFile);
+  const maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_MAX_DIAGNOSTICS);
+  const entries = await readDiagnosticEntries(diagnosticsFile);
+  const nextEntries = [...entries, sanitizeGatewayForDiagnostics(gateway)].slice(-maxEntries);
+  const content = `${nextEntries.map((entry) => JSON.stringify(entry)).join("\n")}
+`;
+  await mkdir3(dirname3(diagnosticsFile), { recursive: true });
+  await writeFile3(diagnosticsFile, content, "utf8");
+}
+
+// packages/service/src/requestGate.ts
+var INVALID_SESSION_GATE = { state: "blocked", reason: "invalid-session" };
+function invalidSessionGate() {
+  return { ...INVALID_SESSION_GATE };
+}
+function hasNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+async function evaluateRequestGate(options = {}) {
+  const snapshot = await readPlatformSessionSnapshot(options);
+  if (snapshot.state === "missing") {
+    return { state: "blocked", reason: "logged-out" };
+  }
+  if (snapshot.state === "invalid") {
+    return invalidSessionGate();
+  }
+  const { session } = snapshot;
+  if (session.device.status !== "active") {
+    return { state: "blocked", reason: "device-inactive" };
+  }
+  if (session.platformMode !== "active" && session.lastModeReleaseReason && session.lastModeReleasedAt) {
+    return {
+      state: "blocked",
+      reason: "mode-released",
+      releaseReason: session.lastModeReleaseReason,
+      releasedAt: session.lastModeReleasedAt
+    };
+  }
+  if (session.platformMode !== "active" || !hasNonEmptyString(session.activeProductId) || !hasNonEmptyString(session.platformModeStartedAt)) {
+    return { state: "blocked", reason: "mode-inactive" };
+  }
+  return {
+    state: "allowed",
+    productId: session.activeProductId,
+    modeStartedAt: session.platformModeStartedAt
+  };
+}
+async function evaluateRouteState(options = {}) {
+  const snapshot = await readPlatformSessionSnapshot(options);
+  if (snapshot.state !== "valid") {
+    return { state: "missing" };
+  }
+  const { routeToken } = snapshot.session;
+  if (!routeToken) {
+    return { state: "missing" };
+  }
+  const expiresAt = Date.parse(routeToken.expiresAt);
+  const now = Date.parse((options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))());
+  if (Number.isNaN(expiresAt) || Number.isNaN(now)) {
+    return { state: "missing" };
+  }
+  if (expiresAt <= now) {
+    return { state: "expired", expiresAt: routeToken.expiresAt };
+  }
+  return { state: "ready", expiresAt: routeToken.expiresAt };
+}
+
+// packages/service/src/takeover.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+var SAFE_TOKEN_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
+var SAFE_MODEL_PATTERN3 = /^[A-Za-z0-9._:-]{1,96}$/;
+var SECRET_PATTERN3 = /(api[_-]?key|authorization|bearer|cookie|cursor[_-]?auth|provider[_-]?secret|secret|token|prompt|messages|sk-[A-Za-z0-9])/i;
+function safeToken(value, fallback) {
+  return typeof value === "string" && SAFE_TOKEN_PATTERN.test(value) && !SECRET_PATTERN3.test(value) ? value : fallback;
+}
+function safeSource(value) {
+  return value === "cursor-always-local" || value === "cursor-agent-exec" ? value : "unknown";
+}
+function safeModel(value) {
+  return typeof value === "string" && SAFE_MODEL_PATTERN3.test(value) && !SECRET_PATTERN3.test(value) ? value : "unknown";
+}
+function buildAgentTakeoverResponse(input, gate, route, forward) {
+  const requestId = safeToken(input.requestId, randomUUID5());
+  if (gate.state === "blocked") {
+    return {
+      state: "rejected",
+      requestId,
+      reason: gate.reason
+    };
+  }
+  if (route.state === "missing") {
+    return { state: "rejected", requestId, reason: "route-missing" };
+  }
+  if (route.state === "expired") {
+    return { state: "rejected", requestId, reason: "route-expired" };
+  }
+  const content = forward?.state === "forwarded" ? forward.content : void 0;
+  return {
+    state: "answered",
+    requestId,
+    source: safeSource(input.source),
+    model: safeModel(input.model),
+    content: content ?? "Cursor Pool provider \u6682\u65F6\u6CA1\u6709\u8FD4\u56DE\u53EF\u663E\u793A\u5185\u5BB9"
+  };
+}
+function createAgentTakeoverStore() {
+  let latestTakeover = null;
+  return {
+    record(takeover) {
+      latestTakeover = takeover;
+      return takeover;
+    },
+    latest() {
+      return latestTakeover;
+    }
+  };
+}
+
+// packages/shared/src/clientConfig.ts
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, join as join4 } from "node:path";
+var DEFAULT_CLIENT_CONFIG_FILE = "~/.cursor-pool/client-config.json";
+function resolveClientConfigFile(configFile = DEFAULT_CLIENT_CONFIG_FILE) {
+  if (configFile.startsWith("~/")) {
+    return join4(homedir4(), configFile.slice(2));
+  }
+  return configFile;
+}
+function normalizeConfig(value) {
+  const record = value;
+  return {
+    ...typeof record?.apiBaseUrl === "string" && record.apiBaseUrl.trim() !== "" ? { apiBaseUrl: record.apiBaseUrl.trim().replace(/\/+$/, "") } : {}
+  };
+}
+async function readClientConfig(options = {}) {
+  try {
+    return normalizeConfig(JSON.parse(await readFile4(resolveClientConfigFile(options.configFile), "utf8")));
+  } catch (error) {
+    if (error.code === "ENOENT" || error instanceof SyntaxError) {
+      return {};
+    }
+    throw error;
+  }
+}
+
+// packages/service/src/server.ts
+var LOOPBACK_HOST = "127.0.0.1";
+var DEFAULT_PORT = 56393;
+var localServices = /* @__PURE__ */ new Map();
+async function resolvePlatformApiBaseUrl(options) {
+  if (options.platformApiBaseUrl) {
+    return options.platformApiBaseUrl;
+  }
+  if (process.env.CURSOR_POOL_API_BASE_URL) {
+    return process.env.CURSOR_POOL_API_BASE_URL;
+  }
+  const config = await readClientConfig({ configFile: options.clientConfigFile });
+  return config.apiBaseUrl;
+}
+function runtimeKey(runtime) {
+  return `${runtime.host}:${runtime.port}:${runtime.runtimeId}`;
+}
+async function readJsonRequest(request) {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  if (chunks.length === 0) {
+    return {};
+  }
+  const body = Buffer.concat(chunks).toString("utf8");
+  if (!body) {
+    return {};
+  }
+  return JSON.parse(body);
+}
+function writeJson(response, statusCode, payload) {
+  const body = JSON.stringify(payload);
+  response.writeHead(statusCode, {
+    "content-type": "application/json",
+    "content-length": Buffer.byteLength(body),
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-headers": "content-type"
+  });
+  response.end(body);
+}
+function writeCorsPreflight(response) {
+  response.writeHead(204, {
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-headers": "content-type",
+    "access-control-max-age": "600"
+  });
+  response.end();
+}
+function writeEventStream(response, events) {
+  const body = `${events.map((event) => `data: ${JSON.stringify(event)}
+
+`).join("")}data: [DONE]
+
+`;
+  response.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache",
+    "connection": "keep-alive",
+    "content-length": Buffer.byteLength(body),
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-headers": "content-type,authorization"
+  });
+  response.end(body);
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function safeOpenAiModel(value) {
+  return typeof value === "string" && /^[A-Za-z0-9._:-]{1,96}$/.test(value) ? value : "unknown";
+}
+function openAiModelsResponse() {
+  return {
+    object: "list",
+    data: [
+      {
+        id: "gpt-test",
+        object: "model",
+        created: 0,
+        owned_by: "cursor-pool",
+        api_types: ["chat_completions"],
+        capabilities: {
+          supports_tool_use: true,
+          supports_streaming: true,
+          output_modalities: ["text"],
+          context_length: 128e3,
+          max_output_tokens: 8192,
+          supports_reasoning: false,
+          supports_vision: false
+        }
+      }
+    ]
+  };
+}
+async function resolveOpenAiGatewayForward(body, runtime, options, retryAfterRefresh = true) {
+  let gate;
+  try {
+    gate = await evaluateRequestGate({ sessionFile: options.platformSessionFile });
+  } catch {
+    gate = { ...INVALID_SESSION_GATE };
+  }
+  const route = gate.state === "allowed" ? await evaluateRouteState({ sessionFile: options.platformSessionFile }) : { state: "missing" };
+  const decision = evaluateGatewayDecision(gate, route);
+  const requestId = typeof body.requestId === "string" ? body.requestId : `openai-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  const model = safeOpenAiModel(body.model);
+  const gateway = sanitizeAgentGateway({
+    requestId,
+    source: "cursor-agent-exec",
+    model
+  }, {
+    runtimeId: runtime.runtimeId,
+    decision
+  });
+  const forwardContext = decision.state === "accepted" ? await readPlatformGatewayForwardContext({ sessionFile: options.platformSessionFile }) : {};
+  const forwarder = options.gatewayForwarder ?? (decision.state === "accepted" ? createGatewayHttpForwarder({
+    apiBaseUrl: forwardContext.apiBaseUrl,
+    deviceToken: forwardContext.deviceToken
+  }) : void 0);
+  const { result, safe } = await resolveGatewayForwardResult({
+    gateway,
+    routeToken: forwardContext.routeToken ?? "",
+    poolSessionId: forwardContext.poolSessionId,
+    productId: decision.state === "accepted" ? decision.productId : "unknown",
+    model,
+    requestId: gateway.requestId,
+    settlementMode: "client_response",
+    openAiRequest: body,
+    forwarder
+  });
+  if (retryAfterRefresh && (decision.state === "route-expired" || safe.state === "skipped" && safe.reason === "not-accepted" || safe.state === "rejected" && safe.reason === "pool-session-expired")) {
+    const refreshed = await refreshPlatformRoute({
+      sessionFile: options.platformSessionFile,
+      startPoolSession: options.platformStartPoolSession
+    });
+    if (refreshed.state === "active") {
+      return resolveOpenAiGatewayForward(body, runtime, options, false);
+    }
+  }
+  return {
+    gateway: {
+      ...gateway,
+      forward: safe
+    },
+    forward: safe,
+    forwardResult: result,
+    completionContext: {
+      apiBaseUrl: forwardContext.apiBaseUrl,
+      deviceToken: forwardContext.deviceToken,
+      routeToken: forwardContext.routeToken,
+      poolSessionId: forwardContext.poolSessionId,
+      productId: decision.state === "accepted" ? decision.productId : void 0,
+      requestId: gateway.requestId
+    },
+    model
+  };
+}
+function openAiChatCompletionResponse(model, content) {
+  const now = Math.floor(Date.now() / 1e3);
+  return {
+    id: `chatcmpl-${now}`,
+    object: "chat.completion",
+    created: now,
+    model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content
+        },
+        finish_reason: "stop"
+      }
+    ],
+    usage: {
+      prompt_tokens: 0,
+      completion_tokens: 0,
+      total_tokens: 0
+    }
+  };
+}
+function openAiChatCompletionStreamEvents(model, content) {
+  const now = Math.floor(Date.now() / 1e3);
+  const id = `chatcmpl-${now}`;
+  return [
+    {
+      id,
+      object: "chat.completion.chunk",
+      created: now,
+      model,
+      choices: [
+        {
+          index: 0,
+          delta: {
+            role: "assistant"
+          },
+          finish_reason: null
+        }
+      ]
+    },
+    {
+      id,
+      object: "chat.completion.chunk",
+      created: now,
+      model,
+      choices: [
+        {
+          index: 0,
+          delta: {
+            content
+          },
+          finish_reason: null
+        }
+      ]
+    },
+    {
+      id,
+      object: "chat.completion.chunk",
+      created: now,
+      model,
+      choices: [
+        {
+          index: 0,
+          delta: {},
+          finish_reason: "stop"
+        }
+      ]
+    }
+  ];
+}
+function openAiBypassResponse() {
+  return {
+    error: {
+      message: "Cursor Pool platform mode is inactive; use the official Cursor path.",
+      type: "cursor_pool_bypass",
+      code: "cursor_pool_bypass"
+    }
+  };
+}
+function openAiFailClosedContent(forward) {
+  if (forward.state === "rejected") {
+    return `Cursor Pool \u53F7\u6C60 provider \u672A\u5C31\u7EEA\uFF1A${forward.reason}`;
+  }
+  if (forward.state === "not-configured") {
+    return "Cursor Pool \u53F7\u6C60 provider \u672A\u914D\u7F6E\uFF0C\u5F53\u524D\u8BF7\u6C42\u5DF2\u88AB\u5E73\u53F0\u63A5\u7BA1\u4F46\u65E0\u6CD5\u8F6C\u53D1\u3002";
+  }
+  if (forward.state === "timeout") {
+    return "Cursor Pool \u53F7\u6C60 provider \u54CD\u5E94\u8D85\u65F6\uFF0C\u5F53\u524D\u8BF7\u6C42\u5DF2\u88AB\u5E73\u53F0\u63A5\u7BA1\u4F46\u6CA1\u6709\u5B8C\u6210\u3002";
+  }
+  if (forward.state === "network-error") {
+    return "Cursor Pool \u53F7\u6C60 provider \u7F51\u7EDC\u4E0D\u53EF\u7528\uFF0C\u5F53\u524D\u8BF7\u6C42\u5DF2\u88AB\u5E73\u53F0\u63A5\u7BA1\u4F46\u65E0\u6CD5\u8F6C\u53D1\u3002";
+  }
+  if (forward.state === "skipped") {
+    return "Cursor Pool \u5E73\u53F0\u6A21\u5F0F\u672A\u5141\u8BB8\u672C\u6B21\u8BF7\u6C42\u3002";
+  }
+  return "Cursor Pool provider \u6682\u65F6\u6CA1\u6709\u8FD4\u56DE\u53EF\u663E\u793A\u5185\u5BB9";
+}
+function isOpenAiObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function forwardedOpenAiResponse(result) {
+  return result.state === "forwarded" && isOpenAiObject(result.openAiResponse) ? result.openAiResponse : void 0;
+}
+function forwardedOpenAiStreamEvents(result) {
+  if (result.state !== "forwarded" || !Array.isArray(result.openAiStreamEvents)) {
+    return void 0;
+  }
+  const events = result.openAiStreamEvents.filter(isOpenAiObject);
+  return events.length > 0 ? events : void 0;
+}
+async function completeForwardAfterClientResponse(context) {
+  if (!context.routeToken || !context.poolSessionId || !context.productId) {
+    return;
+  }
+  await completeGatewayForward({
+    apiBaseUrl: context.apiBaseUrl,
+    deviceToken: context.deviceToken,
+    routeToken: context.routeToken,
+    poolSessionId: context.poolSessionId,
+    productId: context.productId,
+    requestId: context.requestId
+  });
+}
+async function routeRequest(request, response, runtime, options, canaryStore, requestCheckStore, gatewayStore, takeoverStore, stop) {
+  try {
+    if (request.method === "OPTIONS") {
+      writeCorsPreflight(response);
+      return;
+    }
+    if (request.method === "GET" && request.url === "/health") {
+      writeJson(response, 200, buildHealth(runtime));
+      return;
+    }
+    if (request.method === "GET" && request.url === "/models") {
+      writeJson(response, 200, openAiModelsResponse());
+      return;
+    }
+    if (request.method === "POST" && request.url === "/chat/completions") {
+      let clientClosed = false;
+      let responseFinished = false;
+      response.once("finish", () => {
+        responseFinished = true;
+      });
+      response.once("close", () => {
+        if (!responseFinished) {
+          clientClosed = true;
+        }
+      });
+      const clientConnected = () => !clientClosed && !response.destroyed && !response.writableEnded;
+      const body = await readJsonRequest(request);
+      const { gateway, forward, forwardResult, completionContext, model } = await resolveOpenAiGatewayForward(body, runtime, options);
+      const recordedGateway = gatewayStore.record(gateway);
+      try {
+        await appendAgentGatewayDiagnostic(recordedGateway, {
+          diagnosticsFile: options.diagnosticsFile,
+          maxEntries: options.maxDiagnostics
+        });
+      } catch {
+      }
+      if (!clientConnected()) {
+        return;
+      }
+      if (gateway.decision.state !== "accepted") {
+        writeJson(response, 409, openAiBypassResponse());
+        return;
+      }
+      if (forward.state !== "forwarded") {
+        const content = openAiFailClosedContent(forward);
+        if (body.stream === true) {
+          writeEventStream(response, openAiChatCompletionStreamEvents(model, content));
+          return;
+        }
+        writeJson(response, 200, openAiChatCompletionResponse(model, content));
+        return;
+      }
+      if (body.stream === true) {
+        const providerEvents = forwardedOpenAiStreamEvents(forwardResult);
+        if (providerEvents) {
+          writeEventStream(response, providerEvents);
+          await completeForwardAfterClientResponse(completionContext);
+          return;
+        }
+        writeEventStream(
+          response,
+          openAiChatCompletionStreamEvents(
+            model,
+            forward.content ?? "Cursor Pool provider \u6682\u65F6\u6CA1\u6709\u8FD4\u56DE\u53EF\u663E\u793A\u5185\u5BB9"
+          )
+        );
+        await completeForwardAfterClientResponse(completionContext);
+        return;
+      }
+      const providerResponse = forwardedOpenAiResponse(forwardResult);
+      if (providerResponse) {
+        writeJson(response, 200, providerResponse);
+        await completeForwardAfterClientResponse(completionContext);
+        return;
+      }
+      writeJson(
+        response,
+        200,
+        openAiChatCompletionResponse(
+          model,
+          forward.content ?? "Cursor Pool provider \u6682\u65F6\u6CA1\u6709\u8FD4\u56DE\u53EF\u663E\u793A\u5185\u5BB9"
+        )
+      );
+      await completeForwardAfterClientResponse(completionContext);
+      return;
+    }
+    if (request.method === "POST" && request.url === "/cursor-metadata") {
+      const metadata = sanitizeServiceMetadata(await readJsonRequest(request));
+      await options.onMetadata?.(metadata);
+      writeJson(response, 200, { ok: true, metadata });
+      return;
+    }
+    if (request.method === "POST" && request.url === "/agent/canary") {
+      let gate;
+      try {
+        gate = await evaluateRequestGate({ sessionFile: options.platformSessionFile });
+      } catch {
+        gate = { ...INVALID_SESSION_GATE };
+      }
+      const canary = canaryStore.record(
+        sanitizeAgentCanary(await readJsonRequest(request), { runtimeId: runtime.runtimeId, gate })
+      );
+      try {
+        await appendAgentCanaryDiagnostic(canary, {
+          diagnosticsFile: options.diagnosticsFile,
+          maxEntries: options.maxDiagnostics
+        });
+      } catch {
+      }
+      writeJson(response, 200, { ok: true, canary });
+      return;
+    }
+    if (request.method === "GET" && request.url === "/agent/canary/latest") {
+      writeJson(response, 200, { ok: true, canary: canaryStore.latest() });
+      return;
+    }
+    if (request.method === "POST" && request.url === "/agent/request-check") {
+      let decision;
+      try {
+        decision = await evaluateRequestGate({ sessionFile: options.platformSessionFile });
+      } catch {
+        decision = { ...INVALID_SESSION_GATE };
+      }
+      const route = decision.state === "allowed" ? await evaluateRouteState({ sessionFile: options.platformSessionFile }) : { state: "missing" };
+      const check = requestCheckStore.record(
+        sanitizeAgentRequestCheck(await readJsonRequest(request), {
+          runtimeId: runtime.runtimeId,
+          decision,
+          route
+        })
+      );
+      try {
+        await appendAgentRequestCheckDiagnostic(check, {
+          diagnosticsFile: options.diagnosticsFile,
+          maxEntries: options.maxDiagnostics
+        });
+      } catch {
+      }
+      writeJson(response, 200, { ok: decision.state === "allowed", check });
+      return;
+    }
+    if (request.method === "GET" && request.url === "/agent/request-check/latest") {
+      writeJson(response, 200, { ok: true, check: requestCheckStore.latest() });
+      return;
+    }
+    if (request.method === "POST" && request.url === "/agent/request-gateway") {
+      let gate;
+      try {
+        gate = await evaluateRequestGate({ sessionFile: options.platformSessionFile });
+      } catch {
+        gate = { ...INVALID_SESSION_GATE };
+      }
+      const route = gate.state === "allowed" ? await evaluateRouteState({ sessionFile: options.platformSessionFile }) : { state: "missing" };
+      const decision = evaluateGatewayDecision(gate, route);
+      const body = await readJsonRequest(request);
+      const gateway = sanitizeAgentGateway(body, {
+        runtimeId: runtime.runtimeId,
+        decision
+      });
+      const forwardContext = decision.state === "accepted" ? await readPlatformGatewayForwardContext({ sessionFile: options.platformSessionFile }) : {};
+      const forwarder = options.gatewayForwarder ?? (decision.state === "accepted" ? createGatewayHttpForwarder({
+        apiBaseUrl: forwardContext.apiBaseUrl,
+        deviceToken: forwardContext.deviceToken
+      }) : void 0);
+      gateway.forward = await resolveGatewayForward({
+        gateway,
+        routeToken: forwardContext.routeToken ?? "",
+        poolSessionId: forwardContext.poolSessionId,
+        productId: decision.state === "accepted" ? decision.productId : "unknown",
+        model: gateway.model,
+        requestId: gateway.requestId,
+        forwarder
+      });
+      const recordedGateway = gatewayStore.record(gateway);
+      try {
+        await appendAgentGatewayDiagnostic(recordedGateway, {
+          diagnosticsFile: options.diagnosticsFile,
+          maxEntries: options.maxDiagnostics
+        });
+      } catch {
+      }
+      writeJson(response, 200, {
+        ok: decision.state === "accepted" && recordedGateway.forward.state === "forwarded",
+        gateway: recordedGateway
+      });
+      return;
+    }
+    if (request.method === "GET" && request.url === "/agent/request-gateway/latest") {
+      writeJson(response, 200, { ok: true, gateway: gatewayStore.latest() });
+      return;
+    }
+    if (request.method === "POST" && request.url === "/agent/takeover") {
+      const body = await readJsonRequest(request);
+      let gate;
+      try {
+        gate = await evaluateRequestGate({ sessionFile: options.platformSessionFile });
+      } catch {
+        gate = { ...INVALID_SESSION_GATE };
+      }
+      const route = gate.state === "allowed" ? await evaluateRouteState({ sessionFile: options.platformSessionFile }) : { state: "missing" };
+      let forward;
+      if (route.state === "ready") {
+        const decision = evaluateGatewayDecision(gate, route);
+        const gateway = sanitizeAgentGateway(body, {
+          runtimeId: runtime.runtimeId,
+          decision
+        });
+        const forwardContext = await readPlatformGatewayForwardContext({ sessionFile: options.platformSessionFile });
+        const forwarder = options.gatewayForwarder ?? createGatewayHttpForwarder({
+          apiBaseUrl: forwardContext.apiBaseUrl,
+          deviceToken: forwardContext.deviceToken
+        });
+        forward = await resolveGatewayForward({
+          gateway,
+          routeToken: forwardContext.routeToken ?? "",
+          poolSessionId: forwardContext.poolSessionId,
+          productId: decision.state === "accepted" ? decision.productId : "unknown",
+          model: gateway.model,
+          requestId: gateway.requestId,
+          forwarder
+        });
+      }
+      const takeover = takeoverStore.record(
+        buildAgentTakeoverResponse(body, gate, route, forward)
+      );
+      writeJson(response, 200, takeover);
+      return;
+    }
+    if (request.method === "GET" && request.url === "/agent/takeover/latest") {
+      writeJson(response, 200, { ok: true, takeover: takeoverStore.latest() });
+      return;
+    }
+    if (request.method === "POST" && request.url === "/extension/status") {
+      const status = sanitizeExtensionStatus(await readJsonRequest(request));
+      writeJson(response, 200, { ok: true, status });
+      return;
+    }
+    if (request.method === "GET" && request.url === "/platform/status") {
+      writeJson(response, 200, await platformStatus({ sessionFile: options.platformSessionFile }));
+      return;
+    }
+    if (request.method === "GET" && request.url === "/platform/catalog") {
+      writeJson(response, 200, await platformCatalog({ sessionFile: options.platformSessionFile }));
+      return;
+    }
+    if (request.method === "POST" && request.url === "/platform/selection") {
+      const body = await readJsonRequest(request);
+      if (typeof body.productId !== "string" || body.productId.trim() === "") {
+        throw new Error("invalid platform selection request");
+      }
+      const selection = await selectPlatformProduct({
+        sessionFile: options.platformSessionFile,
+        productId: body.productId
+      });
+      writeJson(response, 200, selection);
+      return;
+    }
+    if (request.method === "POST" && request.url === "/platform/login") {
+      const body = await readJsonRequest(request);
+      const apiBaseUrl = await resolvePlatformApiBaseUrl(options);
+      if (typeof body.email === "string" || typeof body.password === "string") {
+        if (typeof body.email !== "string" || typeof body.password !== "string" || typeof apiBaseUrl !== "string" || apiBaseUrl.trim() === "") {
+          throw new Error("invalid platform login request");
+        }
+        let login;
+        try {
+          login = await loginWithPassword({
+            email: body.email,
+            password: body.password,
+            apiBaseUrl,
+            sessionFile: options.platformSessionFile,
+            device: asRecord(body.device),
+            exchangePasswordDeviceToken: options.platformExchangePasswordDeviceToken
+          });
+        } catch (error) {
+          const platformCode = error.platformCode;
+          writeJson(response, 400, {
+            ok: false,
+            error: "platform login failed",
+            ...typeof platformCode === "string" ? { code: platformCode } : {}
+          });
+          return;
+        }
+        writeJson(response, 200, login);
+        return;
+      }
+      if (typeof body.code !== "string" || typeof body.apiBaseUrl !== "string") {
+        throw new Error("invalid platform login request");
+      }
+      writeJson(response, 200, await loginWithCode({
+        code: body.code,
+        apiBaseUrl: body.apiBaseUrl,
+        sessionFile: options.platformSessionFile,
+        device: asRecord(body.device),
+        exchangeDeviceToken: options.platformExchangeDeviceToken
+      }));
+      return;
+    }
+    if (request.method === "POST" && request.url === "/platform/heartbeat") {
+      writeJson(response, 200, await sendHeartbeat({
+        sessionFile: options.platformSessionFile,
+        payload: await readJsonRequest(request),
+        postHeartbeat: options.platformPostHeartbeat
+      }));
+      return;
+    }
+    if (request.method === "POST" && request.url === "/platform/logout") {
+      writeJson(response, 200, await logoutPlatform({
+        sessionFile: options.platformSessionFile,
+        postLogout: options.platformPostLogout
+      }));
+      return;
+    }
+    if (request.method === "POST" && request.url === "/mode/start") {
+      writeJson(response, 200, await startPlatformMode({
+        sessionFile: options.platformSessionFile,
+        startPoolSession: options.platformStartPoolSession
+      }));
+      return;
+    }
+    if (request.method === "POST" && request.url === "/mode/stop") {
+      writeJson(response, 200, await stopPlatformMode({
+        sessionFile: options.platformSessionFile,
+        stopPoolSession: options.platformStopPoolSession
+      }));
+      return;
+    }
+    if (request.method === "POST" && request.url === "/shutdown") {
+      writeJson(response, 200, { ok: true });
+      response.once("finish", () => {
+        void stop();
+      });
+      return;
+    }
+    writeJson(response, 404, { ok: false, error: "not found" });
+  } catch {
+    writeJson(response, 400, { ok: false, error: "invalid request" });
+  }
+}
+function listen(server, port) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, LOOPBACK_HOST);
+  });
+}
+async function closeServer(server) {
+  if (!server.listening) {
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    server.close((error) => error ? reject(error) : resolve());
+  });
+}
+async function startServer(options = {}) {
+  let requestedPort = options.port ?? DEFAULT_PORT;
+  for (; ; ) {
+    const runtime = {
+      host: LOOPBACK_HOST,
+      port: requestedPort,
+      runtimeId: createRuntimeId()
+    };
+    const canaryStore = createCanaryStore();
+    const requestCheckStore = createRequestCheckStore();
+    const gatewayStore = createGatewayStore();
+    const takeoverStore = createAgentTakeoverStore();
+    const server = createServer((request, response) => {
+      void routeRequest(
+        request,
+        response,
+        runtime,
+        options,
+        canaryStore,
+        requestCheckStore,
+        gatewayStore,
+        takeoverStore,
+        stopService
+      );
+    });
+    const stopService = async () => {
+      await closeServer(server);
+      localServices.delete(runtimeKey(runtime));
+    };
+    try {
+      await listen(server, requestedPort);
+      const address = server.address();
+      if (typeof address !== "object" || address === null) {
+        await closeServer(server);
+        throw new Error("service did not bind a TCP address");
+      }
+      runtime.port = address.port;
+      await writeRuntimeInfo(runtime, { runtimeFile: options.runtimeFile });
+      const service = {
+        ...runtime,
+        server,
+        stop: stopService
+      };
+      localServices.set(runtimeKey(runtime), service);
+      return service;
+    } catch (error) {
+      await closeServer(server);
+      if (error.code !== "EADDRINUSE") {
+        throw error;
+      }
+      requestedPort = 0;
+    }
+  }
+}
+
+// packages/extension/src/runtime.ts
+async function readRuntimeInfo2(options = {}) {
+  return readRuntimeInfo({ runtimeFile: options.runtimeFile });
+}
+async function writeRuntimeInfo2(runtime, options = {}) {
+  await writeRuntimeInfo(runtime, { runtimeFile: options.runtimeFile });
+}
+
+// packages/extension/src/api.ts
+var DEFAULT_SERVICE_PORT = 56393;
+var localExtensionServices = /* @__PURE__ */ new Map();
+function buildExtensionDeviceInfo() {
+  return {
+    name: hostname(),
+    os: osPlatform(),
+    arch: arch(),
+    extensionVersion: "0.5.6"
+  };
+}
+function serviceUrl(runtime, path) {
+  return `http://${runtime.host}:${runtime.port}${path}`;
+}
+async function probeRuntime(runtime) {
+  try {
+    const response = await fetch(serviceUrl(runtime, "/health"));
+    const health = await response.json();
+    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 = {}) {
+  const runtime = await readRuntimeInfo2({ runtimeFile: options.runtimeFile });
+  const allowFallback = options.runtimeFile === void 0 || options.fallbackPort !== void 0;
+  if (runtime) {
+    const healthyRuntime = await probeRuntime(runtime);
+    if (healthyRuntime) {
+      return healthyRuntime;
+    }
+  }
+  if (!allowFallback) {
+    return null;
+  }
+  const fallbackRuntime = {
+    host: "127.0.0.1",
+    port: options.fallbackPort ?? DEFAULT_SERVICE_PORT,
+    runtimeId: ""
+  };
+  const healthyFallback = await probeRuntime(fallbackRuntime);
+  if (!healthyFallback) {
+    return null;
+  }
+  await writeRuntimeInfo2(healthyFallback, { runtimeFile: options.runtimeFile });
+  return healthyFallback;
+}
+async function ensureLocalService(runtimeFile, options = {}) {
+  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 = {}) {
+  const runtime = await readRuntimeInfo2({ runtimeFile: options.runtimeFile });
+  const allowFallback = options.runtimeFile === void 0 || options.fallbackPort !== void 0;
+  if (runtime && !allowFallback) {
+    return runtime;
+  }
+  return resolveHealthyRuntime(options);
+}
+function isUserSummary2(value) {
+  const user = value;
+  return typeof user?.id === "string" && typeof user.email === "string";
+}
+function isDeviceSummary2(value) {
+  const device = value;
+  return typeof device?.id === "string" && typeof device.status === "string" && typeof device.lastHeartbeatAt === "string";
+}
+function isProductSummary2(value) {
+  const product = value;
+  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 isPlatformModeReleaseReason2(value) {
+  return value === "product-missing" || value === "product-unavailable" || value === "insufficient-credits" || value === "invalid-token" || value === "device-inactive";
+}
+function normalizePlatformMode(value) {
+  const mode = value;
+  if (mode?.state === "inactive") {
+    return {
+      state: "inactive",
+      ...isPlatformModeReleaseReason2(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) {
+  const mode = normalizePlatformMode(value);
+  if (mode) {
+    return mode;
+  }
+  const result = value;
+  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) {
+  const status = value;
+  if (status?.state === "logged-out") {
+    return true;
+  }
+  if (status?.state === "logged-in") {
+    return isUserSummary2(status.user) && isDeviceSummary2(status.device) && (status.mode === void 0 || normalizePlatformMode(status.mode) !== null);
+  }
+  if (status?.state === "offline" || status?.state === "invalid-token") {
+    return (status.user === void 0 || isUserSummary2(status.user)) && (status.device === void 0 || isDeviceSummary2(status.device)) && (status.mode === void 0 || normalizePlatformMode(status.mode) !== null);
+  }
+  return false;
+}
+function normalizePlatformCatalog(value) {
+  const catalog = value;
+  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) ?? void 0 } : {},
+      ...typeof catalog.selectedProductId === "string" ? { selectedProductId: catalog.selectedProductId } : {},
+      products: catalog.products.filter(isProductSummary2)
+    };
+  }
+  return { state: "offline", products: [] };
+}
+function normalizePlatformSelectionResult(value) {
+  const result = value;
+  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) {
+  if (code === "PASSWORD_LOGIN_INVALID") {
+    return "\u767B\u5F55\u5931\u8D25\uFF1A\u8D26\u53F7\u6216\u5BC6\u7801\u4E0D\u6B63\u786E";
+  }
+  if (code === "PASSWORD_LOGIN_NOT_CONFIGURED") {
+    return "\u767B\u5F55\u5931\u8D25\uFF1A\u8FD9\u4E2A\u8D26\u53F7\u8FD8\u6CA1\u6709\u8BBE\u7F6E\u7F51\u9875\u767B\u5F55\u5BC6\u7801\uFF0C\u8BF7\u5148\u5728\u7528\u6237\u7AEF\u5B8C\u6210\u6CE8\u518C\u6216\u91CD\u7F6E\u5BC6\u7801";
+  }
+  if (code === "DEVICE_LIMIT_REACHED") {
+    return "\u767B\u5F55\u5931\u8D25\uFF1A\u8BBE\u5907\u6570\u91CF\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u8BF7\u5148\u5728\u7528\u6237\u7AEF\u79FB\u9664\u65E7\u8BBE\u5907";
+  }
+  return "\u767B\u5F55\u5931\u8D25\uFF1A\u672C\u5730\u670D\u52A1\u6CA1\u6709\u8FDE\u4E0A\u5E73\u53F0 API\uFF0C\u6216\u8D26\u53F7\u5BC6\u7801\u4E0D\u6B63\u786E";
+}
+async function postJson(options, path, body) {
+  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(() => ({}));
+      throw new Error(platformLoginErrorMessage(errorBody.code));
+    }
+    throw new Error(`\u672C\u5730\u670D\u52A1\u8BF7\u6C42\u5931\u8D25\uFF1A${response.status}`);
+  }
+  return await response.json();
+}
+async function getServiceStatus(runtimeFile, options = {}) {
+  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 };
+  }
+}
+async function getPlatformStatus(runtimeFile, options = {}) {
+  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();
+    return isPlatformStatus(status) ? status : { state: "offline" };
+  } catch {
+    return { state: "offline" };
+  }
+}
+async function getPlatformCatalog(runtimeFile, options = {}) {
+  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: [] };
+  }
+}
+async function startMode(runtimeFile, options = {}) {
+  try {
+    return normalizePlatformModeResult(await postJson({ runtimeFile, ...options }, "/mode/start"));
+  } catch {
+    return { state: "offline" };
+  }
+}
+async function stopMode(runtimeFile, options = {}) {
+  try {
+    return normalizePlatformModeResult(await postJson({ runtimeFile, ...options }, "/mode/stop"));
+  } catch {
+    return { state: "offline" };
+  }
+}
+async function loginPlatform(options) {
+  return postJson(options, "/platform/login", {
+    email: options.email,
+    password: options.password,
+    device: buildExtensionDeviceInfo()
+  });
+}
+async function selectPlatformProduct2(options) {
+  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" };
+  }
+}
+async function logoutPlatform2(runtimeFile, options = {}) {
+  return postJson({ runtimeFile, ...options }, "/platform/logout");
+}
+
+// packages/extension/src/panel.ts
+function createPanelViewModel(status) {
+  const rows = [
+    { label: "patch", value: status.patch },
+    { label: "service", value: status.service },
+    { label: "compat", value: status.compat },
+    { label: "mode", value: status.mode },
+    { label: "platform", value: status.platform ?? "logged-out" }
+  ];
+  if (status.user) {
+    rows.push({ label: "user", value: status.user });
+  }
+  if (status.device) {
+    rows.push({ label: "device", value: status.device });
+  }
+  if (status.heartbeat) {
+    rows.push({ label: "heartbeat", value: status.heartbeat });
+  }
+  if (status.catalog) {
+    rows.push({ label: "catalog", value: status.catalog });
+  }
+  if (status.credits) {
+    rows.push({ label: "credits", value: status.credits });
+  }
+  if (status.selectedProductId) {
+    rows.push({ label: "current product", value: status.selectedProductId });
+  }
+  const platformState = status.platform ?? "logged-out";
+  const takeoverActive = status.mode.startsWith("active ");
+  const platformLoggedIn = platformState === "logged-in" || platformState === "offline" || platformState === "invalid-token";
+  return {
+    title: "Cursor Pool \u53F7\u6C60\u5BA2\u6237\u7AEF",
+    rows,
+    platformControls: {
+      showLogin: platformState === "logged-out" || platformState === "offline",
+      showLogout: platformLoggedIn,
+      showRefresh: true,
+      showEnableTakeover: platformState === "logged-in" && !takeoverActive,
+      showDisableTakeover: platformLoggedIn && takeoverActive
+    },
+    consoleCommand: "cursorPool.openConsole",
+    selectedProductId: status.selectedProductId,
+    products: status.products ?? [],
+    message: status.message,
+    error: status.error
+  };
+}
+function formatPanelMode(mode) {
+  if (mode?.state === "active") {
+    return `active ${mode.productId}`;
+  }
+  if (mode?.state === "inactive" && mode.releaseReason) {
+    return `inactive ${mode.releaseReason}`;
+  }
+  if (mode?.state === "inactive") {
+    return "inactive";
+  }
+  return void 0;
+}
+function formatPanelPlatformStatus(status) {
+  const mode = formatPanelMode(status.mode);
+  return {
+    platform: status.state,
+    user: status.user?.email,
+    device: status.device ? `${status.device.status} ${status.device.id}` : void 0,
+    heartbeat: status.device?.lastHeartbeatAt,
+    ...mode ? { mode } : {}
+  };
+}
+function formatPanelPlatformCatalog(catalog) {
+  const mode = catalog.state === "logged-in" || catalog.state === "offline" || catalog.state === "invalid-token" ? formatPanelMode(catalog.mode) : void 0;
+  return {
+    catalog: catalog.state,
+    credits: catalog.state === "logged-in" ? String(catalog.account.credits) : void 0,
+    selectedProductId: catalog.state === "logged-in" ? catalog.selectedProductId : void 0,
+    products: catalog.state === "logged-in" ? catalog.products : [],
+    ...mode ? { mode } : {}
+  };
+}
+function platformSelectionMessage(result) {
+  if (result.state === "selected") {
+    return { message: "\u5546\u54C1\u5DF2\u5207\u6362" };
+  }
+  if (result.state === "logged-out") {
+    return { error: "\u8BF7\u5148\u767B\u5F55\u5E73\u53F0" };
+  }
+  if (result.state === "invalid-token") {
+    return { error: "\u5E73\u53F0\u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" };
+  }
+  if (result.state === "product-not-found") {
+    return { error: "\u5F53\u524D\u5546\u54C1\u5217\u8868\u4E2D\u6CA1\u6709\u8FD9\u4E2A\u5546\u54C1" };
+  }
+  if (result.state === "product-unavailable") {
+    return { error: "\u5546\u54C1\u5F53\u524D\u4E0D\u53EF\u7528" };
+  }
+  return { error: "\u5E73\u53F0\u670D\u52A1\u6216\u7F51\u9875\u7AEF API \u6682\u65F6\u4E0D\u53EF\u7528" };
+}
+function platformModeMessage(result, action) {
+  if (result.state === "active") {
+    return { message: "\u5DF2\u5F00\u542F\u5E73\u53F0\u63A5\u7BA1" };
+  }
+  if (result.state === "inactive") {
+    return { message: "\u5DF2\u5207\u56DE\u5B98\u65B9\u6A21\u5F0F" };
+  }
+  if (result.state === "logged-out") {
+    return { error: "\u8BF7\u5148\u767B\u5F55\u5E73\u53F0" };
+  }
+  if (result.state === "invalid-token") {
+    return { error: "\u5E73\u53F0\u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" };
+  }
+  if (result.state === "product-not-selected") {
+    return { error: "\u5F00\u542F\u5E73\u53F0\u63A5\u7BA1\u524D\u8BF7\u5148\u9009\u62E9\u5546\u54C1" };
+  }
+  if (result.state === "product-not-found") {
+    return { error: "\u6240\u9009\u5546\u54C1\u4E0D\u5728\u5F53\u524D\u5546\u54C1\u5217\u8868\u4E2D" };
+  }
+  if (result.state === "product-unavailable") {
+    return { error: "\u6240\u9009\u5546\u54C1\u5F53\u524D\u4E0D\u53EF\u7528" };
+  }
+  if (result.state === "insufficient-credits") {
+    return { error: "\u79EF\u5206\u4E0D\u8DB3\uFF0C\u8BF7\u6253\u5F00\u7F51\u9875\u7AEF\u5904\u7406" };
+  }
+  return { error: action === "start" ? "\u5E73\u53F0\u670D\u52A1\u6216\u7F51\u9875\u7AEF API \u6682\u65F6\u4E0D\u53EF\u7528" : "\u5E73\u53F0\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528" };
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function buildPanelHtml(viewModel) {
+  const valueFor = (label, fallback = "-") => viewModel.rows.find((row) => row.label === label)?.value ?? fallback;
+  const statusItems = [
+    { label: "\u672C\u5730\u670D\u52A1", value: valueFor("service") },
+    ...valueFor("user", "") ? [{ label: "\u767B\u5F55\u8D26\u53F7", value: valueFor("user") }] : [],
+    ...valueFor("credits", "") ? [{ label: "\u79EF\u5206\u4F59\u989D", value: valueFor("credits") }] : [],
+    ...valueFor("user", "") ? [{
+      label: "\u5F53\u524D\u6A21\u5F0F",
+      value: valueFor("mode").startsWith("active ") ? "\u5E73\u53F0\u63A5\u7BA1" : "\u5B98\u65B9\u6A21\u5F0F"
+    }] : []
+  ];
+  const rows = statusItems.map((row) => `<li><span>${escapeHtml(row.label)}</span><strong>${escapeHtml(row.value)}</strong></li>`).join("");
+  const currentProductName = viewModel.products.find((product) => product.id === viewModel.selectedProductId)?.name;
+  const currentProduct = currentProductName ? `<li><span>\u5F53\u524D\u4F7F\u7528</span><strong>${escapeHtml(currentProductName)}</strong></li>` : "";
+  const platformControls = [
+    viewModel.platformControls.showLogin ? `<section class="panel-section platform-login">
+          <h2>\u53F7\u6C60\u767B\u5F55</h2>
+          <input name="email" placeholder="\u8D26\u53F7/\u90AE\u7BB1" autocomplete="username">
+          <input name="password" type="password" placeholder="\u5BC6\u7801" autocomplete="current-password">
+          <button type="button" data-command="platform/login">\u767B\u5F55</button>
+        </section>` : "",
+    viewModel.platformControls.showLogout ? '<button type="button" data-command="platform/logout">\u9000\u51FA\u767B\u5F55</button>' : "",
+    viewModel.platformControls.showEnableTakeover ? '<button type="button" data-command="takeover/enable">\u5F00\u542F\u5E73\u53F0\u63A5\u7BA1</button>' : "",
+    viewModel.platformControls.showDisableTakeover ? '<button type="button" data-command="takeover/disable">\u5207\u56DE\u5B98\u65B9\u6A21\u5F0F</button>' : "",
+    viewModel.platformControls.showRefresh ? '<button type="button" data-command="platform/refresh">\u5237\u65B0\u72B6\u6001</button>' : ""
+  ].join("");
+  const message = viewModel.message ? `<p class="message">${escapeHtml(viewModel.message)}</p>` : "";
+  const error = viewModel.error ? `<p class="error">${escapeHtml(viewModel.error)}</p>` : "";
+  const productItems = viewModel.products.map(
+    (product) => {
+      const rowClass = product.id === viewModel.selectedProductId ? "product-row is-selected" : "product-row";
+      return `<li class="${rowClass}" title="${escapeHtml(product.description)}">
+          <div class="product-main">
+            <strong>${escapeHtml(product.name)}</strong>
+            <span class="product-description">${escapeHtml(product.description)}</span>
+          </div>
+          <div class="product-meta">
+            <span>${escapeHtml(product.status)}</span>
+            <span>\u51C6\u5165 ${escapeHtml(String(product.minCredits))}</span>
+            <span>${escapeHtml(product.usageLabel)}</span>
+          </div>
+          <div class="product-action">
+          ${product.id === viewModel.selectedProductId ? '<span class="current-badge">\u5F53\u524D\u4F7F\u7528</span>' : product.status === "available" ? `<button type="button" data-command="platform/select-product" data-product-id="${escapeHtml(product.id)}">\u4F7F\u7528</button>` : ""}
+          </div>
+        </li>`;
+    }
+  ).join("");
+  const products = viewModel.products.length > 0 ? `<section class="panel-section products"><h2>\u53EF\u7528\u5546\u54C1</h2><ul class="product-list">${productItems}</ul></section>` : "";
+  return `<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8">
+    <style>
+      body { font-family: var(--vscode-font-family, sans-serif); padding: 12px; color: var(--vscode-foreground); }
+      h1 { font-size: 15px; margin: 0 0 10px; }
+      h2 { font-size: 12px; margin: 0 0 8px; }
+      ul { list-style: none; margin: 0; padding: 0; }
+      li { margin: 0; }
+      .status-list { display: grid; gap: 6px; }
+      .status-list li { display: flex; justify-content: space-between; gap: 10px; min-width: 0; }
+      .status-list span { color: var(--vscode-descriptionForeground, #777); }
+      .status-list strong { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+      strong { font-weight: 600; }
+      button { border: 1px solid var(--vscode-button-border, transparent); border-radius: 4px; padding: 3px 8px; color: var(--vscode-button-foreground); background: var(--vscode-button-background); }
+      input { box-sizing: border-box; display: block; width: 100%; margin: 6px 0; }
+      .panel-section { border-top: 1px solid var(--vscode-panel-border, #ddd); padding-top: 10px; margin-top: 10px; }
+      .products { margin-top: 10px; }
+      .product-list { max-height: 260px; overflow: auto; border: 1px solid var(--vscode-panel-border, #ddd); border-radius: 6px; }
+      .product-row { display: grid; grid-template-columns: minmax(0, 1fr) auto auto; gap: 8px; align-items: center; padding: 8px; border-top: 1px solid var(--vscode-panel-border, #ddd); }
+      .product-row:first-child { border-top: 0; }
+      .product-row.is-selected { background: var(--vscode-list-activeSelectionBackground, rgba(45, 91, 209, 0.14)); }
+      .product-main { min-width: 0; }
+      .product-main strong, .product-description { display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+      .product-description, .product-meta { color: var(--vscode-descriptionForeground, #777); font-size: 11px; }
+      .product-meta { display: grid; gap: 1px; white-space: nowrap; }
+      .product-action { min-width: 46px; text-align: right; }
+      .current-badge { color: var(--vscode-testing-iconPassed, #17633f); font-size: 12px; font-weight: 600; white-space: nowrap; }
+      .platform-controls { margin-top: 10px; }
+      .platform-controls button { margin-right: 8px; margin-bottom: 8px; }
+      .message { color: var(--vscode-descriptionForeground, #666); }
+      .error { color: var(--vscode-errorForeground, #b00020); }
+    </style>
+  </head>
+  <body>
+    <h1>${escapeHtml(viewModel.title)}</h1>
+    <section class="panel-section"><h2>\u8FD0\u884C\u72B6\u6001</h2><ul class="status-list">${rows}${currentProduct}</ul></section>
+    ${message}
+    ${error}
+    ${products}
+    <div class="platform-controls">${platformControls}</div>
+    <script>
+      const vscode = acquireVsCodeApi();
+      document.addEventListener('click', (event) => {
+        const target = event.target;
+        if (!(target instanceof HTMLElement) || !target.dataset.command) {
+          return;
+        }
+
+        const payload = { command: target.dataset.command };
+        if (target.dataset.command === 'platform/login') {
+          payload.email = document.querySelector('[name="email"]')?.value || '';
+          payload.password = document.querySelector('[name="password"]')?.value || '';
+        }
+        if (target.dataset.productId) {
+          payload.productId = target.dataset.productId;
+        }
+
+        vscode.postMessage(payload);
+      });
+    </script>
+  </body>
+</html>`;
+}
+function registerStatusPanel(context, vscode, options = {}) {
+  const provider = {
+    async resolveWebviewView(view) {
+      const readServiceStatus = options.getServiceStatus ?? getServiceStatus;
+      const ensureService = options.ensureService ?? (async (runtimeFile) => {
+        await ensureLocalService(runtimeFile);
+      });
+      const readPlatformStatus = options.getPlatformStatus ?? getPlatformStatus;
+      const readPlatformCatalog = options.getPlatformCatalog ?? getPlatformCatalog;
+      const doLoginPlatform = options.loginPlatform ?? loginPlatform;
+      const doLogoutPlatform = options.logoutPlatform ?? logoutPlatform2;
+      const doSelectPlatformProduct = options.selectPlatformProduct ?? selectPlatformProduct2;
+      const doStartMode = options.startMode ?? startMode;
+      const doStopMode = options.stopMode ?? stopMode;
+      let serviceEnsured = false;
+      let initialServiceStatus;
+      view.webview.options = {
+        ...view.webview.options,
+        enableScripts: true
+      };
+      const render = async (feedback = {}, serviceStatus) => {
+        const service = options.status ? options.status.service : (serviceStatus ?? await readServiceStatus(options.runtimeFile)).service;
+        const platform = options.status ? {} : formatPanelPlatformStatus(await readPlatformStatus(options.runtimeFile));
+        const catalog = options.status ? {} : formatPanelPlatformCatalog(await readPlatformCatalog(options.runtimeFile));
+        const status = options.status ? { ...options.status, ...feedback } : {
+          patch: "unknown",
+          service,
+          compat: "unknown",
+          mode: "unknown",
+          ...platform,
+          ...catalog,
+          ...feedback
+        };
+        view.webview.html = buildPanelHtml(createPanelViewModel(status));
+      };
+      const renderError = async (error) => {
+        try {
+          const message = error instanceof Error && error.message === "fetch failed" ? "\u672C\u5730\u670D\u52A1\u672A\u8FD0\u884C\uFF0C\u8BF7\u5148\u542F\u52A8 Cursor Pool \u672C\u5730\u670D\u52A1" : error instanceof Error ? error.message : "Cursor Pool service request failed";
+          await render({
+            error: message
+          });
+        } catch {
+        }
+      };
+      const ensureServiceForPanel = async () => {
+        if (serviceEnsured) {
+          return void 0;
+        }
+        const service = await readServiceStatus(options.runtimeFile);
+        if (service.service === "stopped") {
+          await ensureService(options.runtimeFile);
+          serviceEnsured = true;
+          return void 0;
+        }
+        serviceEnsured = true;
+        return service;
+      };
+      if (!options.status) {
+        try {
+          initialServiceStatus = await ensureServiceForPanel();
+        } catch {
+        }
+      }
+      await render({}, initialServiceStatus);
+      view.webview.onDidReceiveMessage?.(async (message) => {
+        try {
+          if (message.command === "mode/start" || message.command === "takeover/enable") {
+            const result = await doStartMode(options.runtimeFile);
+            await render(platformModeMessage(result, "start"));
+            if (result.state === "active") {
+              await vscode.commands?.executeCommand?.("workbench.action.reloadWindow");
+            }
+            return;
+          }
+          if (message.command === "mode/stop" || message.command === "takeover/disable") {
+            const result = await doStopMode(options.runtimeFile);
+            await render(platformModeMessage(result, "stop"));
+            if (result.state === "inactive") {
+              await vscode.commands?.executeCommand?.("workbench.action.reloadWindow");
+            }
+            return;
+          }
+          if (message.command === "platform/login") {
+            if (!message.email) {
+              await render({ error: "\u8BF7\u8F93\u5165\u8D26\u53F7/\u90AE\u7BB1" });
+              return;
+            }
+            if (!message.password) {
+              await render({ error: "\u8BF7\u8F93\u5165\u5BC6\u7801" });
+              return;
+            }
+            await ensureServiceForPanel();
+            try {
+              await doLoginPlatform({
+                runtimeFile: options.runtimeFile,
+                email: message.email,
+                password: message.password
+              });
+            } catch (error) {
+              const current = await readPlatformStatus(options.runtimeFile).catch(() => null);
+              if (current?.state === "logged-in") {
+                await render({ message: "\u5E73\u53F0\u72B6\u6001\u5DF2\u5237\u65B0" });
+                return;
+              }
+              throw error;
+            }
+            await render({ message: "\u5E73\u53F0\u767B\u5F55\u6210\u529F" });
+            return;
+          }
+          if (message.command === "platform/logout") {
+            await doLogoutPlatform(options.runtimeFile);
+            await render({ message: "\u5DF2\u9000\u51FA\u5E73\u53F0\u767B\u5F55" });
+            return;
+          }
+          if (message.command === "platform/select-product") {
+            if (!message.productId) {
+              await render({ error: "\u8BF7\u9009\u62E9\u5546\u54C1" });
+              return;
+            }
+            const result = await doSelectPlatformProduct({
+              runtimeFile: options.runtimeFile,
+              productId: message.productId
+            });
+            await render(platformSelectionMessage(result));
+            return;
+          }
+          if (message.command === "platform/refresh") {
+            await render({ message: "\u5E73\u53F0\u72B6\u6001\u5DF2\u5237\u65B0" });
+            return;
+          }
+          if (message.command === "cursorPool.openConsole") {
+            await vscode.commands?.executeCommand?.("workbench.action.webview.openDeveloperTools");
+          }
+        } catch (error) {
+          await renderError(error);
+        }
+      });
+    }
+  };
+  const subscription = vscode.window?.registerWebviewViewProvider?.("cursorPool.statusPanel", provider);
+  if (subscription) {
+    context.subscriptions?.push(subscription);
+  }
+  return provider;
+}
+
+// packages/extension/src/extension.ts
+async function appendDiagnostic(message) {
+  try {
+    const os = await new Function("specifier", "return import(specifier)")("node:os");
+    const path = await new Function("specifier", "return import(specifier)")("node:path");
+    const fs = await new Function("specifier", "return import(specifier)")("node:fs/promises");
+    const logDir = path.join(os.homedir(), ".cursor-pool/logs");
+    await fs.mkdir(logDir, { recursive: true });
+    await fs.appendFile(
+      path.join(logDir, "extension.log"),
+      `${(/* @__PURE__ */ new Date()).toISOString()} ${message}
+`,
+      "utf8"
+    );
+  } catch {
+  }
+}
+function registerExtensionCommands(context, vscode, options = {}) {
+  void appendDiagnostic("registerExtensionCommands");
+  const openClientSubscription = vscode.commands?.registerCommand?.("cursorPool.openClient", () => {
+    void appendDiagnostic("cursorPool.openClient invoked");
+    try {
+      const result = vscode.commands?.executeCommand?.("workbench.view.extension.cursorPoolClient");
+      void appendDiagnostic("workbench.view.extension.cursorPoolClient dispatched");
+      return result;
+    } catch (error) {
+      void appendDiagnostic(`workbench.view.extension.cursorPoolClient failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  });
+  if (openClientSubscription) {
+    void appendDiagnostic("cursorPool.openClient registered");
+    context.subscriptions?.push(openClientSubscription);
+  } else {
+    void appendDiagnostic("cursorPool.openClient not registered");
+  }
+  const openConsoleSubscription = vscode.commands?.registerCommand?.("cursorPool.openConsole", () => {
+    vscode.window?.showInformationMessage?.("\u8BF7\u5728\u7F51\u9875\u7AEF\u67E5\u770B\u5145\u503C\u3001\u8BB0\u5F55\u3001\u8BBE\u5907\u548C\u8D26\u53F7\u4FE1\u606F\u3002");
+  });
+  if (openConsoleSubscription) {
+    context.subscriptions?.push(openConsoleSubscription);
+  }
+  const reportStatusSubscription = vscode.commands?.registerCommand?.(
+    "cursorPool.reportStatus",
+    async () => {
+      const readStatus = options.getServiceStatus ?? getServiceStatus;
+      const status = await readStatus(options.runtimeFile);
+      vscode.window?.showInformationMessage?.(`Cursor Pool service: ${status.service}`);
+    }
+  );
+  if (reportStatusSubscription) {
+    context.subscriptions?.push(reportStatusSubscription);
+  }
+}
+async function activate(context, injectedVscode, options = {}) {
+  void appendDiagnostic("activate start");
+  try {
+    const vscode = injectedVscode ?? await new Function("specifier", "return import(specifier)")("vscode");
+    registerExtensionCommands(context, vscode, options);
+    registerStatusPanel(context, vscode, options);
+    void appendDiagnostic("activate complete");
+  } catch (error) {
+    void appendDiagnostic(`activate failed: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+}
+function deactivate() {
+}
+export {
+  activate,
+  deactivate,
+  registerExtensionCommands
+};