The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
fix(opencode): guard legacy cleanup and portable consent fixtures
affaan-mef8c2d8b9c91
diff --git a/scripts/lib/install-lifecycle.js b/scripts/lib/install-lifecycle.jsindex 1702684ae..bc9cb05cc 100644--- a/scripts/lib/install-lifecycle.js+++ b/scripts/lib/install-lifecycle.js@@ -1964,7 +1964,7 @@ function preflightOpenCodeHookDeactivation(record, context, options = {}) {// Migration does not replay operations into the old root. Inspect existing// activations there, without treating historical merge-json records as new// writes; the canonical destination is validated separately below.- assertOpenCodeRepairHookDeactivation({ ...legacyPlan, operations: [] }, { requireInactive: true });+ assertOpenCodeRepairHookDeactivation({ ...legacyPlan, operations: [] }, { allowVerifiedLegacyRemoval: true });assertOpenCodeRepairHookDeactivation(rawPlan, options);return;}@@ -2298,9 +2298,10 @@ function repairInstalledStates(options = {}) {homeDir: context.homeDir, projectRoot: context.projectRoot,repoRoot: context.projectRoot, env: context.env,});- const { getOpenCodeInstallRoots } = require('./install/apply');+ const { getOpenCodeInstallRoots, assertOpenCodeLeaseCoverage } = require('./install/apply');const roots = getOpenCodeInstallRoots({ adapter, targetRoot, homeDir: context.homeDir });return withOpenCodeInstallLocks(roots, lease => {+ assertOpenCodeLeaseCoverage({ adapter, targetRoot, homeDir: context.homeDir }, lease);// Discovery precedes acquisition. Never repair from that stale state.record = buildDiscoveryRecord(adapter, context, record.legacyLayout === 'opencode'? getLegacyOpencodeLocation(context.homeDir) : null);diff --git a/scripts/lib/install/apply.js b/scripts/lib/install/apply.jsindex eb90de8c1..f9db01d00 100644--- a/scripts/lib/install/apply.js+++ b/scripts/lib/install/apply.js@@ -14,8 +14,8 @@ const {disableOpenCodeHookPluginRegistration,getDisabledOpenCodePluginContent,getRecordedHookConsent,- isOpenCodeHookActivationOperation,- isOpenCodePluginEntrypoint,+ getOpenCodeActivationPathKind,+ getOpenCodeSourceActivationKind,planMaterializesHookRuntime,shouldDisableOpenCodeHooks,} = require('./hook-consent');@@ -42,7 +42,8 @@ const {prepareUserOwnedFileGuard,preserveUnwrittenFiles,} = require('./ownership-guard');-const { cleanupLegacyOpencodeInstall, getLegacyLocationForPlan } = require('./opencode-legacy-migration');+const { cleanupLegacyOpencodeInstall, getLegacyLocationForPlan, inspectLegacyOpencodeState,+ verifyManagedLegacyFile } = require('./opencode-legacy-migration');const { writeFileNoFollow } = require('./guarded-write');const { withOpenCodeInstallLocks } = require('./opencode-install-lock');const {@@ -313,12 +314,7 @@ function getOpenCodeActivationKind(plan, operation) {const relative = operation.destinationPath? path.relative(plan.targetRoot, operation.destinationPath).split(path.sep).join('/').toLowerCase(): '';- if (/^plugins\/(?:[^/]+\.(?:[cm]?js|ts)|[^/]+\/(?:index\.(?:[cm]?js|ts)|package\.json))$/.test(relative)) {- return 'plugin';- }- if (relative === 'opencode.json') return 'config';- if (isOpenCodePluginEntrypoint(operation)) return 'plugin';- return isOpenCodeHookActivationOperation(operation) ? 'config' : null;+ return getOpenCodeActivationPathKind(relative) || getOpenCodeSourceActivationKind(operation);}function readOpenCodeAliasForAttribution(plan, destinationPath) {@@ -473,8 +469,11 @@ function assertOpenCodeHookDeactivationReady(plan, options = {}) {const desired = new Map(plan.operations.filter(operation => getOpenCodeActivationKind(plan, operation)).map(operation => [comparablePath(operation.destinationPath), operation]));const snapshot = new Map();- for (const [key, operation] of openCodeActivationCandidates(plan, [...previous.values()])) {+ for (const [key, operation] of openCodeActivationCandidates(plan, [...previous.values(), ...(options.legacyOperations || [])])) {const kind = getOpenCodeActivationKind(plan, operation);+ if (kind === 'package') {+ throw new Error(`Unsupported OpenCode package metadata deactivation: ${operation.destinationPath}`);+ }const expectedTransform = kind === 'plugin'? 'opencode-disable-plugin-entrypoint' : 'opencode-disable-ecc-hooks';const replacement = desired.get(key);@@ -498,8 +497,14 @@ function assertOpenCodeHookDeactivationReady(plan, options = {}) {}continue;}- if (kind === 'plugin' && inactive) continue;+ if (inactive && (kind === 'plugin' || options.allowVerifiedLegacyRemoval)) continue;const recorded = previous.get(key);+ if (options.allowVerifiedLegacyRemoval && recorded) {+ const verified = verifyManagedLegacyFile(recorded, {+ targetRoot: plan.targetRoot, installStatePath: plan.installStatePath,+ }, plan.sourceRoot);+ if (verified.destinationPath && verified.digest === digest) continue;+ }if (!replacement || replacement.kind !== 'copy-file'|| replacement.contentTransform !== expectedTransform|| !recorded || recorded.contentSha256 !== digest) {@@ -530,17 +535,29 @@ function getOpenCodeActivationWriteOptions(operation, snapshot) {function getOpenCodeInstallRoots(plan) {const roots = [plan.targetRoot];const legacy = getLegacyLocationForPlan(plan);- if (legacy) {- try {- fs.lstatSync(legacy.targetRoot);- roots.push(legacy.targetRoot);- } catch (error) {- if (error.code !== 'ENOENT') throw error;- }- }+ const inspection = inspectLegacyOpencodeState(legacy);+ if (inspection.status === 'unreadable') throw new Error(inspection.error);+ if (inspection.status === 'valid') roots.push(legacy.targetRoot);return roots;}+function inspectLegacyOpenCodeDeactivation(plan) {+ const location = getLegacyLocationForPlan(plan);+ if (!location || comparablePath(location.targetRoot) === comparablePath(plan.targetRoot)) return null;+ const inspection = inspectLegacyOpencodeState(location);+ if (inspection.status === 'unreadable') throw new Error(inspection.error);+ if (inspection.status !== 'valid') return null;+ const legacyPlan = { ...plan, ...location, operations: [] };+ assertOpenCodeHookDeactivationReady(legacyPlan, { allowVerifiedLegacyRemoval: true });+ return { plan: legacyPlan, operations: inspection.state.operations.filter(operation => operation.ownership === 'managed') };+}++function assertOpenCodeLeaseCoverage(plan, lease) {+ if (plan.adapter?.target !== 'opencode') return;+ // Reuse checks opaque ownership without acquiring extra roots out of order.+ withOpenCodeInstallLocks(getOpenCodeInstallRoots(plan), () => {}, lease);+}+function findPreviousManagedHooks(previousState, plan, operation) {if (!previousState@@ -704,7 +721,7 @@ function applyInstallPlan(plan, dependencies = {}) {assertSafeInstallOperation(plan, { destinationPath: plan.installStatePath });return withOpenCodeInstallLocks(getOpenCodeInstallRoots(plan),- () => applyInstallPlanLocked(plan, dependencies, false),+ lease => applyInstallPlanLocked(plan, { ...dependencies, opencodeLease: lease }, false),dependencies.opencodeLease);}@@ -732,6 +749,8 @@ function applyInstallPlanLocked(plan, dependencies = {}, settingsLockHeld = falsif (typeof beforeInstallStateRead === 'function') {beforeInstallStateRead({ plan });}+ assertOpenCodeLeaseCoverage(plan, dependencies.opencodeLease);+ const legacyActivation = inspectLegacyOpenCodeDeactivation(plan);const activationSnapshot = assertOpenCodeHookDeactivationReady(plan);const migration = prepareExcludedPathsReconciliation(plan,@@ -953,6 +972,9 @@ function applyInstallPlanLocked(plan, dependencies = {}, settingsLockHeld = fals];}+ assertOpenCodeLeaseCoverage(appliedPlan, dependencies.opencodeLease);+ // Recheck removable bytes after canonical writes, before legacy cleanup.+ inspectLegacyOpenCodeDeactivation(appliedPlan);let opencodeMigrationWarnings = [];try {const opencodeMigration = cleanupLegacyOpencodeInstall(appliedPlan);@@ -968,6 +990,12 @@ function applyInstallPlanLocked(plan, dependencies = {}, settingsLockHeld = fals];}+ if (legacyActivation) {+ assertOpenCodeHookDeactivationReady(legacyActivation.plan, {+ requireInactive: true, legacyOperations: legacyActivation.operations,+ });+ }+let excludedPathsRemoved = [];let excludedPathsWarnings = [];try {@@ -1001,6 +1029,7 @@ function applyInstallPlanLocked(plan, dependencies = {}, settingsLockHeld = falsmodule.exports = {applyInstallPlan,assertOpenCodeActivationUnchanged,+ assertOpenCodeLeaseCoverage,assertOpenCodeHookDeactivationReady,getOpenCodeActivationKind,getOpenCodeActivationWriteOptions,diff --git a/scripts/lib/install/hook-consent.js b/scripts/lib/install/hook-consent.jsindex e29c01bf5..f954c9016 100644--- a/scripts/lib/install/hook-consent.js+++ b/scripts/lib/install/hook-consent.js@@ -69,10 +69,22 @@ function disableOpenCodeHookPluginRegistration(content, sourceRelativePath) {}, null, 2)}\n`;}+function getOpenCodeActivationPathKind(value) {+ const relative = normalizeOperationPath(value);+ if (relative === 'opencode.json') return 'config';+ if (/^plugins\/[^/]+\/package\.json$/.test(relative)) return 'package';+ if (/^plugins\/(?:[^/]+\.(?:[cm]?js|ts)|[^/]+\/index\.(?:[cm]?js|ts))$/.test(relative)) return 'plugin';+ return null;+}++function getOpenCodeSourceActivationKind(operation = {}) {+ const source = normalizeOperationPath(operation.sourceRelativePath);+ if (!source.startsWith('.opencode/')) return null;+ return getOpenCodeActivationPathKind(source.replace(/^\.opencode\/(?:dist\/)?/, ''));+}+function isOpenCodePluginEntrypoint(operation = {}) {- return /^\.opencode\/(?:dist\/)?plugins\/[^/]+\.(?:[cm]?js|ts)$/.test(- normalizeOperationPath(operation.sourceRelativePath)- );+ return getOpenCodeSourceActivationKind(operation) === 'plugin';}function getDisabledOpenCodePluginContent() {@@ -82,8 +94,7 @@ function getDisabledOpenCodePluginContent() {}function isOpenCodeHookActivationOperation(operation = {}) {- return normalizeOperationPath(operation.sourceRelativePath) === '.opencode/opencode.json'- || isOpenCodePluginEntrypoint(operation);+ return getOpenCodeSourceActivationKind(operation) !== null;}function isHookRuntimeOperation(operation = {}) {@@ -146,6 +157,9 @@ function withoutHookRuntimeId(values) {}function withoutOpenCodeHookActivation(operation) {+ if (getOpenCodeSourceActivationKind(operation) === 'package') {+ throw new Error(`Unsupported OpenCode package metadata deactivation: ${operation.sourceRelativePath}`);+ }if (!isOpenCodeHookActivationOperation(operation)|| operation.kind !== 'copy-file'@@ -310,6 +324,8 @@ module.exports = {disableUnselectedOpenCodeHooks,disableOpenCodeHookPluginRegistration,getDisabledOpenCodePluginContent,+ getOpenCodeActivationPathKind,+ getOpenCodeSourceActivationKind,formatHookCapabilityDisclosure,getRecordedHookConsent,isHookRuntimeOperation,diff --git a/scripts/lib/install/opencode-legacy-migration.js b/scripts/lib/install/opencode-legacy-migration.jsindex 485130eb4..ea704b6ea 100644--- a/scripts/lib/install/opencode-legacy-migration.js+++ b/scripts/lib/install/opencode-legacy-migration.js@@ -4,7 +4,7 @@ const crypto = require('crypto');const fs = require('fs');const path = require('path');-const { readInstallState } = require('../install-state');+const { readInstallState, validateInstallState } = require('../install-state');const { assertWithinTrustedRoot } = require('../path-safety');const OPENCODE_TARGET = 'opencode';@@ -65,10 +65,14 @@ function inspectLegacyOpencodeState(location) {return { status: 'absent', state: null, error: null };}try {- if (!pathExists(location.installStatePath)) {+ if (!pathExists(location.targetRoot)) {return { status: 'absent', state: null, error: null };}const rootStat = fs.lstatSync(location.targetRoot);+ if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {+ return { status: 'invalid', state: null, error: null };+ }+ if (!pathExists(location.installStatePath)) return { status: 'absent', state: null, error: null };const stateStat = fs.lstatSync(location.installStatePath);if (!rootStat.isDirectory()@@ -78,7 +82,11 @@ function inspectLegacyOpencodeState(location) {) {return { status: 'invalid', state: null, error: null };}- const state = readInstallState(location.installStatePath);+ const { content } = hashFileNoFollow(location.installStatePath);+ let state;+ try { state = JSON.parse(content.toString('utf8')); }+ catch { return { status: 'invalid', state: null, error: null }; }+ if (!validateInstallState(state).valid) return { status: 'invalid', state: null, error: null };const isOpencode = state.target.target === OPENCODE_TARGET|| state.target.id === 'opencode-home';if (@@ -98,17 +106,17 @@ function inspectLegacyOpencodeState(location) {}}-function hashFileNoFollow(filePath) {- const flags = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0);- const descriptor = fs.openSync(filePath, flags);+function hashFileNoFollow(filePath, fileSystem = fs) {+ const flags = fileSystem.constants.O_RDONLY | (fileSystem.constants.O_NOFOLLOW || 0);+ const descriptor = fileSystem.openSync(filePath, flags);try {- const before = fs.fstatSync(descriptor, { bigint: true });+ const before = fileSystem.fstatSync(descriptor, { bigint: true });if (!before.isFile()) {throw new Error(`Refusing to read a non-file at ${filePath}`);}- const content = fs.readFileSync(descriptor);- const after = fs.fstatSync(descriptor, { bigint: true });- const finalPathStat = fs.lstatSync(filePath, { bigint: true });+ const content = fileSystem.readFileSync(descriptor);+ const after = fileSystem.fstatSync(descriptor, { bigint: true });+ const finalPathStat = fileSystem.lstatSync(filePath, { bigint: true });const unchanged = before.dev === after.dev&& before.ino === after.ino&& before.size === after.size@@ -123,11 +131,12 @@ function hashFileNoFollow(filePath) {throw new Error(`Refusing to read a file that changed during validation: ${filePath}`);}return {+ content,digest: crypto.createHash('sha256').update(content).digest('hex'),stat: after,};} finally {- fs.closeSync(descriptor);+ fileSystem.closeSync(descriptor);}}@@ -202,7 +211,7 @@ function verifyManagedLegacyFile(operation, location, sourceRoot) {if (source.digest !== destination.digest) {return { retainedPath: destinationPath };}- return { destinationPath, stat: destination.stat };+ return { destinationPath, digest: destination.digest, stat: destination.stat };}function pathExistsWith(fileSystem, filePath) {@@ -257,6 +266,13 @@ function removeVerifiedLegacyFile(entry, location, fileSystem = fs) {identityError.code = 'ESTALE';throw identityError;}+ // Recheck bytes after quarantine: an in-place edit retains the same inode.+ // Production cleanup entries carry the digest verified against ledger/source.+ if (entry.digest && hashFileNoFollow(quarantinePath, fileSystem).digest !== entry.digest) {+ const changed = new Error(`Legacy OpenCode file changed during quarantine: ${safePath}`);+ changed.code = 'ESTALE';+ throw changed;+ }fileSystem.rmSync(quarantinePath);fileSystem.rmdirSync(quarantineDir);return true;@@ -396,4 +412,5 @@ module.exports = {getLegacyLocationForPlan,inspectLegacyOpencodeState,removeVerifiedLegacyFile,+ verifyManagedLegacyFile,};diff --git a/tests/lib/guarded-write.test.js b/tests/lib/guarded-write.test.jsindex 44e537e96..3f3e35cf1 100644--- a/tests/lib/guarded-write.test.js+++ b/tests/lib/guarded-write.test.js@@ -157,10 +157,16 @@ test('a parent replacement before native open is refused even when the file idenassert.strictEqual(typeof descriptor, 'number');assert.strictEqual(closes, 1);assert.strictEqual(truncates, 0);- const replacementIdentity = fs.statSync(file, { bigint: true });- assert.strictEqual(replacementIdentity.dev, fileIdentity.dev);- assert.strictEqual(replacementIdentity.ino, fileIdentity.ino);- assert.strictEqual(fs.readFileSync(file, 'utf8'), 'old activation bytes');+ const postconditionFd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));+ try {+ const replacementIdentity = fs.fstatSync(postconditionFd, { bigint: true });+ assert.ok(replacementIdentity.isFile());+ assert.strictEqual(replacementIdentity.dev, fileIdentity.dev);+ assert.strictEqual(replacementIdentity.ino, fileIdentity.ino);+ assert.strictEqual(fs.readFileSync(postconditionFd, 'utf8'), 'old activation bytes');+ } finally {+ fs.closeSync(postconditionFd);+ }assert.ok(fs.statSync(`${parent}.old`).isDirectory());});test('a denied native open preserves its cause without closing an unallocated descriptor', ({ file, options }) => {diff --git a/tests/lib/helpers/load-with-file-system.js b/tests/lib/helpers/load-with-file-system.jsnew file mode 100644index 000000000..b11d2a077--- /dev/null+++ b/tests/lib/helpers/load-with-file-system.js@@ -0,0 +1,44 @@+'use strict';++const fs = require('fs');+const path = require('path');+const Module = require('module');++// A private CommonJS graph for filesystem fault fixtures. Dependencies share+// this graph (including opaque lock identities), never the process module cache.+function createFileSystemLoader(fileSystem) {+ const sourceRoot = path.resolve(__dirname, '../../../scripts');+ const cache = new Map();+ function load(filename) {+ const absolute = path.resolve(filename);+ const relative = path.relative(sourceRoot, absolute);+ if (relative.startsWith('..') || path.isAbsolute(relative) || !absolute.endsWith('.js')) {+ throw new Error('Fixture loader requires a JavaScript module under scripts/');+ }+ if (cache.has(absolute)) return cache.get(absolute).exports;+ const child = new Module(absolute, module);+ child.filename = absolute;+ child.paths = Module._nodeModulePaths(path.dirname(absolute));+ const nativeRequire = Module.createRequire(absolute);+ child.require = request => {+ if (request === 'fs' || request === 'node:fs') return fileSystem;+ const resolved = nativeRequire.resolve(request);+ const dependency = path.relative(sourceRoot, resolved);+ if (path.isAbsolute(resolved) && !dependency.startsWith('..')+ && !path.isAbsolute(dependency) && resolved.endsWith('.js')) return load(resolved);+ return nativeRequire(request);+ };+ cache.set(absolute, child);+ try {+ child._compile(fs.readFileSync(absolute, 'utf8'), absolute);+ child.loaded = true;+ return child.exports;+ } catch (error) {+ cache.delete(absolute);+ throw error;+ }+ }+ return load;+}++module.exports = { createFileSystemLoader };diff --git a/tests/lib/hook-consent.test.js b/tests/lib/hook-consent.test.jsindex 691dbceaa..d802c5507 100644--- a/tests/lib/hook-consent.test.js+++ b/tests/lib/hook-consent.test.js@@ -11,6 +11,7 @@ const {formatHookCapabilityDisclosure,getRecordedHookConsent,isHookRuntimeOperation,+ isOpenCodePluginEntrypoint,planMaterializesHookRuntime,resolveHookConsentFlags,withHookConsent,@@ -202,6 +203,25 @@ function runTests() {assert.strictEqual(getRecordedHookConsent({ operations: [{ kind: 'update-claude-settings' }] }), 'enabled');})) passed++; else failed++;+ if (test('source classification covers nested JavaScript but refuses package metadata deactivation', () => {+ for (const extension of ['ts', 'js', 'mjs', 'cjs']) {+ for (const sourceRelativePath of [`.opencode/plugins/custom/index.${extension}`,+ `.OPENCODE\\DIST\\PLUGINS\\CUSTOM\\INDEX.${extension.toUpperCase()}`]) {+ const operation = { kind: 'copy-file', moduleId: 'platform-configs', sourceRelativePath };+ assert.strictEqual(isOpenCodePluginEntrypoint(operation), true, sourceRelativePath);+ const plan = withHookConsent({ target: 'opencode', operations: [operation], selectedModuleIds: [] });+ assert.strictEqual(plan.operations[0].contentTransform, 'opencode-disable-plugin-entrypoint');+ }+ }+ const operation = { kind: 'copy-file', sourceRelativePath: '.opencode/plugins/custom/package.json' };+ for (const decision of [null, 'declined']) {+ assert.throws(() => withHookConsent({ target: 'opencode', operations: [operation], selectedModuleIds: [] }, decision),+ /unsupported.*package/i);+ }+ assert.strictEqual(isOpenCodePluginEntrypoint(operation), false);+ assert.strictEqual(isOpenCodePluginEntrypoint({ sourceRelativePath: '.opencode/plugins/lib/utility.js' }), false);+ })) passed++; else failed++;+if (test('formats one numbered disclosure line per capability group', () => {const disclosure = formatHookCapabilityDisclosure();const lines = disclosure.split('\n');diff --git a/tests/lib/install-lifecycle.test.js b/tests/lib/install-lifecycle.test.jsindex 6a892797f..64290d842 100644--- a/tests/lib/install-lifecycle.test.js+++ b/tests/lib/install-lifecycle.test.js@@ -7,6 +7,7 @@ const crypto = require('crypto');const fs = require('fs');const os = require('os');const path = require('path');+const { createFileSystemLoader } = require('./helpers/load-with-file-system');const {buildDoctorReport,@@ -206,11 +207,11 @@ function writeOpencodeState(homeDir, overrides = {}) {};}-function writeRecordedOpenCodeActivation(homeDir) {+function writeRecordedOpenCodeActivation(homeDir, sourceRoot = REPO_ROOT) {const targetRoot = path.join(homeDir, '.config', 'opencode');const operations = ['opencode.json', 'plugins/ecc-hooks.ts', 'plugins/index.ts'].map(relativePath => {const sourceRelativePath = `.opencode/${relativePath}`;- const content = fs.readFileSync(path.join(REPO_ROOT, sourceRelativePath));+ const content = fs.readFileSync(path.join(sourceRoot, sourceRelativePath));const destinationPath = path.join(targetRoot, relativePath);fs.mkdirSync(path.dirname(destinationPath), { recursive: true });fs.writeFileSync(destinationPath, content);@@ -227,6 +228,32 @@ function writeRecordedOpenCodeActivation(homeDir) {});}+// These race fixtures read public source as inert bytes into a private source+// tree. Fake payload construction must never move/write repository build output.+function withPrivateOpenCodeSource(homeDir, callback) {+ const sourceRoot = path.join(homeDir, 'source');+ fs.mkdirSync(path.join(sourceRoot, 'manifests'), { recursive: true });+ const files = {+ 'package.json': { name: 'private-opencode-race-fixture', version: CURRENT_PACKAGE_VERSION },+ 'manifests/install-modules.json': { version: CURRENT_MANIFEST_VERSION, modules: [{+ id: 'platform-configs', kind: 'platform', description: 'Private race fixture.',+ paths: ['.opencode'], targets: ['opencode'], dependencies: [],+ defaultInstall: false, cost: 'light', stability: 'stable',+ }] },+ 'manifests/install-profiles.json': { version: 1, profiles: {} },+ 'manifests/install-components.json': { version: 1, components: [] },+ };+ for (const [relative, value] of Object.entries(files)) {+ fs.writeFileSync(path.join(sourceRoot, relative), formatJson(value));+ }+ for (const relative of ['opencode.json', 'plugins/ecc-hooks.ts', 'plugins/index.ts']) {+ const destination = path.join(sourceRoot, '.opencode', relative);+ fs.mkdirSync(path.dirname(destination), { recursive: true });+ fs.copyFileSync(path.join(REPO_ROOT, '.opencode', relative), destination);+ }+ callback(sourceRoot);+}+function withTemporarilyMovedPath(filePath, callback) {if (!fs.existsSync(filePath)) {try {@@ -2159,28 +2186,33 @@ function runTests() {if (test('OpenCode repair preserves activation bytes changed between health inspection and write', () => {const homeDir = createTempDir('install-lifecycle-opencode-health-race-');+ const fileSystem = { ...fs };+ const cacheEntry = require.cache[require.resolve('../../scripts/lib/install-lifecycle')];+ const isolatedRepair = createFileSystemLoader(fileSystem)(+ require.resolve('../../scripts/lib/install-lifecycle')+ ).repairInstalledStates;const originalOpenSync = fs.openSync;const originalReadFileSync = fs.readFileSync;const originalCloseSync = fs.closeSync;const descriptors = new Set();try {- withTemporarilyMovedPath(path.join(REPO_ROOT, '.opencode', 'dist'), () => {- const recorded = writeRecordedOpenCodeActivation(homeDir);+ withPrivateOpenCodeSource(homeDir, sourceRoot => {+ const recorded = writeRecordedOpenCodeActivation(homeDir, sourceRoot);const pluginPath = path.join(recorded.targetRoot, 'plugins', 'ecc-hooks.ts');const canonicalPluginPath = fs.realpathSync(pluginPath);const changedContent = 'globalThis.userChangedHook = true;\n';const stateBefore = fs.readFileSync(recorded.installStatePath);let changed = false;- fs.openSync = function trackActivationDescriptor(candidate, ...args) {+ fileSystem.openSync = function trackActivationDescriptor(candidate, ...args) {const descriptor = originalOpenSync.call(fs, candidate, ...args);if (typeof candidate === 'string' && [pluginPath, canonicalPluginPath].includes(path.resolve(candidate))) descriptors.add(descriptor);return descriptor;};- fs.closeSync = function releaseActivationDescriptor(descriptor) {+ fileSystem.closeSync = function releaseActivationDescriptor(descriptor) {descriptors.delete(descriptor);return originalCloseSync.call(fs, descriptor);};- fs.readFileSync = function mutateAfterHealthRead(candidate, ...args) {+ fileSystem.readFileSync = function mutateAfterHealthRead(candidate, ...args) {const content = originalReadFileSync.call(fs, candidate, ...args);// Lifecycle reads pass an encoding argument; the consent snapshot// reads the descriptor as raw bytes with no second argument.@@ -2192,8 +2224,8 @@ function runTests() {};let result;try {- result = repairInstalledStates({- repoRoot: REPO_ROOT, homeDir, projectRoot: homeDir, targets: ['opencode'],+ result = isolatedRepair({+ repoRoot: sourceRoot, homeDir, projectRoot: homeDir, targets: ['opencode'],buildOpencodePayload(repoRoot) {const distDir = path.join(repoRoot, '.opencode', 'dist');fs.mkdirSync(path.join(distDir, 'plugins'), { recursive: true });@@ -2202,9 +2234,9 @@ function runTests() {},});} finally {- fs.openSync = originalOpenSync;- fs.readFileSync = originalReadFileSync;- fs.closeSync = originalCloseSync;+ fileSystem.openSync = originalOpenSync;+ fileSystem.readFileSync = originalReadFileSync;+ fileSystem.closeSync = originalCloseSync;}assert.strictEqual(changed, true, 'The health-read boundary was exercised');assert.strictEqual(result.results[0].status, 'error');@@ -2219,39 +2251,48 @@ function runTests() {assert.notStrictEqual(result.results[0].stateRefreshed, true);});} finally {- fs.openSync = originalOpenSync;- fs.readFileSync = originalReadFileSync;- fs.closeSync = originalCloseSync;+ fileSystem.openSync = originalOpenSync;+ fileSystem.readFileSync = originalReadFileSync;+ fileSystem.closeSync = originalCloseSync;cleanup(homeDir);+ assert.strictEqual(descriptors.size, 0, 'Every tracked descriptor must close');+ assert.strictEqual(fs.openSync, originalOpenSync, 'Native fs must remain untouched');+ assert.strictEqual(fs.closeSync, originalCloseSync);+ assert.strictEqual(require.cache[require.resolve('../../scripts/lib/install-lifecycle')], cacheEntry);}})) passed++; else failed++;if (test('OpenCode repair rejects an active alias introduced during writes before refreshing state', () => {const homeDir = createTempDir('install-lifecycle-opencode-alias-race-');+ const fileSystem = { ...fs };+ const cacheEntry = require.cache[require.resolve('../../scripts/lib/install-lifecycle')];+ const isolatedRepair = createFileSystemLoader(fileSystem)(+ require.resolve('../../scripts/lib/install-lifecycle')+ ).repairInstalledStates;const originalOpenSync = fs.openSync;const originalWriteFileSync = fs.writeFileSync;const originalWriteSync = fs.writeSync;const originalCloseSync = fs.closeSync;const descriptors = new Set();try {- withTemporarilyMovedPath(path.join(REPO_ROOT, '.opencode', 'dist'), () => {- const recorded = writeRecordedOpenCodeActivation(homeDir);+ withPrivateOpenCodeSource(homeDir, sourceRoot => {+ const recorded = writeRecordedOpenCodeActivation(homeDir, sourceRoot);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 = fs.readFileSync(path.join(REPO_ROOT, '.opencode', 'plugins', 'index.ts'), 'utf8');+ const aliasContent = fs.readFileSync(path.join(sourceRoot, '.opencode', 'plugins', 'index.ts'), 'utf8');const stateBefore = fs.readFileSync(recorded.installStatePath);let inserted = false;- fs.openSync = function trackPluginWriteDescriptor(candidate, ...args) {+ fileSystem.openSync = function trackPluginWriteDescriptor(candidate, ...args) {const descriptor = originalOpenSync.call(fs, candidate, ...args);if (typeof candidate === 'string' && [pluginPath, canonicalPluginPath].includes(path.resolve(candidate))) descriptors.add(descriptor);return descriptor;};- fs.closeSync = function releasePluginWriteDescriptor(descriptor) {+ fileSystem.closeSync = function releasePluginWriteDescriptor(descriptor) {descriptors.delete(descriptor);return originalCloseSync.call(fs, descriptor);};- fs.writeSync = function insertAliasAfterPluginWrite(candidate, ...args) {+ fileSystem.writeSync = function insertAliasAfterPluginWrite(candidate, ...args) {const result = originalWriteSync.call(fs, candidate, ...args);if (!inserted && descriptors.has(candidate)) {inserted = true;@@ -2261,8 +2302,8 @@ function runTests() {};let result;try {- result = repairInstalledStates({- repoRoot: REPO_ROOT, homeDir, projectRoot: homeDir, targets: ['opencode'],+ result = isolatedRepair({+ repoRoot: sourceRoot, homeDir, projectRoot: homeDir, targets: ['opencode'],buildOpencodePayload(repoRoot) {const distDir = path.join(repoRoot, '.opencode', 'dist');fs.mkdirSync(path.join(distDir, 'plugins'), { recursive: true });@@ -2271,9 +2312,9 @@ function runTests() {},});} finally {- fs.openSync = originalOpenSync;- fs.writeSync = originalWriteSync;- fs.closeSync = originalCloseSync;+ fileSystem.openSync = originalOpenSync;+ fileSystem.writeSync = originalWriteSync;+ fileSystem.closeSync = originalCloseSync;}assert.strictEqual(inserted, true, 'The plugin-write boundary was exercised');assert.strictEqual(result.results[0].status, 'error');@@ -2285,10 +2326,14 @@ function runTests() {assert.notStrictEqual(result.results[0].stateRefreshed, true);});} finally {- fs.openSync = originalOpenSync;- fs.writeSync = originalWriteSync;- fs.closeSync = originalCloseSync;+ fileSystem.openSync = originalOpenSync;+ fileSystem.writeSync = originalWriteSync;+ fileSystem.closeSync = originalCloseSync;cleanup(homeDir);+ assert.strictEqual(descriptors.size, 0, 'Every tracked descriptor must close');+ assert.strictEqual(fs.openSync, originalOpenSync, 'Native fs must remain untouched');+ assert.strictEqual(fs.closeSync, originalCloseSync);+ assert.strictEqual(require.cache[require.resolve('../../scripts/lib/install-lifecycle')], cacheEntry);}})) passed++; else failed++;diff --git a/tests/lib/opencode-consent-legacy-lock.test.js b/tests/lib/opencode-consent-legacy-lock.test.jsindex 259e86b9f..a0baced47 100644--- a/tests/lib/opencode-consent-legacy-lock.test.js+++ b/tests/lib/opencode-consent-legacy-lock.test.js@@ -6,10 +6,14 @@ const crypto = require('crypto');const fs = require('fs');const os = require('os');const path = require('path');-const { applyInstallPlan } = require('../../scripts/lib/install/apply');-const { repairInstalledStates } = require('../../scripts/lib/install-lifecycle');+const { createFileSystemLoader } = require('./helpers/load-with-file-system');+const fileSystem = { ...fs };+const load = createFileSystemLoader(fileSystem);+const { applyInstallPlan } = load(require.resolve('../../scripts/lib/install/apply'));+const { withHookConsent } = require('../../scripts/lib/install/hook-consent');+const { repairInstalledStates, buildDoctorReport } = load(require.resolve('../../scripts/lib/install-lifecycle'));const { createInstallState, readInstallState, writeInstallState } = require('../../scripts/lib/install-state');-const { withOpenCodeInstallLocks } = require('../../scripts/lib/install/opencode-install-lock');+const { withOpenCodeInstallLocks } = load(require.resolve('../../scripts/lib/install/opencode-install-lock'));const SOURCE_RELATIVE_PATH = path.join('skills', 'skill-comply', 'SKILL.md');const SKILL_CONTENT = '---\nname: skill-comply\ndescription: Synthetic migration fixture.\n---\n\n# Inert fixture\n';@@ -131,6 +135,43 @@ function assertBothLocksReleased(value) {}}+function addLegacyActivations(value, consent = null) {+ const manifestPath = path.join(value.sourceRoot, 'manifests', 'install-modules.json');+ const manifest = JSON.parse(fs.readFileSync(manifestPath));+ manifest.modules.push({ id: 'platform-configs', kind: 'platform', description: 'Inert config fixture.',+ paths: ['.opencode'], targets: ['opencode'], dependencies: [], defaultInstall: false,+ cost: 'light', stability: 'stable' });+ writeJson(manifestPath, manifest);+ const state = readInstallState(value.legacyStatePath);+ state.request.modules.push('platform-configs');+ state.request.hookConsent = consent;+ state.resolution.selectedModules.push('platform-configs');+ for (const [relative, content] of [+ ['opencode.json', '{"plugin":["./plugins"],"userSetting":true}\n'],+ ['plugins/ecc-hooks.ts', 'export default async () => ({ "session.created": () => {} });\n'],+ ]) {+ const sourceRelativePath = `.opencode/${relative}`;+ const sourcePath = path.join(value.sourceRoot, sourceRelativePath);+ const destinationPath = path.join(value.legacyRoot, relative);+ for (const file of [sourcePath, destinationPath]) {+ fs.mkdirSync(path.dirname(file), { recursive: true });+ fs.writeFileSync(file, content);+ }+ state.operations.push({ kind: 'copy-file', moduleId: 'platform-configs', sourceRelativePath,+ destinationPath, ownership: 'managed', scaffoldOnly: false, strategy: 'preserve-relative-path',+ contentSha256: sha256(content) });+ }+ writeInstallState(value.legacyStatePath, state);+ return state;+}++function buildInertPayload(sourceRoot) {+ const dist = path.join(sourceRoot, '.opencode', 'dist');+ fs.mkdirSync(path.join(dist, 'plugins'), { recursive: true });+ fs.mkdirSync(path.join(dist, 'tools'), { recursive: true });+ fs.writeFileSync(path.join(dist, 'index.js'), 'module.exports = {};\n');+}+function runTests() {let passed = 0;let failed = 0;@@ -188,6 +229,161 @@ function runTests() {assertSourceUnchanged(value);assertBothLocksReleased(value);});+ for (const unrelated of ['directory', 'file', 'symlink', 'invalid-state', 'malformed-state', 'non-ECC-state']) {+ test(`canonical apply ignores an unrelated legacy ${unrelated} without locking it`, value => {+ fs.rmSync(value.legacyRoot, { recursive: true, force: true });+ if (unrelated === 'file') fs.writeFileSync(value.legacyRoot, 'user file');+ else if (unrelated === 'symlink') {+ fs.mkdirSync(value.canonicalRoot, { recursive: true });+ fs.symlinkSync(value.canonicalRoot, value.legacyRoot, process.platform === 'win32' ? 'junction' : 'dir');+ } else {+ fs.mkdirSync(value.legacyRoot, { recursive: true });+ if (unrelated === 'malformed-state') fs.writeFileSync(value.legacyStatePath, '{malformed');+ if (unrelated === 'invalid-state') writeJson(value.legacyStatePath, { unrelated: true });+ if (unrelated === 'non-ECC-state') {+ const state = { ...value.canonicalPlan.statePreview, target: { id: 'user-tool', target: 'user-tool',+ root: value.legacyRoot, installStatePath: value.legacyStatePath } };+ writeJson(value.legacyStatePath, state);+ }+ }+ const previousLedger = fs.existsSync(value.legacyStatePath)+ ? fs.readFileSync(value.legacyStatePath) : null;+ const original = fileSystem.openSync;+ let legacyLocks = 0;+ fileSystem.openSync = (candidate, ...args) => {+ if (typeof candidate === 'string' && candidate.startsWith(lockPath(value.legacyRoot))) { legacyLocks++; throw new Error('Unrelated legacy root must not be locked'); }+ return original(candidate, ...args);+ };+ try {+ const plan = withHookConsent({ ...value.canonicalPlan, operations: [],+ statePreview: { ...value.canonicalPlan.statePreview, operations: [] } });+ assert.strictEqual(applyInstallPlan(plan).applied, true);+ assert.strictEqual(legacyLocks, 0);+ if (previousLedger) assert.deepStrictEqual(fs.readFileSync(value.legacyStatePath), previousLedger);+ if (unrelated === 'file') assert.strictEqual(fs.readFileSync(value.legacyRoot, 'utf8'), 'user file');+ if (unrelated === 'symlink') assert.ok(fs.lstatSync(value.legacyRoot).isSymbolicLink());+ } finally { fileSystem.openSync = original; }+ assert.strictEqual(fs.existsSync(lockPath(value.canonicalRoot)), false);+ });+ }+ test('unreadable legacy ECC state remains an explicit failure before writes', value => {+ const original = fileSystem.openSync;+ let attempted = false;+ fileSystem.openSync = (candidate, ...args) => {+ if (candidate === value.legacyStatePath) {+ attempted = true;+ throw Object.assign(new Error('Synthetic unreadable legacy state'), { code: 'EACCES' });+ }+ return original(candidate, ...args);+ };+ try {+ assert.throws(() => applyInstallPlan(value.canonicalPlan), /Unable to inspect legacy/);+ assert.ok(attempted);+ assert.strictEqual(fs.existsSync(value.canonicalStatePath), false);+ } finally { fileSystem.openSync = original; }+ });+ for (const boundary of ['beforeInstallStateRead', 'beforeInstallStateWrite']) {+ test(`new valid legacy state at ${boundary} is never cleaned without its lock`, value => {+ const originalState = fs.readFileSync(value.legacyStatePath);+ fs.rmSync(value.legacyRoot, { recursive: true, force: true });+ let injected = false;+ assert.throws(() => applyInstallPlan(value.canonicalPlan, {+ [boundary]() {+ injected = true;+ fs.mkdirSync(path.dirname(value.legacyFile), { recursive: true });+ fs.writeFileSync(value.legacyFile, SKILL_CONTENT);+ fs.writeFileSync(value.legacyStatePath, originalState);+ },+ }), /lease does not cover/);+ assert.ok(injected);+ assert.deepStrictEqual(fs.readFileSync(value.legacyStatePath), originalState);+ assert.strictEqual(fs.readFileSync(value.legacyFile, 'utf8'), SKILL_CONTENT);+ assert.strictEqual(fs.existsSync(lockPath(value.canonicalRoot)), false);+ assert.strictEqual(fs.existsSync(lockPath(value.legacyRoot)), false);+ });+ }+ for (const consent of [null, 'declined']) {+ test(`verified active legacy copies migrate under ${consent || 'default'} consent with no hooks`, value => {+ addLegacyActivations(value, consent);+ const before = fs.readFileSync(value.legacyStatePath);+ const doctor = buildDoctorReport({ repoRoot: value.sourceRoot, homeDir: value.homeDir,+ projectRoot: value.homeDir, targets: ['opencode'], env: {} });+ assert.ok(doctor.results[0].issues.some(issue => issue.code === 'legacy-opencode-layout'));+ assert.ok(!doctor.results[0].issues.some(issue => issue.code === 'opencode-hook-consent-violation'));+ assert.deepStrictEqual(fs.readFileSync(value.legacyStatePath), before);+ let builds = 0;+ const result = repair(value, sourceRoot => {+ builds++;+ for (const target of [value.canonicalRoot, value.legacyRoot]) assert.ok(fs.existsSync(lockPath(target)));+ buildInertPayload(sourceRoot);+ });+ assert.strictEqual(result.results[0].status, 'repaired', JSON.stringify(result));+ assert.strictEqual(builds, 1);+ const state = readInstallState(value.canonicalStatePath);+ assert.ok(!state.resolution.selectedModules.includes('hooks-runtime'));+ assert.notStrictEqual(state.request.hookConsent, 'enabled');+ assert.strictEqual(fs.readFileSync(path.join(value.canonicalRoot, 'plugins/ecc-hooks.ts'), 'utf8'),+ 'export default async () => ({});\n');+ assert.deepStrictEqual(JSON.parse(fs.readFileSync(path.join(value.canonicalRoot, 'opencode.json'))).plugin, []);+ for (const relative of ['opencode.json', 'plugins/ecc-hooks.ts', 'ecc-install-state.json']) {+ assert.strictEqual(fs.existsSync(path.join(value.legacyRoot, relative)), false);+ }+ assertBothLocksReleased(value);+ });+ }+ for (const defect of ['modified', 'missing-digest', 'source-mismatch', 'source-missing', 'symlink', 'unrecorded-alias', 'merge-json']) {+ test(`legacy ${defect} activation refuses before build and preserves ownership`, value => {+ const state = addLegacyActivations(value);+ const plugin = path.join(value.legacyRoot, 'plugins/ecc-hooks.ts');+ const source = path.join(value.sourceRoot, '.opencode/plugins/ecc-hooks.ts');+ if (defect === 'modified') fs.writeFileSync(plugin, 'user edit\n');+ if (defect === 'missing-digest') delete state.operations[2].contentSha256;+ if (defect === 'source-mismatch') fs.writeFileSync(source, 'different trusted source\n');+ if (defect === 'source-missing') fs.unlinkSync(source);+ if (defect === 'symlink') { fs.unlinkSync(plugin); fs.symlinkSync(source, plugin); }+ if (defect === 'unrecorded-alias') fs.copyFileSync(source, path.join(value.legacyRoot, 'plugins/index.js'));+ if (defect === 'merge-json') state.operations[1].kind = 'merge-json';+ writeInstallState(value.legacyStatePath, state);+ const before = fs.readFileSync(value.legacyStatePath);+ let builds = 0;+ const result = repair(value, () => { builds++; throw new Error('Must refuse before build'); });+ assert.strictEqual(result.results[0].status, 'error', defect);+ assert.strictEqual(builds, 0);+ assert.deepStrictEqual(fs.readFileSync(value.legacyStatePath), before);+ assert.strictEqual(fs.existsSync(value.canonicalStatePath), false);+ assertBothLocksReleased(value);+ });+ }+ for (const failure of ['late-edit', 'remove-error', 'quarantine-edit']) {+ test(`legacy ${failure} never reports successful deactivation`, value => {+ addLegacyActivations(value);+ const plugin = path.join(value.legacyRoot, 'plugins/ecc-hooks.ts');+ const originalRename = fileSystem.renameSync;+ const before = fs.readFileSync(value.legacyStatePath);+ let failedRemoval = false;+ fileSystem.renameSync = (from, ...args) => {+ if (failure === 'remove-error' && from === plugin) {+ failedRemoval = true;+ throw Object.assign(new Error('Synthetic removal denial'), { code: 'EACCES' });+ }+ if (failure === 'quarantine-edit' && from === plugin) fs.writeFileSync(plugin, 'user edit at quarantine\n');+ return originalRename(from, ...args);+ };+ try {+ const result = repair(value, sourceRoot => {+ buildInertPayload(sourceRoot);+ if (failure === 'late-edit') fs.writeFileSync(plugin, 'user edit after preflight\n');+ });+ assert.strictEqual(result.results[0].status, 'error', JSON.stringify(result));+ assert.notStrictEqual(result.results[0].stateRefreshed, true);+ assert.deepStrictEqual(fs.readFileSync(value.legacyStatePath), before);+ if (failure === 'late-edit') assert.strictEqual(fs.readFileSync(plugin, 'utf8'), 'user edit after preflight\n');+ else if (failure === 'quarantine-edit') assert.strictEqual(fs.readFileSync(plugin, 'utf8'), 'user edit at quarantine\n');+ else assert.ok(failedRemoval, 'The actual cleanup removal was attempted');+ } finally { fileSystem.renameSync = originalRename; }+ assertBothLocksReleased(value);+ });+ }console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);return { passed, failed };}diff --git a/tests/lib/opencode-hook-consent-safety.test.js b/tests/lib/opencode-hook-consent-safety.test.jsindex 824ab5329..305242015 100644--- a/tests/lib/opencode-hook-consent-safety.test.js+++ b/tests/lib/opencode-hook-consent-safety.test.js@@ -5,10 +5,13 @@ const crypto = require('crypto');const fs = require('fs');const os = require('os');const path = require('path');-const { applyInstallPlan } = require('../../scripts/lib/install/apply');+const { createFileSystemLoader } = require('./helpers/load-with-file-system');+const fileSystem = { ...fs };+const load = createFileSystemLoader(fileSystem);+const { applyInstallPlan } = load(require.resolve('../../scripts/lib/install/apply'));const { withHookConsent } = require('../../scripts/lib/install/hook-consent');const { createInstallState, readInstallState, writeInstallState } = require('../../scripts/lib/install-state');-const { buildDoctorReport, repairInstalledStates } = require('../../scripts/lib/install-lifecycle');+const { buildDoctorReport, repairInstalledStates } = load(require.resolve('../../scripts/lib/install-lifecycle'));const REPO_ROOT = path.resolve(__dirname, '../..');const sha256 = value => crypto.createHash('sha256').update(value).digest('hex');@@ -98,8 +101,16 @@ function fixture(callback, enabled = false) {const basePlan = { target: 'opencode', adapter, homeDir, sourceRoot, targetRoot,installRoot: targetRoot, installStatePath, operations, warnings: [],selectedModuleIds: state.resolution.selectedModules, statePreview: state };- callback({ root, homeDir, sourceRoot, targetRoot, installStatePath, state, basePlan,- declinePlan: withHookConsent(basePlan, 'declined') });+ const previousCwd = process.cwd();+ try {+ // Hosted Windows checkouts and os.tmpdir() may be on different drives.+ // Anchor relative-root callers inside their private fixture on every OS.+ process.chdir(root);+ callback({ root, homeDir, sourceRoot, targetRoot, installStatePath, state, basePlan,+ declinePlan: withHookConsent(basePlan, 'declined') });+ } finally {+ process.chdir(previousCwd);+ }} finally {fs.rmSync(root, { recursive: true, force: true });}@@ -112,11 +123,11 @@ function repair(value, extra = {}) {}function withWritableOpenMutation(filePath, mutate, callback) {- const originalOpen = fs.openSync;- const originalClose = fs.closeSync;+ const originalOpen = fileSystem.openSync;+ const originalClose = fileSystem.closeSync;let injected = false;const descriptors = new Set();- fs.openSync = function (candidate, flags, ...rest) {+ fileSystem.openSync = function (candidate, flags, ...rest) {const writable = typeof flags === 'number'? Boolean(flags & (fs.constants.O_WRONLY | fs.constants.O_RDWR)): /[wa+]/.test(flags);@@ -129,7 +140,7 @@ function withWritableOpenMutation(filePath, mutate, callback) {if (matches && writable) descriptors.add(fd);return fd;};- fs.closeSync = function (fd) {+ fileSystem.closeSync = function (fd) {descriptors.delete(fd);return originalClose.call(fs, fd);};@@ -138,8 +149,8 @@ function withWritableOpenMutation(filePath, mutate, callback) {assert.ok(injected, 'The destination writable-open boundary must be exercised');assert.strictEqual(descriptors.size, 0, 'Every owned writable descriptor must close');} finally {- fs.openSync = originalOpen;- fs.closeSync = originalClose;+ fileSystem.openSync = originalOpen;+ fileSystem.closeSync = originalClose;}}@@ -158,6 +169,27 @@ function runTests() {try { callback(); passed++; console.log(` PASS ${name}`); }catch (error) { failed++; console.error(` FAIL ${name}: ${error.stack}`); }};+ test('relative-root fixture remains relative across Windows checkout and temp drives', () => {+ const source = 'C:\\private\\source';+ assert.strictEqual(path.win32.isAbsolute(path.win32.relative('D:\\checkout', source)), true);+ const relative = path.win32.relative('C:\\private', source);+ assert.strictEqual(relative, 'source');+ assert.strictEqual(path.win32.isAbsolute(relative), false);+ assert.strictEqual(path.win32.resolve('C:\\private', relative), source);+ });+ test('private filesystem injection never patches the process filesystem or module cache', () => fixture(value => {+ const nativeOpen = fs.openSync;+ const nativeClose = fs.closeSync;+ const cachedApply = require.cache[require.resolve('../../scripts/lib/install/apply')];+ const destination = path.join(value.targetRoot, 'plugins/ecc-hooks.ts');+ withWritableOpenMutation(destination, () => {+ assert.strictEqual(fs.openSync, nativeOpen);+ assert.strictEqual(fs.closeSync, nativeClose);+ }, () => assert.strictEqual(applyInstallPlan(value.declinePlan).applied, true));+ assert.strictEqual(fs.openSync, nativeOpen);+ assert.strictEqual(fs.closeSync, nativeClose);+ assert.strictEqual(require.cache[require.resolve('../../scripts/lib/install/apply')], cachedApply);+ }));for (const relativePath of ['plugins/ecc-hooks.ts', 'opencode.json']) {for (const mode of ['apply', 'repair']) {test(`${mode} preserves a same-inode ${relativePath} edit at writable open`, () => fixture(value => {@@ -366,6 +398,37 @@ function runTests() {});}));}+ for (const consent of [null, 'declined', 'enabled']) {+ test(`nested JavaScript entrypoint applies with ${consent || 'default'} consent semantics`, () => fixture(value => {+ const sourceRelativePath = '.opencode/plugins/custom/index.js';+ const sourcePath = path.join(value.sourceRoot, sourceRelativePath);+ const destinationPath = path.join(value.targetRoot, 'plugins/custom/index.js');+ const content = 'export default async () => ({ event: () => {} });\n';+ fs.mkdirSync(path.dirname(sourcePath), { recursive: true });+ fs.writeFileSync(sourcePath, content);+ const operation = { kind: 'copy-file', moduleId: 'platform-configs', sourceRelativePath,+ sourcePath, destinationPath, ownership: 'managed', scaffoldOnly: false };+ const selectedModuleIds = consent === 'enabled' ? ['platform-configs', 'hooks-runtime'] : ['platform-configs'];+ const plan = withHookConsent({ ...value.basePlan, selectedModuleIds,+ operations: [...value.basePlan.operations, operation] }, consent);+ assert.strictEqual(applyInstallPlan(plan).applied, true);+ assert.strictEqual(fs.readFileSync(destinationPath, 'utf8'), consent === 'enabled'+ ? content : 'export default async () => ({});\n');+ }));+ }+ test('nested package metadata fails before writing and never receives a JavaScript tombstone', () => fixture(value => {+ const destinationPath = path.join(value.targetRoot, 'plugins/custom/package.json');+ const sourcePath = path.join(value.sourceRoot, '.opencode/plugins/custom/package.json');+ fs.mkdirSync(path.dirname(sourcePath), { recursive: true });+ fs.writeFileSync(sourcePath, '{"main":"index.js"}\n');+ const before = fs.readFileSync(value.installStatePath);+ const operation = { kind: 'copy-file', sourceRelativePath: '.opencode/plugins/custom/package.json',+ sourcePath, destinationPath, ownership: 'managed' };+ assert.throws(() => applyInstallPlan(withHookConsent({ ...value.basePlan,+ operations: [...value.basePlan.operations, operation] }, 'declined')), /unsupported.*package/i);+ assert.strictEqual(fs.existsSync(destinationPath), false);+ assert.deepStrictEqual(fs.readFileSync(value.installStatePath), before);+ }));for (const rootForm of ['relative', 'missing']) {for (const consent of [null, 'declined']) {test(`${rootForm} source root keeps historical refusal for fresh ${consent || 'default'} apply`, () => fixture(value => {@@ -523,9 +586,9 @@ function runTests() {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;+ const originalOpen = fileSystem.openSync;let refusedReads = 0;- fs.openSync = function (candidate, ...args) {+ fileSystem.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' });@@ -537,7 +600,7 @@ function runTests() {else assert.strictEqual(applyInstallPlan(value.declinePlan).applied, true);assert.ok(refusedReads > 0, 'The permission boundary must be exercised');} finally {- fs.openSync = originalOpen;+ fileSystem.openSync = originalOpen;}assert.deepStrictEqual(fs.readFileSync(destination), content);if (!planned) assert.ok(!readInstallState(value.installStatePath).operations.some(operation => operation.destinationPath === destination));diff --git a/tests/lib/opencode-legacy-migration.test.js b/tests/lib/opencode-legacy-migration.test.jsindex 9cce6bff0..0a871336b 100644--- a/tests/lib/opencode-legacy-migration.test.js+++ b/tests/lib/opencode-legacy-migration.test.js@@ -118,7 +118,7 @@ function canonicalPlan(homeDir, env) {console.log('\n=== Testing OpenCode legacy migration ===\n');-test('legacy inspection distinguishes absent, invalid, and unreadable state', () => {+test('legacy inspection distinguishes absent and invalid state without claiming ownership', () => {const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencode-legacy-inspect-'));try {const location = getLegacyOpencodeLocation(homeDir);@@ -131,9 +131,9 @@ test('legacy inspection distinguishes absent, invalid, and unreadable state', ()fs.rmSync(location.installStatePath, { recursive: true, force: true });fs.writeFileSync(location.installStatePath, '{not-json', 'utf8');- const unreadable = inspectLegacyOpencodeState(location);- assert.strictEqual(unreadable.status, 'unreadable');- assert.ok(unreadable.error.includes(location.installStatePath));+ const malformed = inspectLegacyOpencodeState(location);+ assert.strictEqual(malformed.status, 'invalid');+ assert.strictEqual(malformed.error, null);assert.deepStrictEqual(cleanupLegacyOpencodeInstall(null), {detected: false,