@cursorpool-dev/cli 0.5.6

package/src/extensionLink.ts

@@ -0,0 +1,168 @@
+import { cp, mkdtemp, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { resolveExtensionInstallPath } from './extensionBundle';
+import type { ExtensionState } from './trial';
+
+export const LINKED_EXTENSION_DIRNAME = 'cursor-pool.extension-0.5.6';
+const RUNTIME_EXTENSION_ID = 'cursor-pool.cursorpool';
+const STALE_EXTENSION_IDS = new Set([
+  RUNTIME_EXTENSION_ID,
+  'keg1255.cursorpool',
+  'cursor-pool.@cursor-pool/extension',
+]);
+
+export type LinkedExtensionState = Extract<ExtensionState, 'linked' | 'missing'>;
+
+export type LinkExtensionBundleOptions = {
+  sourceBundlePath: string;
+  cursorExtensionsDir: string;
+};
+
+export type LinkExtensionBundleResult = {
+  state: LinkedExtensionState;
+  linkedPath: string;
+};
+
+export type LinkedExtensionSnapshot = {
+  root: string;
+};
+
+async function exists(path: string) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function readRuntimeManifest(linkedPath: string) {
+  const manifest = JSON.parse(await readFile(join(linkedPath, 'package.json'), 'utf8')) as {
+    publisher?: unknown;
+    name?: unknown;
+    version?: unknown;
+  };
+  const publisher = typeof manifest.publisher === 'string' ? manifest.publisher : 'cursor-pool';
+  const name = typeof manifest.name === 'string' ? manifest.name : 'cursorpool';
+  const version = typeof manifest.version === 'string' ? manifest.version : '0.5.6';
+  return { id: `${publisher}.${name}`, version };
+}
+
+export async function refreshCursorExtensionsIndex(cursorExtensionsDir: string, linkedPath: string) {
+  const indexPath = join(resolveExtensionInstallPath(cursorExtensionsDir), 'extensions.json');
+  if (!(await exists(indexPath))) {
+    return;
+  }
+
+  const entries = JSON.parse(await readFile(indexPath, 'utf8')) as Array<{
+    identifier?: { id?: string };
+    relativeLocation?: string;
+  }>;
+  const manifest = await readRuntimeManifest(linkedPath);
+  const nextEntries = entries.filter((entry) => {
+    const id = entry.identifier?.id;
+    return (
+      !STALE_EXTENSION_IDS.has(id ?? '') &&
+      entry.relativeLocation !== LINKED_EXTENSION_DIRNAME &&
+      entry.relativeLocation !== 'keg1255.cursorpool-1.0.52'
+    );
+  });
+
+  nextEntries.push({
+    identifier: { id: manifest.id },
+    location: {
+      $mid: 1,
+      path: linkedPath,
+      scheme: 'file',
+    },
+    relativeLocation: LINKED_EXTENSION_DIRNAME,
+    version: manifest.version,
+  });
+  await writeFile(indexPath, `${JSON.stringify(nextEntries, null, 2)}\n`, 'utf8');
+}
+
+function assertSafeLinkedExtensionPath(linkedPath: string) {
+  const resolvedLinkedPath = resolve(linkedPath);
+  const parentSegments = dirname(resolvedLinkedPath).split(/[\\/]+/).filter(Boolean);
+  const hasExtensionsParent = parentSegments.some(
+    (segment) => segment === 'extensions' || segment === 'Extensions',
+  );
+
+  if (basename(resolvedLinkedPath) !== LINKED_EXTENSION_DIRNAME || !hasExtensionsParent) {
+    throw new Error(
+      `Unsafe linked extension path for recursive removal: ${linkedPath}. Expected an extensions/${LINKED_EXTENSION_DIRNAME} bundle path.`,
+    );
+  }
+}
+
+export function linkedExtensionPathForDir(cursorExtensionsDir: string) {
+  return join(resolveExtensionInstallPath(cursorExtensionsDir), LINKED_EXTENSION_DIRNAME);
+}
+
+export async function getLinkedExtensionState(linkedPath: string | undefined): Promise<LinkedExtensionState> {
+  if (!linkedPath) {
+    return 'missing';
+  }
+
+  const resolvedLinkedPath = resolveExtensionInstallPath(linkedPath);
+  const manifestPath = join(resolvedLinkedPath, 'package.json');
+  const entryPath = join(resolvedLinkedPath, 'dist/extension.js');
+  return (await exists(manifestPath)) && (await exists(entryPath)) ? 'linked' : 'missing';
+}
+
+export async function linkExtensionBundle({
+  sourceBundlePath,
+  cursorExtensionsDir,
+}: LinkExtensionBundleOptions): Promise<LinkExtensionBundleResult> {
+  const resolvedSourceBundlePath = resolveExtensionInstallPath(sourceBundlePath);
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+
+  if ((await getLinkedExtensionState(resolvedSourceBundlePath)) === 'missing') {
+    return { state: 'missing', linkedPath };
+  }
+
+  await removeLinkedExtensionBundle(linkedPath);
+  await mkdir(dirname(linkedPath), { recursive: true });
+  await cp(resolvedSourceBundlePath, linkedPath, { recursive: true });
+  await refreshCursorExtensionsIndex(cursorExtensionsDir, linkedPath);
+
+  return { state: 'linked', linkedPath };
+}
+
+export async function removeLinkedExtensionBundle(linkedPath: string) {
+  const resolvedLinkedPath = resolveExtensionInstallPath(linkedPath);
+  assertSafeLinkedExtensionPath(resolvedLinkedPath);
+  await rm(resolvedLinkedPath, { recursive: true, force: true });
+}
+
+export async function snapshotLinkedExtensionBundle(
+  linkedPath: string,
+): Promise<LinkedExtensionSnapshot | null> {
+  const resolvedLinkedPath = resolveExtensionInstallPath(linkedPath);
+
+  if (!(await exists(resolvedLinkedPath))) {
+    return null;
+  }
+
+  const snapshotRoot = await mkdtemp(join(tmpdir(), 'cursor-pool-linked-extension-snapshot-'));
+  await cp(resolvedLinkedPath, snapshotRoot, { recursive: true });
+  return { root: snapshotRoot };
+}
+
+export async function restoreLinkedExtensionSnapshot(
+  linkedPath: string,
+  snapshot: LinkedExtensionSnapshot | null | undefined,
+) {
+  if (!snapshot) {
+    return;
+  }
+
+  const resolvedLinkedPath = resolveExtensionInstallPath(linkedPath);
+  await removeLinkedExtensionBundle(resolvedLinkedPath);
+  await mkdir(dirname(resolvedLinkedPath), { recursive: true });
+  await cp(snapshot.root, resolvedLinkedPath, { recursive: true });
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+export const packageRole = 'cli';
+export { detectEnvironment } from './environment';
+export { findCursor } from './cursor';
+export { resolveCompatEntry } from './compat';
+export { install } from './install';
+export { repair } from './repair';
+export { status } from './status';
+export { restore } from './restore';
+export { uninstall } from './uninstall';
+export { clearDiagnostics, diagnostics } from './diagnostics';
+export { launchCommand, launchStatus } from './launch';
+export { confirmRealOperation, formatRealOperationSummary } from './confirm';
+export { resolveCursorTarget } from './target';
+export {
+  DEFAULT_INSTALL_RECORD_FILE,
+  deleteInstallRecord,
+  installIdForAppPath,
+  installRecordPath,
+  isInstallRecordStale,
+  readInstallRecord,
+  writeInstallRecord,
+} from './installRecord';
+export type { InstallMode, InstallRecord, InstallRecordOptions } from './installRecord';