@cursorpool-dev/cli 0.5.6

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

@@ -0,0 +1,17 @@
+{
+  "name": "@cursor-pool/shared",
+  "version": "0.5.6",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./clientConfig": "./src/clientConfig.ts",
+    "./manifest": "./src/manifest.ts",
+    "./metadata": "./src/metadata.ts",
+    "./paths": "./src/paths.ts",
+    "./runtime": "./src/runtime.ts"
+  },
+  "scripts": {
+    "test": "tsx --test test/*.test.ts"
+  }
+}

package/node_modules/@cursor-pool/shared/src/clientConfig.ts

@@ -0,0 +1,49 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+export const DEFAULT_CLIENT_CONFIG_FILE = '~/.cursor-pool/client-config.json';
+
+export type ClientConfig = {
+  apiBaseUrl?: string;
+};
+
+export type ClientConfigOptions = {
+  configFile?: string;
+};
+
+export function resolveClientConfigFile(configFile = DEFAULT_CLIENT_CONFIG_FILE) {
+  if (configFile.startsWith('~/')) {
+    return join(homedir(), configFile.slice(2));
+  }
+  return configFile;
+}
+
+function normalizeConfig(value: unknown): ClientConfig {
+  const record = value as ClientConfig;
+  return {
+    ...(typeof record?.apiBaseUrl === 'string' && record.apiBaseUrl.trim() !== ''
+      ? { apiBaseUrl: record.apiBaseUrl.trim().replace(/\/+$/, '') }
+      : {}),
+  };
+}
+
+export async function readClientConfig(options: ClientConfigOptions = {}): Promise<ClientConfig> {
+  try {
+    return normalizeConfig(JSON.parse(await readFile(resolveClientConfigFile(options.configFile), 'utf8')));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT' || error instanceof SyntaxError) {
+      return {};
+    }
+    throw error;
+  }
+}
+
+export async function writeClientConfig(
+  config: ClientConfig,
+  options: ClientConfigOptions = {},
+) {
+  const configFile = resolveClientConfigFile(options.configFile);
+  await mkdir(dirname(configFile), { recursive: true });
+  await writeFile(configFile, `${JSON.stringify(normalizeConfig(config), null, 2)}\n`, 'utf8');
+}

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

@@ -0,0 +1,14 @@
+export const workspacePackages = [
+  'packages/shared',
+  'packages/cli',
+  'packages/service',
+  'packages/patcher',
+  'packages/extension',
+] as const;
+export {
+  DEFAULT_CLIENT_CONFIG_FILE,
+  readClientConfig,
+  resolveClientConfigFile,
+  writeClientConfig,
+} from './clientConfig';
+export type { ClientConfig, ClientConfigOptions } from './clientConfig';

package/node_modules/@cursor-pool/shared/src/manifest.ts

@@ -0,0 +1,36 @@
+export type CompatibilityStatus =
+  | 'supported'
+  | 'canary'
+  | 'warning'
+  | 'blocked'
+  | 'unknown';
+
+export interface CompatibilityManifestEntry {
+  platform: string;
+  arch: string;
+  cursorVersion: string;
+  cursorCommit: string;
+  supportStatus: CompatibilityStatus;
+  targetRelativePath: string;
+  expectedSha256: string;
+  structureSignature: string;
+  patchStrategy: string;
+  verifyMarker: string;
+  restoreStrategy: string;
+  minCliVersion: string;
+  minExtensionVersion: string;
+  minServiceVersion: string;
+  requiresWritableAppBundle: boolean;
+  requiresAdHocResign: boolean;
+  userMessage: string;
+}
+
+export type CompatibilityManifestSignatureAlgorithm = 'hmac-sha256-dev';
+
+export interface CompatibilityManifestEnvelope {
+  version: number;
+  signature: string;
+  signatureAlgorithm: CompatibilityManifestSignatureAlgorithm;
+  signatureKeyId: string;
+  rules: CompatibilityManifestEntry[];
+}

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

@@ -0,0 +1,19 @@
+export const SAFE_METADATA_KEYS = [
+  'requestId',
+  'model',
+  'requestType',
+  'source',
+  'cursorVersion',
+  'clientVersion',
+  'entrypoint',
+] as const;
+
+export function sanitizeRequestMetadata(input: Record<string, unknown>) {
+  const output: Record<string, unknown> = {};
+  for (const key of SAFE_METADATA_KEYS) {
+    if (input[key] !== undefined) {
+      output[key] = input[key];
+    }
+  }
+  return output;
+}

package/node_modules/@cursor-pool/shared/src/paths.ts

@@ -0,0 +1,5 @@
+import path from 'node:path';
+
+export function joinCursorAppPath(appPath: string, relativePath: string) {
+  return path.join(appPath, relativePath);
+}

package/node_modules/@cursor-pool/shared/src/runtime.ts

@@ -0,0 +1,3 @@
+export const DEFAULT_RUNTIME_DIR = '~/.cursor-pool';
+export const DEFAULT_RUNTIME_FILE = '~/.cursor-pool/runtime.json';
+export const DEFAULT_DIAGNOSTICS_FILE = '~/.cursor-pool/diagnostics.jsonl';

package/node_modules/@cursor-pool/shared/test/index.test.ts

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '../../..');
+const packageDirs = ['shared', 'cli', 'service', 'patcher', 'extension'];
+
+function readJson(path: string) {
+  return JSON.parse(readFileSync(join(repoRoot, path), 'utf8'));
+}
+
+function assertEntrypointExists(packageDir: string, target: string, label: string) {
+  const normalizedTarget = target.replace(/^\.\//, '');
+  const entrypointPath = join(repoRoot, 'packages', packageDir, normalizedTarget);
+
+  assert.equal(existsSync(entrypointPath), true, `${label} target ${target} exists`);
+}
+
+test('root workspace exposes the minimal MVP-0 package skeleton', () => {
+  const rootPackage = readJson('package.json');
+
+  assert.equal(rootPackage.name, 'cursor-pool-platform');
+  assert.equal(rootPackage.private, true);
+  assert.match(rootPackage.scripts?.test ?? '', /tsx --test/);
+  assert.ok(rootPackage.devDependencies?.tsx);
+  assert.ok(rootPackage.devDependencies?.typescript);
+
+  const workspace = readFileSync(join(repoRoot, 'pnpm-workspace.yaml'), 'utf8');
+  assert.match(workspace, /packages\/\*/);
+
+  for (const packageDir of packageDirs) {
+    const manifestPath = `packages/${packageDir}/package.json`;
+    assert.equal(existsSync(join(repoRoot, manifestPath)), true, `${manifestPath} exists`);
+
+    const manifest = readJson(manifestPath);
+    assert.match(manifest.name, /^@cursor-pool\/[a-z-]+$/);
+    assert.equal(typeof manifest.version, 'string');
+    assert.equal(manifest.type, 'module');
+    assert.ok(manifest.main || manifest.exports, `${manifestPath} exposes an entrypoint`);
+    if (manifest.main) {
+      assertEntrypointExists(packageDir, manifest.main, `${manifestPath} main`);
+    }
+    if (manifest.exports?.['.']) {
+      assertEntrypointExists(packageDir, manifest.exports['.'], `${manifestPath} exports["."]`);
+    }
+    assert.match(manifest.scripts?.test ?? '', /tsx --test/);
+  }
+
+  const sharedEntryPath = 'packages/shared/src/index.ts';
+  assert.equal(existsSync(join(repoRoot, sharedEntryPath)), true, `${sharedEntryPath} exists`);
+
+  const sharedEntry = readFileSync(join(repoRoot, sharedEntryPath), 'utf8');
+  assert.match(sharedEntry, /export\s+(const|function|type|interface|class)\s+\w+/);
+});

package/node_modules/@cursor-pool/shared/test/manifest.test.ts

@@ -0,0 +1,65 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type {
+  CompatibilityManifestEnvelope,
+  CompatibilityManifestEntry,
+  CompatibilityStatus,
+} from '../src/manifest';
+
+test('compatibility manifest entry captures patch compatibility metadata', () => {
+  const supportStatus: CompatibilityStatus = 'supported';
+  const entry: CompatibilityManifestEntry = {
+    platform: 'darwin',
+    arch: 'arm64',
+    cursorVersion: '1.0.0',
+    cursorCommit: 'abc123',
+    supportStatus,
+    targetRelativePath: 'Contents/Resources/app/out/main.js',
+    expectedSha256: 'sha256',
+    structureSignature: 'signature',
+    patchStrategy: 'replace-marker',
+    verifyMarker: 'cursor-pool',
+    restoreStrategy: 'backup',
+    minCliVersion: '0.5.6',
+    minExtensionVersion: '0.5.6',
+    minServiceVersion: '0.5.6',
+    requiresWritableAppBundle: true,
+    requiresAdHocResign: true,
+    userMessage: 'Supported Cursor build.',
+  };
+
+  assert.equal(entry.supportStatus, 'supported');
+  assert.equal(entry.targetRelativePath, 'Contents/Resources/app/out/main.js');
+});
+
+test('compatibility manifest envelope captures signed rule payload', () => {
+  const rule: CompatibilityManifestEntry = {
+    platform: 'darwin',
+    arch: 'arm64',
+    cursorVersion: '1.0.0',
+    cursorCommit: 'abc123',
+    supportStatus: 'supported',
+    targetRelativePath: 'Contents/Resources/app/out/main.js',
+    expectedSha256: 'sha256',
+    structureSignature: 'signature',
+    patchStrategy: 'replace-marker',
+    verifyMarker: 'cursor-pool',
+    restoreStrategy: 'backup',
+    minCliVersion: '0.5.6',
+    minExtensionVersion: '0.5.6',
+    minServiceVersion: '0.5.6',
+    requiresWritableAppBundle: true,
+    requiresAdHocResign: false,
+    userMessage: 'Supported Cursor build.',
+  };
+  const envelope: CompatibilityManifestEnvelope = {
+    version: 7,
+    signature: 'signed',
+    signatureAlgorithm: 'hmac-sha256-dev',
+    signatureKeyId: 'dev-compatibility-key',
+    rules: [rule],
+  };
+
+  assert.equal(envelope.version, 7);
+  assert.equal(envelope.rules[0]?.cursorVersion, '1.0.0');
+});

package/node_modules/@cursor-pool/shared/test/metadata.test.ts

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { sanitizeRequestMetadata } from '../src/metadata';
+
+test('sanitizeRequestMetadata keeps only safe cursor metadata', () => {
+  const result = sanitizeRequestMetadata({
+    requestId: 'req-1',
+    model: 'claude-unknown',
+    requestType: 'agent',
+    source: 'cursor-agent-exec',
+    prompt: 'secret prompt',
+    messages: ['hidden'],
+    cursorAuthToken: 'token',
+    providerSecret: 'secret',
+    apiKey: 'key',
+    authorization: 'bearer secret',
+  });
+
+  assert.deepEqual(result, {
+    requestId: 'req-1',
+    model: 'claude-unknown',
+    requestType: 'agent',
+    source: 'cursor-agent-exec',
+  });
+});

package/node_modules/@cursor-pool/shared/test/runtime.test.ts

@@ -0,0 +1,8 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { DEFAULT_RUNTIME_DIR, DEFAULT_RUNTIME_FILE } from '../src/runtime';
+
+test('runtime constants use the cursor pool runtime path convention', () => {
+  assert.equal(DEFAULT_RUNTIME_DIR, '~/.cursor-pool');
+  assert.equal(DEFAULT_RUNTIME_FILE, '~/.cursor-pool/runtime.json');
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@cursorpool-dev/cli",
+  "version": "0.5.6",
+  "type": "module",
+  "main": "./src/index.ts",
+  "bin": {
+    "cursor-pool": "./bin/cursor-pool.mjs"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "tsx": "^4.22.3",
+    "@cursor-pool/patcher": "0.5.6",
+    "@cursor-pool/service": "0.5.6",
+    "@cursor-pool/shared": "0.5.6",
+    "@cursor-pool/extension": "0.5.6"
+  },
+  "bundledDependencies": [
+    "@cursor-pool/extension",
+    "@cursor-pool/patcher",
+    "@cursor-pool/service",
+    "@cursor-pool/shared"
+  ],
+  "scripts": {
+    "test": "tsx --test test/*.test.ts"
+  }
+}

package/src/adHocResign.ts

@@ -0,0 +1,65 @@
+import { execFile } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export const AD_HOC_RESIGN_ENTITLEMENTS = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>com.apple.security.automation.apple-events</key><true/>
+  <key>com.apple.security.cs.allow-jit</key><true/>
+  <key>com.apple.security.cs.allow-unsigned-executable-memory</key><true/>
+  <key>com.apple.security.cs.disable-library-validation</key><true/>
+  <key>com.apple.security.device.audio-input</key><true/>
+  <key>com.apple.security.device.camera</key><true/>
+</dict>
+</plist>
+`;
+
+export type AdHocResignOptions = {
+  execFile?: typeof execFileAsync;
+};
+
+function errorOutput(error: unknown) {
+  if (error instanceof Error) {
+    const details = [
+      error.message,
+      'stdout' in error && typeof error.stdout === 'string' ? error.stdout : '',
+      'stderr' in error && typeof error.stderr === 'string' ? error.stderr : '',
+    ]
+      .filter(Boolean)
+      .join('\n');
+    return details;
+  }
+  return String(error);
+}
+
+export async function adHocResignApp(appPath: string, options: AdHocResignOptions = {}) {
+  const run = options.execFile ?? execFileAsync;
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-entitlements-'));
+  const entitlementsPath = join(tempDir, 'entitlements.plist');
+
+  try {
+    await writeFile(entitlementsPath, AD_HOC_RESIGN_ENTITLEMENTS, 'utf8');
+    await run('codesign', [
+      '--force',
+      '--deep',
+      '--options',
+      'runtime',
+      '--entitlements',
+      entitlementsPath,
+      '--sign',
+      '-',
+      appPath,
+    ]);
+    await run('codesign', ['--verify', '--deep', '--strict', '--verbose=2', appPath]);
+  } catch (error) {
+    throw new Error(`Ad-hoc resign failed: ${errorOutput(error)}`, { cause: error });
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}

package/src/autostart.ts

@@ -0,0 +1,240 @@
+import { execFile as execFileCallback } from 'node:child_process';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { homedir, userInfo } from 'node:os';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+import { DEFAULT_CLIENT_CONFIG_FILE, resolveClientConfigFile } from '@cursor-pool/shared/clientConfig';
+import { DEFAULT_RUNTIME_FILE } from '@cursor-pool/shared/runtime';
+
+export type AutostartResult = { state: 'installed' | 'removed' | 'skipped'; reason?: string };
+export type ExecFile = (
+  command: string,
+  args: string[],
+) => Promise<{ stdout: string; stderr: string }>;
+
+export type UserAutostartOptions = {
+  platform?: NodeJS.Platform;
+  launchAgentFile?: string;
+  windowsStartupFile?: string;
+  linuxServiceFile?: string;
+  cliCommand?: string;
+  nodeCommand?: string;
+  cliEntry?: string;
+  runtimeFile?: string;
+  serviceLogFile?: string;
+  configFile?: string;
+  tsxLoader?: string;
+  serviceEntry?: string;
+  uid?: number;
+  execFile?: ExecFile;
+};
+
+const execFileAsync = promisify(execFileCallback) as ExecFile;
+const SERVICE_LABEL = 'com.cursor-pool.service';
+const DEFAULT_SERVICE_LOG_FILE = '~/.cursor-pool/logs/service.log';
+
+function resolveTildePath(path: string) {
+  if (path.startsWith('~/')) {
+    return join(homedir(), path.slice(2));
+  }
+  return path;
+}
+
+function defaultCliCommand() {
+  return join(homedir(), '.cursor-pool/client/node_modules/.bin/cursor-pool');
+}
+
+function defaultCliEntry() {
+  return join(homedir(), '.cursor-pool/client/node_modules/@cursorpool-dev/cli/bin/cursor-pool.mjs');
+}
+
+function defaultTsxLoader() {
+  return join(homedir(), '.cursor-pool/client/node_modules/tsx/dist/esm/index.mjs');
+}
+
+function defaultServiceEntry() {
+  return join(
+    homedir(),
+    '.cursor-pool/client/node_modules/@cursorpool-dev/cli/node_modules/@cursor-pool/service/src/entry.ts',
+  );
+}
+
+function defaultLaunchAgentFile() {
+  return join(homedir(), 'Library/LaunchAgents/com.cursor-pool.service.plist');
+}
+
+function defaultWindowsStartupFile() {
+  return join(
+    process.env.APPDATA ?? join(homedir(), 'AppData/Roaming'),
+    'Microsoft/Windows/Start Menu/Programs/Startup/CursorPoolService.cmd',
+  );
+}
+
+function defaultLinuxServiceFile() {
+  return join(homedir(), '.config/systemd/user/cursor-pool.service');
+}
+
+function launchctlDomain(uid = userInfo().uid) {
+  return `gui/${uid}`;
+}
+
+function xmlEscape(value: string) {
+  return value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+}
+
+function launchAgentPlist(options: Required<Pick<UserAutostartOptions,
+  'cliCommand' | 'nodeCommand' | 'cliEntry' | 'runtimeFile' | 'serviceLogFile' | 'configFile' | 'tsxLoader' | 'serviceEntry'
+>>) {
+  const args = serviceArgs(options);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args.map((arg) => `    <string>${xmlEscape(arg)}</string>`).join('\n')}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(resolveTildePath(options.serviceLogFile))}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(resolveTildePath(options.serviceLogFile))}</string>
+</dict>
+</plist>
+`;
+}
+
+function serviceArgs(options: Required<Pick<UserAutostartOptions,
+  'cliCommand' | 'nodeCommand' | 'cliEntry' | 'runtimeFile' | 'serviceLogFile' | 'configFile' | 'tsxLoader' | 'serviceEntry'
+>>) {
+  return [
+    options.nodeCommand,
+    '--import',
+    options.tsxLoader,
+    options.serviceEntry,
+    '--runtime-file',
+    options.runtimeFile,
+    '--service-log-file',
+    options.serviceLogFile,
+    '--config-file',
+    options.configFile,
+  ];
+}
+
+function windowsStartupScript(options: Required<Pick<UserAutostartOptions,
+  'cliCommand' | 'nodeCommand' | 'cliEntry' | 'runtimeFile' | 'serviceLogFile' | 'configFile' | 'tsxLoader' | 'serviceEntry'
+>>) {
+  const command = serviceArgs(options)
+    .map((arg) => `"${arg.replaceAll('"', '""')}"`)
+    .join(' ');
+  return `@echo off\r\nstart "" /min ${command}\r\n`;
+}
+
+function linuxSystemdService(options: Required<Pick<UserAutostartOptions,
+  'cliCommand' | 'nodeCommand' | 'cliEntry' | 'runtimeFile' | 'serviceLogFile' | 'configFile' | 'tsxLoader' | 'serviceEntry'
+>>) {
+  const execStart = serviceArgs(options)
+    .map((arg) => arg.includes(' ') ? `"${arg.replaceAll('"', '\\"')}"` : arg)
+    .join(' ');
+  return `[Unit]
+Description=Cursor Pool local service
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+Restart=always
+RestartSec=3
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+export async function installUserAutostart(
+  options: UserAutostartOptions = {},
+): Promise<AutostartResult> {
+  const platform = options.platform ?? process.platform;
+  const serviceOptions = {
+    cliCommand: options.cliCommand ?? defaultCliCommand(),
+    nodeCommand: options.nodeCommand ?? process.execPath,
+    cliEntry: options.cliEntry ?? defaultCliEntry(),
+    tsxLoader: options.tsxLoader ?? defaultTsxLoader(),
+    serviceEntry: options.serviceEntry ?? defaultServiceEntry(),
+    runtimeFile: options.runtimeFile ?? DEFAULT_RUNTIME_FILE,
+    serviceLogFile: options.serviceLogFile ?? DEFAULT_SERVICE_LOG_FILE,
+    configFile: options.configFile ?? DEFAULT_CLIENT_CONFIG_FILE,
+  };
+
+  if (platform === 'win32') {
+    const startupFile = options.windowsStartupFile ?? defaultWindowsStartupFile();
+    await mkdir(dirname(startupFile), { recursive: true });
+    await writeFile(startupFile, windowsStartupScript(serviceOptions), 'utf8');
+    return { state: 'installed' };
+  }
+
+  if (platform === 'linux') {
+    const serviceFile = options.linuxServiceFile ?? defaultLinuxServiceFile();
+    const execFile = options.execFile ?? execFileAsync;
+    await mkdir(dirname(serviceFile), { recursive: true });
+    await writeFile(serviceFile, linuxSystemdService(serviceOptions), 'utf8');
+    await execFile('systemctl', ['--user', 'daemon-reload']).catch(() => ({ stdout: '', stderr: '' }));
+    await execFile('systemctl', ['--user', 'enable', '--now', 'cursor-pool.service']).catch(() => ({ stdout: '', stderr: '' }));
+    return { state: 'installed' };
+  }
+
+  if (platform !== 'darwin') {
+    return { state: 'skipped', reason: 'unsupported-platform' };
+  }
+
+  const launchAgentFile = options.launchAgentFile ?? defaultLaunchAgentFile();
+  const execFile = options.execFile ?? execFileAsync;
+  const domain = launchctlDomain(options.uid);
+  const plist = launchAgentPlist(serviceOptions);
+
+  await mkdir(dirname(launchAgentFile), { recursive: true });
+  await writeFile(launchAgentFile, plist, 'utf8');
+  await execFile('launchctl', ['bootstrap', domain, launchAgentFile]).catch(() => ({ stdout: '', stderr: '' }));
+  await execFile('launchctl', ['kickstart', '-k', `${domain}/${SERVICE_LABEL}`]);
+  return { state: 'installed' };
+}
+
+export async function removeUserAutostart(
+  options: UserAutostartOptions = {},
+): Promise<AutostartResult> {
+  const platform = options.platform ?? process.platform;
+  if (platform === 'win32') {
+    await rm(options.windowsStartupFile ?? defaultWindowsStartupFile(), { force: true });
+    return { state: 'removed' };
+  }
+  if (platform === 'linux') {
+    const execFile = options.execFile ?? execFileAsync;
+    await execFile('systemctl', ['--user', 'disable', '--now', 'cursor-pool.service']).catch(() => ({ stdout: '', stderr: '' }));
+    await rm(options.linuxServiceFile ?? defaultLinuxServiceFile(), { force: true });
+    await execFile('systemctl', ['--user', 'daemon-reload']).catch(() => ({ stdout: '', stderr: '' }));
+    return { state: 'removed' };
+  }
+  if (platform !== 'darwin') {
+    return { state: 'skipped', reason: 'unsupported-platform' };
+  }
+
+  const launchAgentFile = options.launchAgentFile ?? defaultLaunchAgentFile();
+  const execFile = options.execFile ?? execFileAsync;
+  const domain = launchctlDomain(options.uid);
+  await execFile('launchctl', ['bootout', `${domain}/${SERVICE_LABEL}`]).catch(() => ({ stdout: '', stderr: '' }));
+  await rm(launchAgentFile, { force: true });
+  return { state: 'removed' };
+}
+
+export function resolveAutostartConfigFile(configFile = DEFAULT_CLIENT_CONFIG_FILE) {
+  return resolveClientConfigFile(configFile);
+}