@cursorpool-dev/cli 0.5.6

package/bin/cursor-pool.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import 'tsx/esm';
+
+const { main } = await import('./cursor-pool.ts');
+
+main().catch((error) => {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+});

package/bin/cursor-pool.ts

@@ -0,0 +1,169 @@
+#!/usr/bin/env tsx
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { resolve } from 'node:path';
+import { install } from '../src/install';
+import { repair } from '../src/repair';
+import { restore } from '../src/restore';
+import { status } from '../src/status';
+import { uninstall } from '../src/uninstall';
+import { clearDiagnostics, diagnostics } from '../src/diagnostics';
+import { launchCommand, launchStatus } from '../src/launch';
+import { heartbeat, login, logout, whoami } from '../src/platform';
+import { startLocalServiceCommand, stopLocalServiceCommand } from '../src/serviceCommands';
+
+function isDirectExecution() {
+  const scriptPath = process.argv[1];
+  if (!scriptPath) {
+    return false;
+  }
+
+  try {
+    return (
+      realpathSync(fileURLToPath(import.meta.url)) ===
+      realpathSync(resolve(scriptPath))
+    );
+  } catch {
+    return resolve(fileURLToPath(import.meta.url)) === resolve(scriptPath);
+  }
+}
+
+function valueForArg(args: string[], name: string) {
+  const index = args.indexOf(name);
+  if (index === -1) {
+    return { provided: false, value: undefined, missing: false };
+  }
+  const value = args[index + 1];
+  if (!value || value.startsWith('--')) {
+    return { provided: true, value: undefined, missing: true };
+  }
+  return { provided: true, value, missing: false };
+}
+
+function missingReasonForOption(name: string) {
+  return `${name.slice(2).replaceAll('-', '_')}_missing_value`;
+}
+
+function readOption(args: string[], name: string) {
+  const result = valueForArg(args, name);
+  if (result.missing) {
+    throw new Error(missingReasonForOption(name));
+  }
+  return result.value;
+}
+
+function hasFlag(args: string[], name: string) {
+  return args.includes(name);
+}
+
+function readPositiveIntegerOption(args: string[], name: string) {
+  const value = readOption(args, name);
+  if (value === undefined) {
+    return undefined;
+  }
+
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+
+  return parsed;
+}
+
+export function parseCommonOptions(args: string[]) {
+  return {
+    appPath: readOption(args, '--app-path'),
+    realAppPath: readOption(args, '--real-app-path'),
+    runtimeFile: readOption(args, '--runtime-file'),
+    backupDir: readOption(args, '--backup-dir'),
+    installRecordFile: readOption(args, '--install-record-file'),
+    trialRecordDir: readOption(args, '--trial-record-dir'),
+    extensionInstallPath: readOption(args, '--extension-install-path'),
+    cursorExtensionsDir: readOption(args, '--cursor-extensions-dir'),
+    userDataDir: readOption(args, '--user-data-dir'),
+    serviceLogFile: readOption(args, '--service-log-file'),
+    configFile: readOption(args, '--config-file'),
+    diagnosticsFile: readOption(args, '--diagnostics-file'),
+    sessionFile: readOption(args, '--session-file'),
+    code: readOption(args, '--code'),
+    apiBaseUrl: readOption(args, '--api-base-url'),
+    compatManifestUrl: readOption(args, '--compat-manifest-url'),
+    yes: hasFlag(args, '--yes'),
+  };
+}
+
+function parseDiagnosticsOptions(
+  args: string[],
+  commonOptions: ReturnType<typeof parseCommonOptions>,
+) {
+  return {
+    diagnosticsFile: commonOptions.diagnosticsFile,
+    limit: readPositiveIntegerOption(args, '--limit'),
+    json: hasFlag(args, '--json'),
+  };
+}
+
+export async function main() {
+  const [command = 'status', ...args] = process.argv.slice(2);
+  const commonOptions = parseCommonOptions(args);
+
+  const handlers: Record<string, () => Promise<string>> = {
+    install: () => install(commonOptions),
+    repair: () => repair(commonOptions),
+    start: () => startLocalServiceCommand(commonOptions),
+    stop: () => stopLocalServiceCommand(commonOptions),
+    status: () => status(commonOptions),
+    restore: () => restore(commonOptions),
+    uninstall: () => uninstall(commonOptions),
+    diagnostics: () => diagnostics(parseDiagnosticsOptions(args, commonOptions)),
+    'clear-diagnostics': () =>
+      clearDiagnostics({ diagnosticsFile: commonOptions.diagnosticsFile }),
+    'launch-command': () =>
+      launchCommand({
+        appPath: commonOptions.appPath,
+        userDataDir: commonOptions.userDataDir,
+        cursorExtensionsDir: commonOptions.cursorExtensionsDir,
+      }),
+    'launch-status': () =>
+      launchStatus({
+        appPath: commonOptions.appPath,
+        userDataDir: commonOptions.userDataDir,
+        cursorExtensionsDir: commonOptions.cursorExtensionsDir,
+      }),
+    login: () =>
+      login({
+        runtimeFile: commonOptions.runtimeFile,
+        sessionFile: commonOptions.sessionFile,
+        code: commonOptions.code,
+        apiBaseUrl: commonOptions.apiBaseUrl,
+      }),
+    whoami: () =>
+      whoami({
+        runtimeFile: commonOptions.runtimeFile,
+        sessionFile: commonOptions.sessionFile,
+      }),
+    heartbeat: () =>
+      heartbeat({
+        runtimeFile: commonOptions.runtimeFile,
+        sessionFile: commonOptions.sessionFile,
+      }),
+    logout: () =>
+      logout({
+        runtimeFile: commonOptions.runtimeFile,
+        sessionFile: commonOptions.sessionFile,
+      }),
+  };
+  const handler = handlers[command];
+  if (!handler) {
+    throw new Error(`Unknown command: ${command}`);
+  }
+
+  process.stdout.write(`${await handler()}\n`);
+}
+
+if (isDirectExecution()) {
+  main().catch((error) => {
+    process.stderr.write(`${(error as Error).message}\n`);
+    process.exitCode = 1;
+  });
+}