@cursorpool-dev/cli 0.5.6

package/test/extensionBundle.test.ts

@@ -0,0 +1,161 @@
+import assert from 'node:assert/strict';
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+import {
+  bundleExtension,
+  getExtensionState,
+  removeExtensionBundle,
+  resolveExtensionInstallPath,
+} from '../src/extensionBundle';
+
+const cliRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+test('bundleExtension copies package manifest and dist extension entry', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-bundle-'));
+  const sourceDir = join(tempDir, 'source');
+  const installPath = join(tempDir, 'installed/extensions/cursor-pool-status');
+  await mkdir(join(sourceDir, 'dist'), { recursive: true });
+  await mkdir(join(sourceDir, 'resources'), { recursive: true });
+  await writeFile(
+    join(sourceDir, 'package.json'),
+    JSON.stringify({
+      name: '@cursor-pool/extension',
+      type: 'module',
+      main: './dist/extension.js',
+      contributes: {
+        viewsContainers: {
+          activitybar: [{ id: 'cursorPoolClient', title: 'Cursor Pool 平台模式', icon: 'resources/cursor-pool.svg' }],
+        },
+      },
+    }),
+    'utf8',
+  );
+  await writeFile(join(sourceDir, 'dist/extension.js'), 'export function activate() {}\n', 'utf8');
+  await writeFile(join(sourceDir, 'resources/cursor-pool.svg'), '<svg />\n', 'utf8');
+
+  try {
+    const result = await bundleExtension({ sourceDir, installPath });
+    assert.deepEqual(result, { state: 'bundled', installPath });
+    const manifest = JSON.parse(await readFile(join(installPath, 'package.json'), 'utf8'));
+    assert.equal(manifest.name, 'cursorpool');
+    assert.equal(manifest.publisher, 'cursor-pool');
+    assert.equal(manifest.displayName, 'Cursor Pool 平台模式');
+    assert.equal(manifest.type, 'module');
+    assert.equal(manifest.dependencies, undefined);
+    assert.equal(manifest.exports, undefined);
+    assert.equal(manifest.scripts, undefined);
+    assert.match(await readFile(join(installPath, 'dist/extension.js'), 'utf8'), /activate/);
+    assert.equal(await readFile(join(installPath, 'resources/cursor-pool.svg'), 'utf8'), '<svg />\n');
+    assert.equal(await getExtensionState(installPath), 'bundled');
+
+    await removeExtensionBundle(installPath);
+    assert.equal(await getExtensionState(installPath), 'missing');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('bundleExtension default source works from package-local cwd', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-default-source-'));
+  const installPath = join(tempDir, 'installed/extensions/cursor-pool-status');
+  const previousCwd = process.cwd();
+  process.chdir(cliRoot);
+
+  try {
+    const result = await bundleExtension({ installPath });
+    assert.deepEqual(result, { state: 'bundled', installPath });
+    const manifest = JSON.parse(await readFile(join(installPath, 'package.json'), 'utf8'));
+    assert.equal(manifest.name, 'cursorpool');
+    assert.equal(manifest.publisher, 'cursor-pool');
+    assert.equal(manifest.displayName, 'Cursor Pool 平台模式');
+    assert.equal(manifest.type, 'module');
+    assert.match(await readFile(join(installPath, 'dist/extension.js'), 'utf8'), /activate/);
+    await access(join(installPath, 'resources/cursor-pool.svg'));
+  } finally {
+    process.chdir(previousCwd);
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('bundleExtension reports missing when dist entry is absent', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-missing-'));
+  const sourceDir = join(tempDir, 'source');
+  const installPath = join(tempDir, 'installed/extensions/cursor-pool-status');
+  await mkdir(sourceDir, { recursive: true });
+  await writeFile(join(sourceDir, 'package.json'), JSON.stringify({ name: 'x' }), 'utf8');
+
+  try {
+    const result = await bundleExtension({ sourceDir, installPath });
+    assert.deepEqual(result, { state: 'missing', installPath });
+    assert.equal(await getExtensionState(installPath), 'missing');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('bundleExtension rejects unsafe install paths without removing them', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-unsafe-bundle-'));
+  const sourceDir = join(tempDir, 'source');
+  const unsafeInstallPath = join(tempDir, 'unsafe-install-root');
+  await mkdir(join(sourceDir, 'dist'), { recursive: true });
+  await mkdir(unsafeInstallPath, { recursive: true });
+  await writeFile(join(sourceDir, 'package.json'), JSON.stringify({ name: 'x' }), 'utf8');
+  await writeFile(join(sourceDir, 'dist/extension.js'), 'export function activate() {}\n', 'utf8');
+  await writeFile(join(unsafeInstallPath, 'sentinel.txt'), 'keep me\n', 'utf8');
+
+  try {
+    await assert.rejects(
+      bundleExtension({ sourceDir, installPath: unsafeInstallPath }),
+      /Unsafe extension install path/,
+    );
+    assert.equal(await readFile(join(unsafeInstallPath, 'sentinel.txt'), 'utf8'), 'keep me\n');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('removeExtensionBundle rejects unsafe home path without removing it', async () => {
+  const originalHome = process.env.HOME;
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-unsafe-home-'));
+  const fakeHome = join(tempDir, 'home');
+  const unsafeBundleRoot = join(fakeHome, '.cursor-pool');
+  await mkdir(unsafeBundleRoot, { recursive: true });
+  await writeFile(join(unsafeBundleRoot, 'sentinel.txt'), 'keep me\n', 'utf8');
+  process.env.HOME = fakeHome;
+
+  try {
+    await assert.rejects(removeExtensionBundle('~/.cursor-pool'), /Unsafe extension install path/);
+    assert.equal(await readFile(join(unsafeBundleRoot, 'sentinel.txt'), 'utf8'), 'keep me\n');
+  } finally {
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('resolveExtensionInstallPath expands home-relative install paths', async () => {
+  const originalHome = process.env.HOME;
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-home-'));
+  const fakeHome = join(tempDir, 'home');
+  process.env.HOME = fakeHome;
+
+  try {
+    assert.equal(
+      resolveExtensionInstallPath('~/extensions/cursor-pool-status'),
+      join(fakeHome, 'extensions/cursor-pool-status'),
+    );
+  } finally {
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

package/test/extensionLink.test.ts

@@ -0,0 +1,209 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  getLinkedExtensionState,
+  linkExtensionBundle,
+  linkedExtensionPathForDir,
+  removeLinkedExtensionBundle,
+  restoreLinkedExtensionSnapshot,
+  snapshotLinkedExtensionBundle,
+} from '../src/extensionLink';
+
+async function createSourceBundle(tempDir: string) {
+  const sourceBundlePath = join(tempDir, 'source/extensions/cursor-pool-status');
+  await mkdir(join(sourceBundlePath, 'dist'), { recursive: true });
+  await writeFile(
+    join(sourceBundlePath, 'package.json'),
+    JSON.stringify({ name: 'cursorpool', publisher: 'cursor-pool', version: '0.0.0' }),
+    'utf8',
+  );
+  await writeFile(join(sourceBundlePath, 'dist/extension.js'), 'export function activate() {}\n', 'utf8');
+  return sourceBundlePath;
+}
+
+test('linkedExtensionPathForDir builds the deterministic Cursor extension path', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-path-'));
+  try {
+    assert.equal(
+      linkedExtensionPathForDir(join(tempDir, 'Cursor-Pool-Trial-Extensions')),
+      join(tempDir, 'Cursor-Pool-Trial-Extensions/cursor-pool.extension-0.0.0'),
+    );
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('linkExtensionBundle copies source bundle into Cursor extensions directory', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-'));
+  const sourceBundlePath = await createSourceBundle(tempDir);
+  const cursorExtensionsDir = join(tempDir, 'Extensions');
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+
+  try {
+    const result = await linkExtensionBundle({ sourceBundlePath, cursorExtensionsDir });
+
+    assert.deepEqual(result, { state: 'linked', linkedPath });
+    assert.equal(await getLinkedExtensionState(linkedPath), 'linked');
+    assert.match(await readFile(join(linkedPath, 'package.json'), 'utf8'), /cursorpool/);
+    assert.match(await readFile(join(linkedPath, 'dist/extension.js'), 'utf8'), /activate/);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('linkExtensionBundle refreshes Cursor extensions index with runtime extension id', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-index-'));
+  const sourceBundlePath = await createSourceBundle(tempDir);
+  const cursorExtensionsDir = join(tempDir, 'Extensions');
+  await mkdir(cursorExtensionsDir, { recursive: true });
+  await writeFile(
+    join(cursorExtensionsDir, 'extensions.json'),
+    JSON.stringify([
+      {
+        identifier: { id: 'cursor-pool.@cursor-pool/extension' },
+        relativeLocation: 'cursor-pool.extension-0.0.0',
+        version: '0.0.0',
+      },
+      {
+        identifier: { id: 'keg1255.cursorpool' },
+        relativeLocation: 'keg1255.cursorpool-1.0.52',
+        version: '1.0.52',
+      },
+      {
+        identifier: { id: 'cursor-pool.cursorpool' },
+        relativeLocation: 'cursor-pool.cursorpool-0.0.0',
+        version: '0.0.0',
+      },
+      {
+        identifier: { id: 'publisher.other' },
+        relativeLocation: 'publisher.other-1.0.0',
+        version: '1.0.0',
+      },
+    ]),
+    'utf8',
+  );
+
+  try {
+    const result = await linkExtensionBundle({ sourceBundlePath, cursorExtensionsDir });
+    const index = JSON.parse(await readFile(join(cursorExtensionsDir, 'extensions.json'), 'utf8'));
+
+    assert.equal(
+      index.some((entry: { identifier?: { id?: string } }) =>
+        entry.identifier?.id === 'cursor-pool.@cursor-pool/extension',
+      ),
+      false,
+    );
+    assert.equal(
+      index.some((entry: { relativeLocation?: string }) =>
+        entry.relativeLocation === 'keg1255.cursorpool-1.0.52',
+      ),
+      false,
+    );
+    assert.equal(
+      index.some((entry: { identifier?: { id?: string } }) =>
+        entry.identifier?.id === 'publisher.other',
+      ),
+      true,
+    );
+    assert.deepEqual(index.at(-1), {
+      identifier: { id: 'cursor-pool.cursorpool' },
+      location: {
+        $mid: 1,
+        path: result.linkedPath,
+        scheme: 'file',
+      },
+      relativeLocation: 'cursor-pool.extension-0.0.0',
+      version: '0.0.0',
+    });
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('linkExtensionBundle reports missing when source bundle is absent', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-missing-'));
+  const cursorExtensionsDir = join(tempDir, 'Extensions');
+
+  try {
+    const result = await linkExtensionBundle({
+      sourceBundlePath: join(tempDir, 'source/extensions/cursor-pool-status'),
+      cursorExtensionsDir,
+    });
+
+    assert.deepEqual(result, {
+      state: 'missing',
+      linkedPath: linkedExtensionPathForDir(cursorExtensionsDir),
+    });
+    assert.equal(await getLinkedExtensionState(result.linkedPath), 'missing');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('removeLinkedExtensionBundle rejects unsafe paths without removing bytes', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-unsafe-'));
+  const unsafePath = join(tempDir, 'not-the-linked-extension');
+  await mkdir(unsafePath, { recursive: true });
+  await writeFile(join(unsafePath, 'sentinel.txt'), 'keep me\n', 'utf8');
+
+  try {
+    await assert.rejects(removeLinkedExtensionBundle(unsafePath), /Unsafe linked extension path/);
+    assert.equal(await readFile(join(unsafePath, 'sentinel.txt'), 'utf8'), 'keep me\n');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('removeLinkedExtensionBundle rejects paths where extensions is not an exact segment', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-unsafe-segment-'));
+  const unsafePath = join(tempDir, 'not-extensions/cursor-pool.extension-0.0.0');
+  await mkdir(unsafePath, { recursive: true });
+  await writeFile(join(unsafePath, 'sentinel.txt'), 'keep me\n', 'utf8');
+
+  try {
+    await assert.rejects(removeLinkedExtensionBundle(unsafePath), /Unsafe linked extension path/);
+    assert.equal(await readFile(join(unsafePath, 'sentinel.txt'), 'utf8'), 'keep me\n');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('linked extension snapshot restores pre-existing linked bytes', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-snapshot-'));
+  const cursorExtensionsDir = join(tempDir, 'Extensions');
+  const linkedPath = linkedExtensionPathForDir(cursorExtensionsDir);
+  await mkdir(join(linkedPath, 'dist'), { recursive: true });
+  await writeFile(join(linkedPath, 'package.json'), JSON.stringify({ name: 'sentinel' }), 'utf8');
+  await writeFile(join(linkedPath, 'dist/extension.js'), 'sentinel\n', 'utf8');
+
+  try {
+    const snapshot = await snapshotLinkedExtensionBundle(linkedPath);
+    await rm(linkedPath, { recursive: true, force: true });
+    await mkdir(join(linkedPath, 'dist'), { recursive: true });
+    await writeFile(join(linkedPath, 'package.json'), JSON.stringify({ name: 'new' }), 'utf8');
+    await writeFile(join(linkedPath, 'dist/extension.js'), 'new\n', 'utf8');
+
+    await restoreLinkedExtensionSnapshot(linkedPath, snapshot);
+
+    assert.equal(await readFile(join(linkedPath, 'dist/extension.js'), 'utf8'), 'sentinel\n');
+    await rm(snapshot?.root ?? '', { recursive: true, force: true });
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('linked extension snapshot returns null for missing path and null restore is a no-op', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-extension-link-snapshot-missing-'));
+  const linkedPath = linkedExtensionPathForDir(join(tempDir, 'Extensions'));
+
+  try {
+    assert.equal(await snapshotLinkedExtensionBundle(linkedPath), null);
+    await restoreLinkedExtensionSnapshot(linkedPath, null);
+    assert.equal(await getLinkedExtensionState(linkedPath), 'missing');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});