@cursorpool-dev/cli 0.5.6

package/node_modules/@cursor-pool/service/src/entry.ts

@@ -0,0 +1,161 @@
+#!/usr/bin/env tsx
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { readRuntimeInfo, resolveRuntimeFile, type RuntimeInfo } from './runtime';
+import { startServer } from './server';
+
+function readOption(args: string[], name: string) {
+  const index = args.indexOf(name);
+  return index === -1 ? undefined : args[index + 1];
+}
+
+const runtimeFile = readOption(process.argv.slice(2), '--runtime-file');
+const clientConfigFile = readOption(process.argv.slice(2), '--config-file');
+let activeService: Awaited<ReturnType<typeof startServer>> | undefined;
+let releaseStartLock: (() => Promise<void>) | undefined;
+const keepAlive = setInterval(() => {}, 2 ** 30);
+
+function delay(ms: number) {
+  return new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
+
+async function fetchRuntimeHealth(runtime: RuntimeInfo | null) {
+  if (!runtime) {
+    return false;
+  }
+
+  try {
+    const response = await fetch(`http://${runtime.host}:${runtime.port}/health`);
+    const health = (await response.json()) as { ok?: unknown; runtimeId?: unknown };
+    return response.ok && health.ok === true && health.runtimeId === runtime.runtimeId;
+  } catch {
+    return false;
+  }
+}
+
+async function readLockPid(lockDir: string) {
+  try {
+    const pid = Number(await readFile(`${lockDir}/owner.json`, 'utf8').then((content) => JSON.parse(content).pid));
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function isProcessAlive(pid: number) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForHealthyRuntime(resolvedRuntimeFile: string, timeoutMs = 5000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const runtime = await readRuntimeInfo({ runtimeFile: resolvedRuntimeFile });
+    if (await fetchRuntimeHealth(runtime)) {
+      return runtime;
+    }
+    await delay(50);
+  }
+  return null;
+}
+
+async function acquireStartLock(resolvedRuntimeFile: string) {
+  const lockDir = `${resolvedRuntimeFile}.start.lock`;
+  const startedAt = Date.now();
+
+  for (;;) {
+    const existingRuntime = await readRuntimeInfo({ runtimeFile: resolvedRuntimeFile });
+    if (await fetchRuntimeHealth(existingRuntime)) {
+      return { release: null, runtime: existingRuntime };
+    }
+
+    try {
+      await mkdir(lockDir, { recursive: false });
+      await writeFile(
+        `${lockDir}/owner.json`,
+        `${JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() })}\n`,
+        'utf8',
+      );
+      return {
+        release: async () => {
+          await rm(lockDir, { recursive: true, force: true });
+        },
+        runtime: null,
+      };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
+        throw error;
+      }
+
+      const ownerPid = await readLockPid(lockDir);
+      if (ownerPid !== null && !isProcessAlive(ownerPid)) {
+        await rm(lockDir, { recursive: true, force: true });
+        continue;
+      }
+
+      const runtime = await waitForHealthyRuntime(resolvedRuntimeFile, 250);
+      if (runtime) {
+        return { release: null, runtime };
+      }
+
+      if (Date.now() - startedAt > 5000) {
+        throw new Error(`another Cursor Pool service is still starting for ${resolvedRuntimeFile}`);
+      }
+    }
+  }
+}
+
+function writeRuntime(runtime: RuntimeInfo) {
+  process.stdout.write(`${JSON.stringify(runtime)}\n`);
+}
+
+async function main() {
+  const resolvedRuntimeFile = resolveRuntimeFile(runtimeFile);
+  await mkdir(dirname(resolvedRuntimeFile), { recursive: true });
+
+  const lock = await acquireStartLock(resolvedRuntimeFile);
+  if (lock.runtime) {
+    writeRuntime(lock.runtime);
+    clearInterval(keepAlive);
+    return;
+  }
+
+  releaseStartLock = lock.release ?? undefined;
+  try {
+    const service = await startServer({
+      runtimeFile: resolvedRuntimeFile,
+      clientConfigFile,
+      onShutdown() {
+        clearInterval(keepAlive);
+        process.exit(0);
+      },
+    });
+    activeService = service;
+    writeRuntime({
+      host: service.host,
+      port: service.port,
+      runtimeId: service.runtimeId,
+    });
+  } finally {
+    await releaseStartLock?.();
+    releaseStartLock = undefined;
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(`${(error as Error).message}\n`);
+  clearInterval(keepAlive);
+  process.exitCode = 1;
+});
+
+process.once('SIGTERM', () => {
+  void activeService?.stop().finally(async () => {
+    await releaseStartLock?.();
+    clearInterval(keepAlive);
+    process.exit(0);
+  });
+});

package/node_modules/@cursor-pool/service/src/health.ts

@@ -0,0 +1,10 @@
+import type { RuntimeInfo } from './runtime';
+
+export function buildHealth(runtime: RuntimeInfo) {
+  return {
+    ok: true,
+    host: runtime.host,
+    port: runtime.port,
+    runtimeId: runtime.runtimeId,
+  };
+}

package/node_modules/@cursor-pool/service/src/index.ts

@@ -0,0 +1,29 @@
+export const packageRole = 'service';
+export { buildHealth } from './health';
+export { sanitizeExtensionStatus, sanitizeServiceMetadata } from './metadata';
+export {
+  DEFAULT_PLATFORM_SESSION_FILE,
+  loginWithPassword,
+  loginWithCode,
+  logoutPlatform,
+  platformStatus,
+  resolvePlatformSessionFile,
+  sendHeartbeat,
+} from './platformSession';
+export type {
+  HeartbeatPayload,
+  LoginWithPasswordOptions,
+  LoginWithCodeOptions,
+  LogoutPlatformOptions,
+  PlatformDeviceInput,
+  PlatformDeviceSummary,
+  PlatformSession,
+  PlatformSessionOptions,
+  PlatformStatus,
+  PlatformUserSummary,
+  SendHeartbeatOptions,
+} from './platformSession';
+export { readRuntimeInfo, resolveRuntimeFile, writeRuntimeInfo } from './runtime';
+export { createRequestCheckStore, sanitizeAgentRequestCheck } from './requestCheck';
+export type { AgentRequestCheck, AgentRequestCheckInput } from './requestCheck';
+export { startServer } from './server';

package/node_modules/@cursor-pool/service/src/metadata.ts

@@ -0,0 +1,22 @@
+import { sanitizeRequestMetadata } from '@cursor-pool/shared/metadata';
+
+const EXTENSION_STATUS_KEYS = ['connected', 'cursorVersion', 'clientVersion'] as const;
+
+export type ServiceMetadata = Record<string, unknown>;
+
+export function sanitizeServiceMetadata(input: Record<string, unknown>): ServiceMetadata {
+  return {
+    model: 'unknown',
+    ...sanitizeRequestMetadata(input),
+  };
+}
+
+export function sanitizeExtensionStatus(input: Record<string, unknown>): Record<string, unknown> {
+  const output: Record<string, unknown> = {};
+  for (const key of EXTENSION_STATUS_KEYS) {
+    if (input[key] !== undefined) {
+      output[key] = input[key];
+    }
+  }
+  return output;
+}