The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
fix(install): distinguish user plugins from ECC aliases
affaan-m6dc706fe85cf
diff --git a/scripts/lib/install-lifecycle.js b/scripts/lib/install-lifecycle.jsindex 8b8ce2ca7..36122e7ea 100644--- a/scripts/lib/install-lifecycle.js+++ b/scripts/lib/install-lifecycle.js@@ -1799,6 +1799,7 @@ function createRepairPlanFromRecord(record, context, options = {}) {const statePreview = buildRecordedStatePreview(state, context, operations);const recordedPlan = {+ sourceRoot: context.repoRoot,mode: state.request.legacyMode ? 'legacy' : 'recorded',target: record.adapter.target,adapter: record.adapter,@@ -1950,6 +1951,7 @@ function preflightOpenCodeHookDeactivation(record, context, options = {}) {if (record.legacyLayout === 'opencode') {const state = record.state;const legacyPlan = withHookConsent({+ sourceRoot: context.repoRoot,target: 'opencode',adapter: record.adapter,targetRoot: record.targetRoot,diff --git a/scripts/lib/install/apply.js b/scripts/lib/install/apply.jsindex 0f8b27f51..39c7823ad 100644--- a/scripts/lib/install/apply.js+++ b/scripts/lib/install/apply.js@@ -321,6 +321,35 @@ function getOpenCodeActivationKind(plan, operation) {return isOpenCodeHookActivationOperation(operation) ? 'config' : null;}+function readOpenCodeAliasForAttribution(plan, destinationPath) {+ try {+ const operation = { destinationPath };+ assertSafeInstallOperation(plan, operation);+ if (!fs.lstatSync(destinationPath).isFile()) return null;+ return readInstalledFileNoFollow(plan, operation);+ } catch {+ // Optional, unrecorded aliases have no ECC ownership until their bytes+ // prove it. Never follow an unsafe path or relax recorded/planned guards.+ return null;+ }+}++function knownOpenCodePluginDigests(plan) {+ const digests = new Set();+ if (typeof plan.sourceRoot !== 'string' || !path.isAbsolute(plan.sourceRoot)) return digests;+ const sourcePlan = { ...plan, targetRoot: plan.sourceRoot };+ for (const directory of ['.opencode/plugins', '.opencode/dist/plugins']) {+ for (const name of ['ecc-hooks', 'index']) {+ for (const extension of ['ts', 'js', 'mjs', 'cjs']) {+ const content = readOpenCodeAliasForAttribution(sourcePlan,+ path.join(plan.sourceRoot, directory, `${name}.${extension}`));+ if (content !== null) digests.add(crypto.createHash('sha256').update(content).digest('hex'));+ }+ }+ }+ return digests;+}+function openCodeActivationCandidates(plan, previousOperations) {const candidates = new Map();for (const operation of [...previousOperations, ...plan.operations]) {@@ -328,17 +357,22 @@ function openCodeActivationCandidates(plan, previousOperations) {candidates.set(comparablePath(operation.destinationPath), operation);}}- // Old installs can leave aliases that are absent from the new source tree.- // Inspect only ECC's known entrypoint names, never unrelated user plugins.+ // Old installs can leave unrecorded aliases, but names such as index.js+ // are also used by unrelated plugins. Attribute only exact ECC artifacts.+ const knownDigests = knownOpenCodePluginDigests(plan);for (const name of ['ecc-hooks', 'index']) {for (const extension of ['ts', 'js', 'mjs', 'cjs']) {const destinationPath = path.join(plan.targetRoot, 'plugins', `${name}.${extension}`);const key = comparablePath(destinationPath);if (!candidates.has(key)) {- candidates.set(key, {- sourceRelativePath: `.opencode/plugins/${name}.${extension}`,- destinationPath,- });+ const content = readOpenCodeAliasForAttribution(plan, destinationPath);+ const digest = content === null ? null : crypto.createHash('sha256').update(content).digest('hex');+ if (knownDigests.has(digest)) {+ candidates.set(key, {+ sourceRelativePath: `.opencode/plugins/${name}.${extension}`,+ destinationPath,+ });+ }}}}diff --git a/tests/lib/install-lifecycle.test.js b/tests/lib/install-lifecycle.test.jsindex c1862581c..6a892797f 100644--- a/tests/lib/install-lifecycle.test.js+++ b/tests/lib/install-lifecycle.test.js@@ -2239,7 +2239,7 @@ function runTests() {const pluginPath = path.join(recorded.targetRoot, 'plugins', 'index.ts');const canonicalPluginPath = fs.realpathSync(pluginPath);const aliasPath = path.join(recorded.targetRoot, 'plugins', 'index.js');- const aliasContent = 'globalThis.lateActiveAlias = true;\n';+ const aliasContent = fs.readFileSync(path.join(REPO_ROOT, '.opencode', 'plugins', 'index.ts'), 'utf8');const stateBefore = fs.readFileSync(recorded.installStatePath);let inserted = false;fs.openSync = function trackPluginWriteDescriptor(candidate, ...args) {diff --git a/tests/lib/opencode-hook-consent-safety.test.js b/tests/lib/opencode-hook-consent-safety.test.jsindex 09b5a9fc7..4f6b05b23 100644--- a/tests/lib/opencode-hook-consent-safety.test.js+++ b/tests/lib/opencode-hook-consent-safety.test.js@@ -220,6 +220,100 @@ function runTests() {{ plugin: [], userSetting: true });assert.strictEqual(fs.existsSync(`${value.installStatePath}.ecc.lock`), false);}));+ for (const consent of [null, 'declined']) {+ test(`fresh ${consent || 'default'} apply preserves unrelated unrecorded plugin aliases`, () => fixture(value => {+ fs.unlinkSync(value.installStatePath);+ for (const operation of value.basePlan.operations) fs.unlinkSync(operation.destinationPath);+ const aliases = ['index.ts', 'index.js', 'index.mjs', 'index.cjs', 'ecc-hooks.js'];+ const content = 'export default async () => ({ "user.plugin": () => {} });\n';+ for (const alias of aliases) fs.writeFileSync(path.join(value.targetRoot, 'plugins', alias), content);+ const result = applyInstallPlan(withHookConsent(value.basePlan, consent));+ assert.strictEqual(result.applied, true);+ const state = readInstallState(value.installStatePath);+ for (const alias of aliases) {+ const destination = path.join(value.targetRoot, 'plugins', alias);+ assert.strictEqual(fs.readFileSync(destination, 'utf8'), content);+ assert.ok(!state.operations.some(operation => operation.destinationPath === destination), 'Do not adopt a user plugin');+ }+ }));+ }+ for (const mode of ['doctor', 'repair']) {+ test(`${mode} preserves an unrelated plugin without reporting ECC activation`, () => fixture(value => {+ applyInstallPlan(value.declinePlan);+ const destination = path.join(value.targetRoot, 'plugins', 'index.js');+ const content = 'export default async () => ({ "user.plugin": () => {} });\n';+ fs.writeFileSync(destination, content);+ const before = fs.readFileSync(value.installStatePath);+ if (mode === 'doctor') {+ const result = buildDoctorReport({ repoRoot: value.sourceRoot, homeDir: value.homeDir,+ projectRoot: value.homeDir, targets: ['opencode'] }).results[0];+ assert.ok(!result.issues.some(issue => issue.code === 'opencode-hook-consent-violation'), JSON.stringify(result.issues));+ } else {+ const result = repair(value).results[0];+ assert.notStrictEqual(result.status, 'error', result.error);+ }+ assert.strictEqual(fs.readFileSync(destination, 'utf8'), content);+ const { lastValidatedAt: _beforeValidation, ...priorState } = JSON.parse(before);+ const { lastValidatedAt: _afterValidation, ...afterState } = readInstallState(value.installStatePath);+ assert.deepStrictEqual(afterState, priorState, 'Only the legitimate validation timestamp may change');+ assert.ok(!afterState.operations.some(operation => operation.destinationPath === destination), 'Do not adopt a user plugin');+ }));+ }+ for (const artifact of ['source', 'build']) {+ test(`unrecorded ${artifact}-identical ECC alias still fails closed`, () => fixture(value => {+ applyInstallPlan(value.declinePlan);+ const source = artifact === 'source'+ ? path.join(value.sourceRoot, '.opencode', 'plugins', 'ecc-hooks.ts')+ : path.join(value.sourceRoot, '.opencode', 'dist', 'plugins', 'index.js');+ if (artifact === 'build') fs.writeFileSync(source, 'module.exports = { eccHook: true };\n');+ const content = fs.readFileSync(source);+ const alias = path.join(value.targetRoot, 'plugins', 'index.js');+ fs.writeFileSync(alias, content);+ const before = fs.readFileSync(value.installStatePath);+ assert.throws(() => applyInstallPlan(value.declinePlan), /OpenCode hook deactivation/);+ const doctor = buildDoctorReport({ repoRoot: value.sourceRoot, homeDir: value.homeDir,+ projectRoot: value.homeDir, targets: ['opencode'] }).results[0];+ assert.ok(doctor.issues.some(issue => issue.code === 'opencode-hook-consent-violation'));+ assert.strictEqual(repair(value).results[0].status, 'error');+ assert.deepStrictEqual(fs.readFileSync(alias), content);+ assert.deepStrictEqual(fs.readFileSync(value.installStatePath), before);+ }));+ }+ test('an unrecorded collision at a planned ECC plugin destination still fails closed', () => fixture(value => {+ fs.unlinkSync(value.installStatePath);+ fs.unlinkSync(path.join(value.targetRoot, 'opencode.json'));+ const destination = path.join(value.targetRoot, 'plugins', 'ecc-hooks.ts');+ const content = '// user-owned file at an ECC destination\n';+ fs.writeFileSync(destination, content);+ assert.throws(() => applyInstallPlan(value.declinePlan), /user-owned|unverifiable/i);+ assert.strictEqual(fs.readFileSync(destination, 'utf8'), content);+ assert.strictEqual(fs.existsSync(value.installStatePath), false);+ }));+ for (const planned of [false, true]) {+ test(`${planned ? 'planned ECC' : 'unrecorded user'} plugin read failures respect the attribution boundary`, () => fixture(value => {+ const destination = path.join(value.targetRoot, 'plugins', planned ? 'ecc-hooks.ts' : 'index.js');+ const content = planned ? fs.readFileSync(destination) : Buffer.from('// unreadable user plugin\n');+ if (!planned) fs.writeFileSync(destination, content);+ const originalOpen = fs.openSync;+ let refusedReads = 0;+ fs.openSync = function (candidate, ...args) {+ if (typeof candidate === 'string' && path.resolve(candidate) === destination) {+ refusedReads++;+ throw Object.assign(new Error('Synthetic plugin read permission denied'), { code: 'EACCES' });+ }+ return originalOpen.call(fs, candidate, ...args);+ };+ try {+ if (planned) assert.throws(() => applyInstallPlan(value.declinePlan), /permission denied/);+ else assert.strictEqual(applyInstallPlan(value.declinePlan).applied, true);+ assert.ok(refusedReads > 0, 'The permission boundary must be exercised');+ } finally {+ fs.openSync = originalOpen;+ }+ assert.deepStrictEqual(fs.readFileSync(destination), content);+ if (!planned) assert.ok(!readInstallState(value.installStatePath).operations.some(operation => operation.destinationPath === destination));+ }));+ }test('repair preserves the primary failure and replacement lock when release also fails', () => fixture(value => {const destination = path.join(value.targetRoot, 'opencode.json');const lock = `${value.installStatePath}.ecc.lock`;