fix(cline): make hook installation transactional

This commit is contained in:
ZacharyZhang-NY committed 2026-07-20 10:39:39 -04:00
1 parent 65b60b1eba
commit cf77d49a3c
10 files changed
+1055 -623

No files matched your search

+282
View File
@@ -0,0 +1,282 @@
import assert from 'node:assert/strict';
import {
lstat,
mkdir,
readFile,
readdir,
rm,
symlink,
writeFile,
} from 'node:fs/promises';
import path from 'node:path';
import test from 'node:test';
import {
contractModuleUrl,
createFixture,
environment,
installConfig,
installationModuleUrl,
ioModuleUrl,
runNode,
} from '../test-support/cline-test-helpers.mjs';
const managedFiles = [
'guard.js',
'config.json',
'private.key',
'hook.js',
];
async function assertMissing(filePath) {
await assert.rejects(lstat(filePath), { code: 'ENOENT' });
}
async function snapshotInstallation(fixture) {
const paths = [
...managedFiles.map((name) => path.join(fixture.agentDir, name)),
fixture.guardWrapperPath,
fixture.auditWrapperPath,
];
return new Map(await Promise.all(paths.map(async (filePath) => [
filePath,
await readFile(filePath, 'utf-8'),
])));
}
async function assertSnapshot(snapshot) {
for (const [filePath, source] of snapshot) {
assert.equal(await readFile(filePath, 'utf-8'), source, filePath);
}
}
async function assertNoTransactionFiles(fixture) {
const names = [];
for (const directory of [fixture.agentDir, fixture.hooksDir]) {
try {
names.push(...await readdir(directory));
} catch (error) {
if (error?.code !== 'ENOENT') throw error;
}
}
assert.equal(names.some((name) => /\.(tmp|rollback)$/.test(name)), false, names.join(', '));
}
function transactionEnvironment(fixture, overrides = {}) {
return {
...environment(fixture),
ELYDORA_INSTALL_CONFIG: JSON.stringify(installConfig(fixture, overrides)),
};
}
const prepareSource = `
import { resolveHookFiles } from ${JSON.stringify(contractModuleUrl)};
import { readHookFile } from ${JSON.stringify(ioModuleUrl)};
import { prepareClineInstallation } from ${JSON.stringify(installationModuleUrl)};
const config = JSON.parse(process.env.ELYDORA_INSTALL_CONFIG);
const paths = resolveHookFiles();
const guard = await readHookFile(paths.guardPath);
const audit = await readHookFile(paths.auditPath);
const prepared = await prepareClineInstallation(config, guard, audit);
`;
test('Cline rolls back all six files when a late transaction commit fails', async () => {
const fixture = await createFixture();
try {
assert.equal((await fixture.install()).code, 0);
const before = await snapshotInstallation(fixture);
const source = `${prepareSource}
import { commitClineInstallation } from ${JSON.stringify(installationModuleUrl)};
import { rename } from 'node:fs/promises';
let calls = 0;
await commitClineInstallation(prepared, async (from, to) => {
calls += 1;
if (calls === 5) throw new Error('injected rename failure');
await rename(from, to);
});
`;
const result = await runNode(
['--input-type=module', '--eval', source],
transactionEnvironment(fixture, { orgId: 'org-updated', token: 'token-updated' }),
fixture.projectDir,
);
assert.equal(result.code, 1);
assert.match(result.stderr, /injected rename failure/i);
await assertSnapshot(before);
await assertNoTransactionFiles(fixture);
} finally {
await fixture.close();
}
});
test('Cline detects concurrent hook replacement before runtime commit', async () => {
const fixture = await createFixture();
try {
assert.equal((await fixture.install()).code, 0);
const before = await snapshotInstallation(fixture);
const concurrent = '// concurrently replaced\n';
const source = `${prepareSource}
import { writeFile } from 'node:fs/promises';
import { commitClineInstallation } from ${JSON.stringify(installationModuleUrl)};
await writeFile(process.env.ELYDORA_CONCURRENT_PATH, process.env.ELYDORA_CONCURRENT);
await commitClineInstallation(prepared);
`;
const result = await runNode(
['--input-type=module', '--eval', source],
{
...transactionEnvironment(fixture, { orgId: 'org-updated' }),
ELYDORA_CONCURRENT_PATH: fixture.auditWrapperPath,
ELYDORA_CONCURRENT: concurrent,
},
fixture.projectDir,
);
assert.equal(result.code, 1);
assert.match(result.stderr, /changed during Cline installation/i);
for (const [filePath, sourceBefore] of before) {
if (filePath !== fixture.auditWrapperPath) {
assert.equal(await readFile(filePath, 'utf-8'), sourceBefore, filePath);
}
}
assert.equal(await readFile(fixture.auditWrapperPath, 'utf-8'), concurrent);
await assertNoTransactionFiles(fixture);
} finally {
await fixture.close();
}
});
test('Cline rejects stale hook snapshots before staging files', async () => {
const fixture = await createFixture();
try {
assert.equal((await fixture.install()).code, 0);
const before = await snapshotInstallation(fixture);
const concurrent = '// stale snapshot replacement\n';
const source = `
import { resolveHookFiles } from ${JSON.stringify(contractModuleUrl)};
import { readHookFile } from ${JSON.stringify(ioModuleUrl)};
import { prepareClineInstallation } from ${JSON.stringify(installationModuleUrl)};
import { writeFile } from 'node:fs/promises';
const config = JSON.parse(process.env.ELYDORA_INSTALL_CONFIG);
const paths = resolveHookFiles();
const guard = await readHookFile(paths.guardPath);
const audit = await readHookFile(paths.auditPath);
await writeFile(paths.auditPath, process.env.ELYDORA_CONCURRENT);
await prepareClineInstallation(config, guard, audit);
`;
const result = await runNode(
['--input-type=module', '--eval', source],
{ ...transactionEnvironment(fixture), ELYDORA_CONCURRENT: concurrent },
fixture.projectDir,
);
assert.equal(result.code, 1);
assert.match(result.stderr, /changed before installation/i);
for (const [filePath, sourceBefore] of before) {
if (filePath !== fixture.auditWrapperPath) {
assert.equal(await readFile(filePath, 'utf-8'), sourceBefore, filePath);
}
}
assert.equal(await readFile(fixture.auditWrapperPath, 'utf-8'), concurrent);
await assertNoTransactionFiles(fixture);
} finally {
await fixture.close();
}
});
test('Cline preserves orphaned runtime artifacts without a verifiable identity', async () => {
const fixture = await createFixture();
try {
await mkdir(fixture.agentDir, { recursive: true });
await writeFile(fixture.guardScriptPath, 'orphaned guard\n');
const result = await fixture.install();
assert.equal(result.code, 1);
assert.match(result.stderr, /identity cannot be verified/i);
assert.equal(await readFile(fixture.guardScriptPath, 'utf-8'), 'orphaned guard\n');
await assertMissing(fixture.guardWrapperPath);
} finally {
await fixture.close();
}
});
test('Cline rejects linked hook directories, runtime roots, and hook files', async (t) => {
for (const kind of ['hooks', 'runtime', 'hook']) {
await t.test(kind, async () => {
const fixture = await createFixture();
try {
const target = path.join(fixture.rootDir, `${kind}-target`);
await mkdir(target, { recursive: true });
if (kind === 'hooks') {
await mkdir(path.dirname(fixture.hooksDir), { recursive: true });
await symlink(target, fixture.hooksDir, 'junction');
} else if (kind === 'runtime') {
await mkdir(fixture.homeDir, { recursive: true });
await symlink(target, path.join(fixture.homeDir, '.elydora'), 'junction');
} else {
assert.equal((await fixture.install()).code, 0);
const targetFile = path.join(target, 'PreToolUse.mjs');
await writeFile(targetFile, 'external hook\n');
await rm(fixture.guardWrapperPath);
await symlink(targetFile, fixture.guardWrapperPath, 'file');
}
const result = await fixture.install();
assert.equal(result.code, 1);
assert.match(result.stderr, /physical (directory|file)/i);
} catch (error) {
if (error?.code === 'EPERM') {
t.skip(`symbolic links unavailable: ${error.message}`);
return;
}
throw error;
} finally {
await fixture.close();
}
});
}
});
test('Cline uninstall restores both hooks when the second removal fails', async () => {
const fixture = await createFixture();
try {
assert.equal((await fixture.install()).code, 0);
const before = await snapshotInstallation(fixture);
const source = `
import { resolveHookFiles } from ${JSON.stringify(contractModuleUrl)};
import { readHookFile } from ${JSON.stringify(ioModuleUrl)};
import {
commitClineUninstall,
prepareClineUninstall,
} from ${JSON.stringify(installationModuleUrl)};
import { rename } from 'node:fs/promises';
const paths = resolveHookFiles();
const files = await Promise.all([
readHookFile(paths.guardPath),
readHookFile(paths.auditPath),
]);
const prepared = await prepareClineUninstall(files, 'agent-1');
let calls = 0;
await commitClineUninstall(prepared, async (from, to) => {
calls += 1;
if (calls === 2) throw new Error('injected uninstall failure');
await rename(from, to);
});
`;
const result = await runNode(
['--input-type=module', '--eval', source],
environment(fixture),
fixture.projectDir,
);
assert.equal(result.code, 1);
assert.match(result.stderr, /injected uninstall failure/i);
await assertSnapshot(before);
await assertNoTransactionFiles(fixture);
} finally {
await fixture.close();
}
});
test('Cline installation leaves no transaction artifacts', async () => {
const fixture = await createFixture();
try {
assert.equal((await fixture.install()).code, 0);
await assertNoTransactionFiles(fixture);
} finally {
await fixture.close();
}
});