@cursorpool-dev/cli 0.5.6

package/node_modules/@cursor-pool/patcher/test/patchCursorAlwaysLocal.test.ts

@@ -0,0 +1,144 @@
+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 { sha256File } from '../src/hash';
+import {
+  buildCursorAlwaysLocalTakeoverPatchSnippet,
+  CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_MARKER,
+  CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_SIGNATURE,
+  hasCursorAlwaysLocalTakeoverMarker,
+} from '../src/alwaysLocalMarker';
+import {
+  backupPathForCursorAlwaysLocal,
+  patchCursorAlwaysLocal,
+  resolveCursorAlwaysLocalPath,
+} from '../src/patchCursorAlwaysLocal';
+import { restoreCursorAlwaysLocal } from '../src/restoreCursorAlwaysLocal';
+
+const targetRelativePath =
+  'Contents/Resources/app/extensions/cursor-always-local/dist/main.js';
+
+async function createFixture(content = 'async function streamUnifiedChat() { return "cursor"; }\n') {
+  const base = await mkdtemp(join(tmpdir(), 'cursor-pool-always-local-'));
+  const appPath = join(base, `Fixture-${Date.now()}-${Math.random()}.app`);
+  await mkdir(join(appPath, 'Contents/Resources/app/extensions/cursor-always-local/dist'), {
+    recursive: true,
+  });
+  await writeFile(join(appPath, targetRelativePath), content, 'utf8');
+  return { appPath, targetPath: join(appPath, targetRelativePath) };
+}
+
+test('always-local patch changes target hash and writes takeover marker', async () => {
+  const fixture = await createFixture();
+  const backupDir = join(tmpdir(), `cursor-pool-always-local-backups-${Date.now()}-${Math.random()}`);
+
+  try {
+    assert.equal(resolveCursorAlwaysLocalPath(fixture.appPath), fixture.targetPath);
+    const beforeHash = await sha256File(fixture.targetPath);
+    const result = await patchCursorAlwaysLocal(fixture.appPath, { backupDir });
+    const content = await readFile(fixture.targetPath, 'utf8');
+
+    assert.equal(result.beforeHash, beforeHash);
+    assert.notEqual(result.afterHash, beforeHash);
+    assert.equal(content.includes(CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_MARKER), true);
+    assert.equal(content.includes(CURSOR_POOL_ALWAYS_LOCAL_TAKEOVER_SIGNATURE), true);
+    assert.equal(await hasCursorAlwaysLocalTakeoverMarker(fixture.targetPath), true);
+    assert.match(result.backupPath, new RegExp(`^${backupDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(backupDir, { recursive: true, force: true });
+  }
+});
+
+test('always-local patch supports Linux Cursor relative paths', async () => {
+  const base = await mkdtemp(join(tmpdir(), 'cursor-pool-always-local-linux-'));
+  const appPath = join(base, 'squashfs-root');
+  const linuxTargetRelativePath =
+    'usr/share/cursor/resources/app/extensions/cursor-always-local/dist/main.js';
+  const targetPath = join(appPath, linuxTargetRelativePath);
+  const backupDir = join(tmpdir(), `cursor-pool-always-local-linux-backups-${Date.now()}-${Math.random()}`);
+
+  try {
+    await mkdir(join(appPath, 'usr/share/cursor/resources/app/extensions/cursor-always-local/dist'), {
+      recursive: true,
+    });
+    await writeFile(targetPath, 'async function streamUnifiedChat() { return "cursor"; }\n', 'utf8');
+
+    assert.equal(resolveCursorAlwaysLocalPath(appPath, linuxTargetRelativePath), targetPath);
+    const beforeHash = await sha256File(targetPath);
+    const patch = await patchCursorAlwaysLocal(appPath, {
+      backupDir,
+      targetRelativePath: linuxTargetRelativePath,
+    });
+    const restore = await restoreCursorAlwaysLocal(appPath, {
+      backupDir,
+      targetRelativePath: linuxTargetRelativePath,
+    });
+
+    assert.equal(patch.targetPath, targetPath);
+    assert.notEqual(patch.afterHash, beforeHash);
+    assert.equal(restore.targetPath, targetPath);
+    assert.equal(restore.afterHash, beforeHash);
+    assert.equal(await hasCursorAlwaysLocalTakeoverMarker(targetPath), false);
+  } finally {
+    await rm(base, { recursive: true, force: true });
+    await rm(backupDir, { recursive: true, force: true });
+  }
+});
+
+test('always-local restore returns patched target to original hash and removes marker', async () => {
+  const fixture = await createFixture();
+  const backupDir = join(tmpdir(), `cursor-pool-always-local-restore-${Date.now()}-${Math.random()}`);
+
+  try {
+    const beforeHash = await sha256File(fixture.targetPath);
+    const patch = await patchCursorAlwaysLocal(fixture.appPath, { backupDir });
+    assert.equal(await hasCursorAlwaysLocalTakeoverMarker(fixture.targetPath), true);
+
+    const restore = await restoreCursorAlwaysLocal(fixture.appPath, { backupDir });
+
+    assert.equal(patch.beforeHash, beforeHash);
+    assert.equal(restore.beforeHash, patch.afterHash);
+    assert.equal(restore.afterHash, beforeHash);
+    assert.equal(await sha256File(fixture.targetPath), beforeHash);
+    assert.equal(await hasCursorAlwaysLocalTakeoverMarker(fixture.targetPath), false);
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(backupDir, { recursive: true, force: true });
+  }
+});
+
+test('always-local restore refuses a backup that contains takeover marker text', async () => {
+  const fixture = await createFixture();
+  const backupDir = join(tmpdir(), `cursor-pool-always-local-bad-backup-${Date.now()}-${Math.random()}`);
+
+  try {
+    await patchCursorAlwaysLocal(fixture.appPath, { backupDir });
+    const patchedHash = await sha256File(fixture.targetPath);
+    const backupPath = await backupPathForCursorAlwaysLocal(fixture.appPath, fixture.targetPath, backupDir);
+    await writeFile(backupPath, await readFile(fixture.targetPath, 'utf8'), 'utf8');
+
+    await assert.rejects(
+      restoreCursorAlwaysLocal(fixture.appPath, { backupDir }),
+      /backup.*patch marker/i,
+    );
+
+    assert.equal(await sha256File(fixture.targetPath), patchedHash);
+    assert.equal(await hasCursorAlwaysLocalTakeoverMarker(fixture.targetPath), true);
+  } finally {
+    await rm(fixture.appPath, { recursive: true, force: true });
+    await rm(backupDir, { recursive: true, force: true });
+  }
+});
+
+test('always-local snippet calls takeover endpoint without prompt or token literals', () => {
+  const snippet = buildCursorAlwaysLocalTakeoverPatchSnippet();
+  assert.equal(snippet.includes('/agent/takeover'), true);
+  assert.equal(snippet.includes('CURSOR_POOL_RUNTIME_FILE'), true);
+  assert.equal(snippet.includes('cursor-always-local'), true);
+  assert.equal(snippet.includes('prompt'), false);
+  assert.equal(snippet.includes('messages:'), false);
+  assert.equal(snippet.includes('routeToken'), false);
+});