-
+
-
clear
-
traffic advisory (transmit)
-
resolution advisory (steer)
+
●clear
+
■traffic advisory (transmit)
+
▲resolution advisory (steer)
+
Events
@@ -80,6 +83,9 @@ function renderControlPlaneViewHtml() {
var canvas = document.getElementById('c');
var ctx = canvas.getContext('2d');
var view = { tasks: [], lanes: [], pairs: [], events: [], projection: { agents: [] }, thresholds: { ta: 0.35, ra: 0.7 } };
+ // Last message handed to the live region, so a poll that changes nothing
+ // stays silent.
+ var lastSpoken = null;
function resize() {
var r = canvas.parentElement.getBoundingClientRect();
@@ -91,10 +97,35 @@ function renderControlPlaneViewHtml() {
}
window.addEventListener('resize', resize);
+ // The previous clear/resolution palette had similar relative luminance.
+ // Separate luminance values plus redundant shapes and text reduce reliance
+ // on hue; palette math alone does not establish a user's visual experience.
+ function riskLevel(risk) {
+ if (risk >= view.thresholds.ra) return 'resolution';
+ if (risk >= view.thresholds.ta) return 'traffic';
+ return 'clear';
+ }
+
function riskColor(risk) {
if (risk >= view.thresholds.ra) return '#ff7b72';
if (risk >= view.thresholds.ta) return '#e3b341';
- return '#3fb950';
+ return '#2ea043';
+ }
+
+ // Shape is the second, non-colour channel: circle / square / triangle.
+ function drawRiskMarker(x, y, radius, level) {
+ ctx.beginPath();
+ if (level === 'resolution') {
+ ctx.moveTo(x, y - radius);
+ ctx.lineTo(x + radius, y + radius);
+ ctx.lineTo(x - radius, y + radius);
+ ctx.closePath();
+ } else if (level === 'traffic') {
+ ctx.rect(x - radius, y - radius, radius * 2, radius * 2);
+ } else {
+ ctx.arc(x, y, radius, 0, Math.PI * 2);
+ }
+ ctx.fill();
}
// Fit the projected points into the canvas with a margin. The PCA scores
@@ -142,8 +173,9 @@ function renderControlPlaneViewHtml() {
var t = taskById[a.agentId] || {};
var files = (t.workingSet && t.workingSet.fileCount) || 1;
var radius = 6 + Math.sqrt(files) * 3;
- ctx.fillStyle = riskColor(a.maxRisk || 0);
- ctx.beginPath(); ctx.arc(p[0], p[1], radius, 0, Math.PI * 2); ctx.fill();
+ var risk = a.maxRisk || 0;
+ ctx.fillStyle = riskColor(risk);
+ drawRiskMarker(p[0], p[1], radius, riskLevel(risk));
ctx.fillStyle = '#c9d1d9';
ctx.font = '11px -apple-system, system-ui, sans-serif';
ctx.fillText(String(a.agentId).slice(0, 18), p[0] + radius + 4, p[1] + 3);
@@ -198,7 +230,9 @@ function renderControlPlaneViewHtml() {
var st = document.createElement('span'); st.textContent = t.harness + ' / ' + t.state + ' / ' + (t.workingSet.fileCount || 0) + ' files';
var risk = document.createElement('span'); risk.className = 'risk';
risk.style.color = riskColor(t.projection.maxRisk || 0);
- risk.textContent = t.projection.point ? Math.round((t.projection.maxRisk || 0) * 100) + '%' : 'no pair';
+ risk.textContent = (t.projection.point
+ ? Math.round((t.projection.maxRisk || 0) * 100) + '% - ' + riskLevel(t.projection.maxRisk || 0)
+ : 'no pair');
row.appendChild(idEl); row.appendChild(st); row.appendChild(risk);
el.appendChild(row);
});
@@ -206,6 +240,40 @@ function renderControlPlaneViewHtml() {
});
}
+ // Wording shared by the canvas label and the live region so an outage reads
+ // the same way however the operator reaches it.
+ var UNAVAILABLE = 'Control-plane data is unavailable. Advisories and steering are unknown.';
+ // Polls are not sequenced, so a slow request can settle out of order. Only
+ // the newest poll that has already settled may update the view: a success
+ // from a superseded poll would show older counts, and a failure from a
+ // superseded poll would erase newer counts. Anchoring to the last settled
+ // poll rather than the last started one also lets a failure land while a
+ // newer poll is still pending, instead of leaving stale guidance on screen.
+ var settledPoll = 0;
+ // Monotonic id handed to each poll as it starts.
+ var pollSeq = 0;
+ // A poll that never answers must not stay pending forever, or the last
+ // steering guidance stays on screen indefinitely.
+ var TIMEOUT_MS = 10000;
+
+ // Polling runs every few seconds, so only speak when the advisory and
+ // steering counts actually move. Repeating an unchanged summary would talk
+ // over the operator without telling them anything new.
+ function announce(message) {
+ if (message === lastSpoken) return;
+ lastSpoken = message;
+ document.getElementById('announce').textContent = message;
+ }
+
+ function unavailable() {
+ document.getElementById('status').textContent = 'offline';
+ // The last guidance is now stale, so replace it rather than leaving the
+ // live region claiming the airspace is clear. The canvas label goes with
+ // it, or it would still report the last successful counts.
+ canvas.setAttribute('aria-label', UNAVAILABLE);
+ announce(UNAVAILABLE);
+ }
+
function apply(data) {
if (!data || data.schemaVersion !== 'ecc.control-plane.view.v1' ||
!['tasks', 'lanes', 'pairs', 'events'].every(function (key) { return Array.isArray(data[key]); }) ||
@@ -213,22 +281,68 @@ function renderControlPlaneViewHtml() {
!Number.isFinite(data.thresholds.ta) || !Number.isFinite(data.thresholds.ra)) {
throw new Error('Invalid control-plane view');
}
+ var previous = view;
+ var drawStarted = false;
view = Object.assign({}, data);
- renderEvents(); renderLanes(); draw();
+ try {
+ renderEvents(); renderLanes();
+ drawStarted = true;
+ draw();
+ } catch (error) {
+ view = previous;
+ try {
+ renderEvents(); renderLanes();
+ if (drawStarted) draw();
+ } catch (_) {
+ // Keep the accepted model even if the DOM cannot be restored.
+ }
+ throw error;
+ }
var c = view.counts || {};
+ var summary = (c.tasks || 0) + ' tasks in ' + (c.lanes || 0) + ' lanes, ' +
+ (c.advisories || 0) + ' advisories, ' + (c.resolutions || 0) + ' steering. ' +
+ 'See the Lanes panel for per-task risk.';
+ canvas.setAttribute('aria-label', summary);
document.getElementById('status').textContent =
(c.tasks || 0) + ' tasks in ' + (c.lanes || 0) + ' lanes | ' + (c.agents || 0) + ' with edits | ' +
(c.advisories || 0) + ' advisories (' + (c.resolutions || 0) + ' steering)' +
(view.inventory && view.inventory.status !== 'ok' ? ' | inventory ' + view.inventory.status : '');
+
+ announce((c.advisories || 0) + ' advisories, ' +
+ (c.resolutions || 0) + ' steering. ' +
+ ((c.resolutions || 0) > 0 ? 'Steering is required.' : 'No steering is required.'));
}
function poll() {
- fetch('/api/control-plane').then(function (r) {
+ var token = ++pollSeq;
+ var timer = null;
+ var controller = new AbortController();
+ // Reject on a timer so a hung request cannot keep the previous guidance on
+ // screen forever. The abort is what wakes this poll up, so a timeout is
+ // reported as an outage rather than swallowed.
+ timer = setTimeout(function () { controller.abort(); }, TIMEOUT_MS);
+ // Claim before rendering or reporting failure: two JSON bodies may settle
+ // in the same turn, before a later cleanup continuation can run. Equality
+ // lets a render failure report unavailable for the token that just claimed.
+ function claim() {
+ if (token < settledPoll) return false;
+ settledPoll = token;
+ return true;
+ }
+ function settle() {
+ clearTimeout(timer);
+ }
+ fetch('/api/control-plane', { signal: controller.signal }).then(function (r) {
if (!r.ok) throw new Error('Control-plane request failed');
return r.json();
- }).then(apply).catch(function () {
- document.getElementById('status').textContent = 'offline';
- });
+ }).then(function (data) {
+ // A newer poll already owns the view, so do not resurrect older counts.
+ if (!claim()) return;
+ apply(data);
+ }).catch(function () {
+ if (!claim()) return;
+ unavailable();
+ }).then(settle, settle);
}
resize();
diff --git a/scripts/lib/control-pane/ui.js b/scripts/lib/control-pane/ui.js
index f7b0e069d..38573b291 100644
--- a/scripts/lib/control-pane/ui.js
+++ b/scripts/lib/control-pane/ui.js
@@ -410,7 +410,7 @@ function renderControlPaneHtml() {
diff --git a/scripts/lib/install-lifecycle.js b/scripts/lib/install-lifecycle.js
index 7da0ae78a..98abf8e20 100644
--- a/scripts/lib/install-lifecycle.js
+++ b/scripts/lib/install-lifecycle.js
@@ -10,8 +10,15 @@ const { readInstallState, validateInstallState } = require('./install-state');
const { assertWithinTrustedRoot } = require('./path-safety');
const { createInstallPlanFromRequest } = require('./install/runtime');
const { assertNoNewUserOwnedFile, prepareUserOwnedFileGuard } = require('./install/ownership-guard');
+const { writeFileNoFollow: guardedWriteFile } = require('./install/guarded-write');
+const { withOpenCodeInstallLocks } = require('./install/opencode-install-lock');
const { isCodexUserConfig } = require('./install/codex-user-config');
-const { getRecordedHookConsent } = require('./install/hook-consent');
+const {
+ disableOpenCodeHookPluginRegistration,
+ getDisabledOpenCodePluginContent,
+ getRecordedHookConsent,
+ withHookConsent,
+} = require('./install/hook-consent');
const {
prepareClaudeSkillMigration,
} = require('./install/claude-skill-migration');
@@ -232,6 +239,12 @@ function transformCopyFileContent(operation, content) {
if (operation.contentTransform === 'antigravity-agent-frontmatter') {
return adaptAntigravityAgent(content, operation.sourceRelativePath);
}
+ if (operation.contentTransform === 'opencode-disable-ecc-hooks') {
+ return disableOpenCodeHookPluginRegistration(content, operation.sourceRelativePath);
+ }
+ if (operation.contentTransform === 'opencode-disable-plugin-entrypoint') {
+ return getDisabledOpenCodePluginContent();
+ }
throw new Error(`Unknown install content transform: ${operation.contentTransform}`);
}
@@ -450,66 +463,15 @@ function createChangedDestinationError(action) {
);
}
-function getStableParentStat(filePath, action) {
- const parentStat = fs.lstatSync(path.dirname(filePath));
- if (!parentStat.isDirectory() || parentStat.isSymbolicLink()) {
- throw createChangedDestinationError(action);
- }
- return parentStat;
-}
-
-function assertPinnedWriteDestination(
- filePath,
- fileDescriptor,
- expectedParentStat,
- trustedRoot,
- action
-) {
- const liveDestination = getManagedDestination(filePath, trustedRoot, action);
- if (path.resolve(liveDestination.managedPath) !== path.resolve(filePath)) {
- throw createChangedDestinationError(action);
- }
-
- const liveParentStat = getStableParentStat(filePath, action);
- if (!hasSameFileIdentity(expectedParentStat, liveParentStat)) {
- throw createChangedDestinationError(action);
- }
-
- const descriptorStat = fs.fstatSync(fileDescriptor);
- const livePathStat = fs.lstatSync(liveDestination.managedPath);
- if (
- !descriptorStat.isFile()
- || !livePathStat.isFile()
- || livePathStat.isSymbolicLink()
- || !hasSameFileIdentity(descriptorStat, livePathStat)
- ) {
- throw createChangedDestinationError(action);
- }
-}
-
-function writeFileNoFollow(filePath, content, mode, trustedRoot, action) {
- const expectedParentStat = getStableParentStat(filePath, action);
- const flags = fs.constants.O_WRONLY
- | fs.constants.O_CREAT
- | (fs.constants.O_NOFOLLOW || 0);
- const fileDescriptor = fs.openSync(filePath, flags, mode);
-
- try {
- assertPinnedWriteDestination(
- filePath,
- fileDescriptor,
- expectedParentStat,
- trustedRoot,
- action
- );
- fs.ftruncateSync(fileDescriptor, 0);
- fs.writeFileSync(fileDescriptor, content);
- if (mode !== undefined) {
- fs.fchmodSync(fileDescriptor, mode);
- }
- } finally {
- fs.closeSync(fileDescriptor);
- }
+function writeFileNoFollow(filePath, content, mode, trustedRoot, action, writeOptions = {}) {
+ return guardedWriteFile(filePath, content, {
+ ...writeOptions,
+ mode,
+ action,
+ validateDestination(destinationPath) {
+ return getManagedDestination(destinationPath, trustedRoot, action).managedPath;
+ },
+ });
}
function readFileWithMetadataNoFollow(filePath, encoding) {
@@ -564,7 +526,7 @@ function assertClaudeSettingsDestination(operation, trustedRoot, target = null)
assertClaudeSettingsPath(operation.destinationPath, trustedRoot);
}
-function writeContainedFile(destinationPath, content, trustedRoot, action, mode) {
+function writeContainedFile(destinationPath, content, trustedRoot, action, mode, writeOptions) {
const preparedDestination = prepareContainedWriteDestination(destinationPath, trustedRoot, action);
const finalDestination = getManagedDestination(
preparedDestination,
@@ -576,7 +538,8 @@ function writeContainedFile(destinationPath, content, trustedRoot, action, mode)
content,
mode,
trustedRoot,
- action
+ action,
+ writeOptions
);
return finalDestination;
}
@@ -782,7 +745,8 @@ function executeRepairOperation(
trustedRoot,
linkIndex = null,
target = null,
- settingsLockHeld = false
+ settingsLockHeld = false,
+ writeOptions = {}
) {
// Install-state is attacker-controllable; never write/delete outside the
// adapter-derived trusted root, regardless of what the state file claims
@@ -800,7 +764,8 @@ function executeRepairOperation(
getExpectedCopyFileContent(operation, source.content, linkIndex),
trustedRoot,
'repair',
- source.mode & 0o777
+ source.mode & 0o777,
+ writeOptions
);
} else {
copyContainedFile(sourcePath, operation.destinationPath, trustedRoot, 'repair');
@@ -1179,7 +1144,11 @@ function inspectManagedOperation(repoRoot, trustedRoot, operation, linkIndex = n
let contentMatches;
try {
- contentMatches = hasRecordedContentDigest(operation)
+ // A deactivation transform changes the desired bytes. A historical
+ // active-file digest proves ownership, not completion of that transition.
+ const deactivatesOpenCode = operation.contentTransform === 'opencode-disable-ecc-hooks'
+ || operation.contentTransform === 'opencode-disable-plugin-entrypoint';
+ contentMatches = hasRecordedContentDigest(operation) && !deactivatesOpenCode
? fileMatchesRecordedContent(inspectedPath, operation)
: operation.contentTransform || isMarkdownPath(operation.destinationPath)
? readFileNoFollow(inspectedPath, 'utf8') === getExpectedCopyFileContent(
@@ -1629,6 +1598,24 @@ function analyzeRecord(record, context) {
};
}
+ let planningFailureReported = false;
+ if (record.adapter.target === 'opencode') {
+ let checks;
+ try {
+ checks = prepareOpenCodeHookDeactivationChecks(record, context, { requireInactive: true });
+ } catch (error) {
+ planningFailureReported = true;
+ issues.push(buildIssue('error', 'resolution-unavailable', error.message));
+ }
+ if (checks) {
+ try {
+ for (const check of checks) assertOpenCodeRepairHookDeactivation(check.plan, check.options);
+ } catch (error) {
+ issues.push(buildIssue('error', 'opencode-hook-consent-violation', error.message));
+ }
+ }
+ }
+
if (!fs.existsSync(state.target.root)) {
issues.push(buildIssue('error', 'missing-target-root', `Target root does not exist: ${state.target.root}`));
}
@@ -1731,7 +1718,7 @@ function analyzeRecord(record, context) {
issues.push(buildIssue('warning', 'repo-version-mismatch', `Recorded repo version ${state.source.repoVersion} differs from current repo version ${context.packageVersion}`));
}
- if (!state.request.legacyMode) {
+ if (!state.request.legacyMode && !planningFailureReported) {
try {
const desiredPlan = resolveRecordedManifestPlan(record, context);
@@ -1758,7 +1745,7 @@ function analyzeRecord(record, context) {
}
function buildDoctorReport(options = {}) {
- const repoRoot = options.repoRoot || DEFAULT_REPO_ROOT;
+ const repoRoot = options.repoRoot ? path.resolve(options.repoRoot) : DEFAULT_REPO_ROOT;
const manifests = loadInstallManifests({ repoRoot });
const records = discoverInstalledStates({
homeDir: options.homeDir,
@@ -1821,7 +1808,8 @@ function createRepairPlanFromRecord(record, context, options = {}) {
);
const statePreview = buildRecordedStatePreview(state, context, operations);
- return {
+ const recordedPlan = {
+ sourceRoot: context.repoRoot,
mode: state.request.legacyMode ? 'legacy' : 'recorded',
target: record.adapter.target,
adapter: record.adapter,
@@ -1830,9 +1818,13 @@ function createRepairPlanFromRecord(record, context, options = {}) {
installStatePath: state.target.installStatePath,
warnings: [],
languages: Array.isArray(state.request.legacyLanguages) ? [...state.request.legacyLanguages] : [],
+ selectedModuleIds: [...(state.resolution.selectedModules || [])],
operations,
statePreview
};
+ return record.adapter.target === 'opencode'
+ ? withHookConsent(recordedPlan, getRecordedHookConsent(state))
+ : recordedPlan;
}
const desiredPlan = resolveRecordedManifestPlan(record, context, options);
@@ -1882,8 +1874,11 @@ function writeRefreshedInstallState(record, statePreview, writtenPaths = []) {
return { ...operation };
}
// Refreshing a ledger is not a file write. Keep the last installed digest
- // for untouched shared configs so a concurrent user edit is never claimed.
- if (isCodexUserConfig(record, operation)
+ // for untouched shared configs and OpenCode activations so a concurrent
+ // user edit is never claimed, even by a partial repair checkpoint.
+ if ((isCodexUserConfig(record, operation)
+ || (record.adapter.target === 'opencode'
+ && require('./install/apply').getOpenCodeActivationKind(record, operation)))
&& !writtenPaths.some(writtenPath => path.relative(writtenPath, operation.destinationPath) === '')) {
const previousOperation = (record.state.operations || []).find(previous => (
previous.destinationPath
@@ -1923,10 +1918,13 @@ function prepareRepairMigration(plan, record) {
installStatePath: record.installStatePath,
statePreview: buildAdapterDerivedStatePreview(plan.statePreview, record),
};
- const skillMigration = prepareClaudeSkillMigration(trustedPlan);
- const migration = record.adapter.id === 'codex-home'
- ? prepareUserOwnedFileGuard(trustedPlan, skillMigration)
- : skillMigration;
+ const initialMigration = prepareClaudeSkillMigration(trustedPlan);
+ const guardedMigration = record.adapter.id === 'codex-home'
+ ? prepareUserOwnedFileGuard(trustedPlan, initialMigration)
+ : initialMigration;
+ const migration = trustedPlan.target === 'opencode'
+ ? require('./install/apply').prepareHookConsentMigration(trustedPlan, guardedMigration)
+ : guardedMigration;
return {
migration,
plan: {
@@ -1941,8 +1939,58 @@ function prepareRepairMigration(plan, record) {
};
}
+function assertOpenCodeRepairHookDeactivation(plan, options = {}) {
+ if (plan.target !== 'opencode') {
+ return new Map();
+ }
+ // The installer imports lifecycle helpers. Resolve this shared read-only
+ // guard lazily so both paths enforce the same discovery/ownership boundary.
+ const { assertOpenCodeHookDeactivationReady } = require('./install/apply');
+ return assertOpenCodeHookDeactivationReady(plan, options);
+}
+
+function prepareOpenCodeHookDeactivationChecks(record, context, options = {}) {
+ if (record.adapter.target !== 'opencode') {
+ return [];
+ }
+ const rawPlan = createRepairPlanFromRecord(record, context, {
+ // Planning must reject unsafe existing activations before a repair build
+ // writes compiled files. Missing payload is still validated/built later.
+ exemptValidationCodes: [OPENCODE_PLUGIN_NOT_BUILT_CODE],
+ });
+ if (record.legacyLayout === 'opencode') {
+ const state = record.state;
+ const legacyPlan = withHookConsent({
+ sourceRoot: context.repoRoot,
+ target: 'opencode',
+ adapter: record.adapter,
+ targetRoot: record.targetRoot,
+ installRoot: record.targetRoot,
+ installStatePath: record.installStatePath,
+ selectedModuleIds: [...(state.resolution.selectedModules || [])],
+ operations: getManagedOperations(state),
+ statePreview: buildAdapterDerivedStatePreview(state, record),
+ }, getRecordedHookConsent(state));
+ // 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.
+ return [
+ { plan: { ...legacyPlan, operations: [] }, options: { allowVerifiedLegacyRemoval: true } },
+ { plan: rawPlan, options },
+ ];
+ }
+ const { plan } = prepareRepairMigration(rawPlan, record);
+ return [{ plan, options }];
+}
+
+function preflightOpenCodeHookDeactivation(record, context, options = {}) {
+ for (const check of prepareOpenCodeHookDeactivationChecks(record, context, options)) {
+ assertOpenCodeRepairHookDeactivation(check.plan, check.options);
+ }
+}
+
function repairInstalledStates(options = {}) {
- const repoRoot = options.repoRoot || DEFAULT_REPO_ROOT;
+ const repoRoot = options.repoRoot ? path.resolve(options.repoRoot) : DEFAULT_REPO_ROOT;
const manifests = loadInstallManifests({ repoRoot });
const context = {
repoRoot,
@@ -1965,35 +2013,130 @@ function repairInstalledStates(options = {}) {
&& (!record.legacy || record.legacyLayout === 'opencode')
));
- const results = records.map(record => {
- if (record.error) {
- return {
- adapter: record.adapter,
- status: 'error',
- installStatePath: record.installStatePath,
- repairedPaths: [],
- plannedRepairs: [],
- error: record.error
- };
- }
-
- let releaseSettingsLock = null;
- try {
- const settingsPathToLock = !options.dryRun
- && getManagedOperations(record.state || {}).some(
- operation => operation.kind === 'update-claude-settings'
- )
- ? getClaudeSettingsPath(record.targetRoot)
- : null;
- if (settingsPathToLock) {
- releaseSettingsLock = acquireSettingsLock(settingsPathToLock);
+ const results = records.map(initialRecord => {
+ let record = initialRecord;
+ const performRepair = (opencodeLease) => {
+ if (record.error) {
+ return {
+ adapter: record.adapter,
+ status: 'error',
+ installStatePath: record.installStatePath,
+ repairedPaths: [],
+ plannedRepairs: [],
+ error: record.error
+ };
}
- const needsOpencodeBuild = record.adapter.target === 'opencode'
- && hasOpencodeBuildError(getOpencodeBuildValidationIssues(context));
- const opencodeBuildRepairPath = path.join(context.repoRoot, OPENCODE_BUILD_ARTIFACT);
- if (record.legacyLayout === 'opencode') {
- if (needsOpencodeBuild && !options.dryRun) {
+ let releaseSettingsLock = null;
+ try {
+ preflightOpenCodeHookDeactivation(record, context);
+ const settingsPathToLock = !options.dryRun
+ && getManagedOperations(record.state || {}).some(
+ operation => operation.kind === 'update-claude-settings'
+ )
+ ? getClaudeSettingsPath(record.targetRoot)
+ : null;
+ if (settingsPathToLock) {
+ releaseSettingsLock = acquireSettingsLock(settingsPathToLock);
+ }
+ const needsOpencodeBuild = record.adapter.target === 'opencode'
+ && hasOpencodeBuildError(getOpencodeBuildValidationIssues(context));
+ const opencodeBuildRepairPath = path.join(context.repoRoot, OPENCODE_BUILD_ARTIFACT);
+
+ if (record.legacyLayout === 'opencode') {
+ if (needsOpencodeBuild && !options.dryRun) {
+ try {
+ buildOpencodeRunner(context.repoRoot);
+ } catch (error) {
+ return {
+ adapter: record.adapter,
+ status: 'error',
+ installStatePath: record.installStatePath,
+ repairedPaths: [],
+ plannedRepairs: [],
+ error: formatBuildErrorMessage(error),
+ };
+ }
+ }
+
+ const canonicalPlan = createRepairPlanFromRecord(record, context, {
+ exemptValidationCodes: options.dryRun && needsOpencodeBuild
+ ? [OPENCODE_PLUGIN_NOT_BUILT_CODE]
+ : [],
+ });
+ assertOpenCodeRepairHookDeactivation(canonicalPlan);
+ const plannedRepairs = [...new Set([
+ ...(needsOpencodeBuild ? [opencodeBuildRepairPath] : []),
+ ...canonicalPlan.operations.map(operation => operation.destinationPath),
+ ...getManagedOperations(record.state).map(operation => operation.destinationPath),
+ record.installStatePath,
+ ])];
+
+ if (options.dryRun) {
+ return {
+ adapter: record.adapter,
+ status: 'planned',
+ installStatePath: canonicalPlan.installStatePath,
+ repairedPaths: [],
+ plannedRepairs,
+ stateRefreshed: false,
+ warnings: canonicalPlan.warnings,
+ error: null,
+ };
+ }
+
+ // Load lazily to avoid a module cycle during install-lifecycle startup.
+ const { applyInstallPlan } = require('./install/apply');
+ const appliedPlan = applyInstallPlan(canonicalPlan, { opencodeLease });
+ return {
+ adapter: record.adapter,
+ status: 'repaired',
+ installStatePath: canonicalPlan.installStatePath,
+ repairedPaths: [
+ ...(needsOpencodeBuild ? [opencodeBuildRepairPath] : []),
+ ...canonicalPlan.operations.map(operation => operation.destinationPath),
+ ],
+ plannedRepairs: [],
+ stateRefreshed: true,
+ warnings: appliedPlan.warnings,
+ error: null,
+ };
+ }
+
+ if (needsOpencodeBuild && options.dryRun) {
+ const rawPlan = createRepairPlanFromRecord(record, context, {
+ exemptValidationCodes: [OPENCODE_PLUGIN_NOT_BUILT_CODE],
+ });
+ const { plan: desiredPlan } = prepareRepairMigration(rawPlan, record);
+ const operationHealth = summarizeManagedOperationHealth(
+ context.repoRoot,
+ record.targetRoot,
+ desiredPlan.operations,
+ record.adapter.target
+ );
+ const unsafeOperationResult = getUnsafeOperationResult(
+ record,
+ operationHealth
+ );
+ if (unsafeOperationResult) {
+ return unsafeOperationResult;
+ }
+ const repairOperations = [...operationHealth.missing.map(entry => ({ ...entry.operation })), ...operationHealth.drifted.map(entry => ({ ...entry.operation }))];
+ const plannedRepairs = [opencodeBuildRepairPath, ...repairOperations.map(operation => operation.destinationPath)];
+
+ return {
+ adapter: record.adapter,
+ status: 'planned',
+ installStatePath: record.installStatePath,
+ repairedPaths: [],
+ plannedRepairs,
+ stateRefreshed: false,
+ warnings: desiredPlan.warnings,
+ error: null
+ };
+ }
+
+ if (needsOpencodeBuild) {
try {
buildOpencodeRunner(context.repoRoot);
} catch (error) {
@@ -2003,65 +2146,24 @@ function repairInstalledStates(options = {}) {
installStatePath: record.installStatePath,
repairedPaths: [],
plannedRepairs: [],
- error: formatBuildErrorMessage(error),
+ error: formatBuildErrorMessage(error)
};
}
}
- const canonicalPlan = createRepairPlanFromRecord(record, context, {
- exemptValidationCodes: options.dryRun && needsOpencodeBuild
- ? [OPENCODE_PLUGIN_NOT_BUILT_CODE]
- : [],
- });
- const plannedRepairs = [...new Set([
- ...(needsOpencodeBuild ? [opencodeBuildRepairPath] : []),
- ...canonicalPlan.operations.map(operation => operation.destinationPath),
- ...getManagedOperations(record.state).map(operation => operation.destinationPath),
- record.installStatePath,
- ])];
-
- if (options.dryRun) {
- return {
- adapter: record.adapter,
- status: 'planned',
- installStatePath: canonicalPlan.installStatePath,
- repairedPaths: [],
- plannedRepairs,
- stateRefreshed: false,
- warnings: canonicalPlan.warnings,
- error: null,
- };
- }
-
- // Load lazily to avoid a module cycle during install-lifecycle startup.
- const { applyInstallPlan } = require('./install/apply');
- const appliedPlan = applyInstallPlan(canonicalPlan);
- return {
- adapter: record.adapter,
- status: 'repaired',
- installStatePath: canonicalPlan.installStatePath,
- repairedPaths: [
- ...(needsOpencodeBuild ? [opencodeBuildRepairPath] : []),
- ...canonicalPlan.operations.map(operation => operation.destinationPath),
- ],
- plannedRepairs: [],
- stateRefreshed: true,
- warnings: appliedPlan.warnings,
- error: null,
- };
- }
-
- if (needsOpencodeBuild && options.dryRun) {
- const rawPlan = createRepairPlanFromRecord(record, context, {
- exemptValidationCodes: [OPENCODE_PLUGIN_NOT_BUILT_CODE],
- });
- const { plan: desiredPlan } = prepareRepairMigration(rawPlan, record);
+ const rawPlan = createRepairPlanFromRecord(record, context);
+ const {
+ migration,
+ plan: desiredPlan,
+ } = prepareRepairMigration(rawPlan, record);
+ const activationSnapshot = assertOpenCodeRepairHookDeactivation(desiredPlan);
const operationHealth = summarizeManagedOperationHealth(
context.repoRoot,
record.targetRoot,
desiredPlan.operations,
record.adapter.target
);
+
const unsafeOperationResult = getUnsafeOperationResult(
record,
operationHealth
@@ -2069,175 +2171,169 @@ function repairInstalledStates(options = {}) {
if (unsafeOperationResult) {
return unsafeOperationResult;
}
- const repairOperations = [...operationHealth.missing.map(entry => ({ ...entry.operation })), ...operationHealth.drifted.map(entry => ({ ...entry.operation }))];
- const plannedRepairs = [opencodeBuildRepairPath, ...repairOperations.map(operation => operation.destinationPath)];
- return {
- adapter: record.adapter,
- status: 'planned',
- installStatePath: record.installStatePath,
- repairedPaths: [],
- plannedRepairs,
- stateRefreshed: false,
- warnings: desiredPlan.warnings,
- error: null
- };
- }
-
- if (needsOpencodeBuild) {
- try {
- buildOpencodeRunner(context.repoRoot);
- } catch (error) {
+ if (operationHealth.missingSource.length > 0) {
return {
adapter: record.adapter,
status: 'error',
installStatePath: record.installStatePath,
repairedPaths: [],
plannedRepairs: [],
- error: formatBuildErrorMessage(error)
+ warnings: desiredPlan.warnings,
+ error: `Missing source file(s): ${operationHealth.missingSource.map(entry => entry.sourcePath).join(', ')}`
};
}
- }
- const rawPlan = createRepairPlanFromRecord(record, context);
- const {
- migration,
- plan: desiredPlan,
- } = prepareRepairMigration(rawPlan, record);
- const operationHealth = summarizeManagedOperationHealth(
- context.repoRoot,
- record.targetRoot,
- desiredPlan.operations,
- record.adapter.target
- );
+ const repairOperations = [
+ ...operationHealth.missing.map(entry => ({ ...entry.operation })),
+ ...operationHealth.drifted.map(entry => ({ ...entry.operation })),
+ ...desiredPlan.operations
+ .filter(operation => (
+ operation.kind === 'update-claude-settings'
+ && operation.previousManagedHooks
+ && !isDeepStrictEqual(operation.previousManagedHooks, operation.managedHooks)
+ ))
+ .map(operation => ({ ...operation })),
+ ].filter((operation, index, items) => items.findIndex(candidate => (
+ candidate.kind === operation.kind
+ && candidate.destinationPath === operation.destinationPath
+ )) === index);
+ const repairLinkIndex = buildLinkIndexForOperations(desiredPlan.operations, record.targetRoot);
+ const legacyMigrationPaths = migration.legacyOperationsToRemove.map(
+ operation => operation.destinationPath
+ );
+ const plannedRepairs = [...new Set([
+ ...(needsOpencodeBuild ? [opencodeBuildRepairPath] : []),
+ ...repairOperations.map(operation => operation.destinationPath),
+ ...legacyMigrationPaths,
+ ])];
- const unsafeOperationResult = getUnsafeOperationResult(
- record,
- operationHealth
- );
- if (unsafeOperationResult) {
- return unsafeOperationResult;
- }
+ if (options.dryRun) {
+ return {
+ adapter: record.adapter,
+ status: plannedRepairs.length > 0 ? 'planned' : 'ok',
+ installStatePath: record.installStatePath,
+ repairedPaths: [],
+ plannedRepairs,
+ stateRefreshed: plannedRepairs.length === 0,
+ warnings: desiredPlan.warnings,
+ error: null
+ };
+ }
- if (operationHealth.missingSource.length > 0) {
+ const hasLegacyMigration = migration.legacyOperationsToRemove.length > 0;
+ const repairedPaths = needsOpencodeBuild ? [opencodeBuildRepairPath] : [];
+ if (desiredPlan.target === 'opencode') {
+ const { assertOpenCodeActivationUnchanged } = require('./install/apply');
+ // Health inspection must not let a changed activation become owned by
+ // a bridge checkpoint before the per-write check can reject it.
+ for (const destinationPath of activationSnapshot.keys()) {
+ assertOpenCodeActivationUnchanged(desiredPlan, { destinationPath }, activationSnapshot);
+ }
+ }
+ if (migration.requiresBridgeState && (repairOperations.length > 0 || hasLegacyMigration)) {
+ writeRefreshedInstallState(record, migration.bridgeState);
+ }
+
+ for (const operation of repairOperations) {
+ if (desiredPlan.target === 'opencode') {
+ const { assertOpenCodeActivationUnchanged } = require('./install/apply');
+ assertOpenCodeActivationUnchanged(desiredPlan, operation, activationSnapshot);
+ }
+ if (record.adapter.id === 'codex-home') {
+ assertNoNewUserOwnedFile(migration, operation, desiredPlan);
+ }
+ const repairedPath = executeRepairOperation(
+ context.repoRoot,
+ operation,
+ record.targetRoot,
+ repairLinkIndex,
+ record.adapter.target,
+ Boolean(releaseSettingsLock),
+ require('./install/apply').getOpenCodeActivationWriteOptions(operation, activationSnapshot)
+ );
+ if (repairedPath) {
+ repairedPaths.push(repairedPath);
+ }
+ }
+ if (hasLegacyMigration) {
+ for (const operation of migration.legacyOperationsToRemove) {
+ const removedPath = removeContainedPath(
+ operation.destinationPath,
+ record.targetRoot,
+ 'migrate managed Claude skill',
+ { force: true }
+ );
+ if (removedPath) {
+ repairedPaths.push(removedPath);
+ }
+ }
+ }
+ const changedInstalledBytes = repairOperations.length > 0
+ || needsOpencodeBuild
+ || hasLegacyMigration;
+ const statePreviewToWrite = changedInstalledBytes
+ ? desiredPlan.statePreview
+ : {
+ ...desiredPlan.statePreview,
+ installedAt: record.state.installedAt,
+ source: { ...record.state.source },
+ };
+ assertOpenCodeRepairHookDeactivation(desiredPlan, { requireInactive: true });
+ writeRefreshedInstallState(record, statePreviewToWrite, repairedPaths);
+
+ return {
+ adapter: record.adapter,
+ status: (repairOperations.length > 0 || needsOpencodeBuild || hasLegacyMigration)
+ ? 'repaired'
+ : 'ok',
+ installStatePath: record.installStatePath,
+ repairedPaths,
+ plannedRepairs: [],
+ stateRefreshed: true,
+ warnings: desiredPlan.warnings,
+ error: null
+ };
+ } catch (error) {
return {
adapter: record.adapter,
status: 'error',
installStatePath: record.installStatePath,
repairedPaths: [],
plannedRepairs: [],
- warnings: desiredPlan.warnings,
- error: `Missing source file(s): ${operationHealth.missingSource.map(entry => entry.sourcePath).join(', ')}`
+ error: error.message
};
+ } finally {
+ if (releaseSettingsLock) releaseSettingsLock();
}
-
- const repairOperations = [
- ...operationHealth.missing.map(entry => ({ ...entry.operation })),
- ...operationHealth.drifted.map(entry => ({ ...entry.operation })),
- ...desiredPlan.operations
- .filter(operation => (
- operation.kind === 'update-claude-settings'
- && operation.previousManagedHooks
- && !isDeepStrictEqual(operation.previousManagedHooks, operation.managedHooks)
- ))
- .map(operation => ({ ...operation })),
- ].filter((operation, index, items) => items.findIndex(candidate => (
- candidate.kind === operation.kind
- && candidate.destinationPath === operation.destinationPath
- )) === index);
- const repairLinkIndex = buildLinkIndexForOperations(desiredPlan.operations, record.targetRoot);
- const legacyMigrationPaths = migration.legacyOperationsToRemove.map(
- operation => operation.destinationPath
- );
- const plannedRepairs = [...new Set([
- ...(needsOpencodeBuild ? [opencodeBuildRepairPath] : []),
- ...repairOperations.map(operation => operation.destinationPath),
- ...legacyMigrationPaths,
- ])];
-
- if (options.dryRun) {
- return {
- adapter: record.adapter,
- status: plannedRepairs.length > 0 ? 'planned' : 'ok',
- installStatePath: record.installStatePath,
- repairedPaths: [],
- plannedRepairs,
- stateRefreshed: plannedRepairs.length === 0,
- warnings: desiredPlan.warnings,
- error: null
- };
- }
-
- const hasLegacyMigration = migration.legacyOperationsToRemove.length > 0;
- const repairedPaths = needsOpencodeBuild ? [opencodeBuildRepairPath] : [];
- if (migration.requiresBridgeState && (repairOperations.length > 0 || hasLegacyMigration)) {
- writeRefreshedInstallState(record, migration.bridgeState);
- }
-
- for (const operation of repairOperations) {
- if (record.adapter.id === 'codex-home') {
- assertNoNewUserOwnedFile(migration, operation, desiredPlan);
+ };
+ if (record.adapter.target !== 'opencode' || options.dryRun) return performRepair();
+ let repairResult;
+ try {
+ const adapter = getInstallTargetAdapter('opencode');
+ const targetRoot = adapter.resolveRoot({
+ homeDir: context.homeDir, projectRoot: context.projectRoot,
+ repoRoot: context.projectRoot, env: context.env,
+ });
+ 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);
+ if (!record.exists || record.error) {
+ throw new Error(record.error || 'OpenCode install-state disappeared before repair.');
}
- const repairedPath = executeRepairOperation(
- context.repoRoot,
- operation,
- record.targetRoot,
- repairLinkIndex,
- record.adapter.target,
- Boolean(releaseSettingsLock)
- );
- if (repairedPath) {
- repairedPaths.push(repairedPath);
- }
- }
- if (hasLegacyMigration) {
- for (const operation of migration.legacyOperationsToRemove) {
- const removedPath = removeContainedPath(
- operation.destinationPath,
- record.targetRoot,
- 'migrate managed Claude skill',
- { force: true }
- );
- if (removedPath) {
- repairedPaths.push(removedPath);
- }
- }
- }
- const changedInstalledBytes = repairOperations.length > 0
- || needsOpencodeBuild
- || hasLegacyMigration;
- const statePreviewToWrite = changedInstalledBytes
- ? desiredPlan.statePreview
- : {
- ...desiredPlan.statePreview,
- installedAt: record.state.installedAt,
- source: { ...record.state.source },
- };
- writeRefreshedInstallState(record, statePreviewToWrite, repairedPaths);
-
- return {
- adapter: record.adapter,
- status: (repairOperations.length > 0 || needsOpencodeBuild || hasLegacyMigration)
- ? 'repaired'
- : 'ok',
- installStatePath: record.installStatePath,
- repairedPaths,
- plannedRepairs: [],
- stateRefreshed: true,
- warnings: desiredPlan.warnings,
- error: null
- };
+ repairResult = performRepair(lease);
+ return repairResult;
+ });
} catch (error) {
- return {
- adapter: record.adapter,
- status: 'error',
- installStatePath: record.installStatePath,
- repairedPaths: [],
- plannedRepairs: [],
- error: error.message
- };
- } finally {
- if (releaseSettingsLock) releaseSettingsLock();
+ if (repairResult?.status === 'error') {
+ return { ...repairResult, releaseError: error.message };
+ }
+ return { adapter: record.adapter, status: 'error', installStatePath: record.installStatePath,
+ repairedPaths: repairResult?.repairedPaths || [], plannedRepairs: [], error: error.message };
}
});
diff --git a/scripts/lib/install-manifests.js b/scripts/lib/install-manifests.js
index bb16cc93c..6d0fac5cf 100644
--- a/scripts/lib/install-manifests.js
+++ b/scripts/lib/install-manifests.js
@@ -15,7 +15,7 @@ const COMPONENT_FAMILY_PREFIXES = {
skill: 'skill:',
locale: 'locale:',
};
-const SUPPORTED_LOCALES = Object.freeze(['ja', 'zh-CN', 'ko-KR', 'pt-BR', 'ru', 'tr', 'vi-VN', 'zh-TW', 'de-DE', 'uk-UA']);
+const SUPPORTED_LOCALES = Object.freeze(['ja', 'zh-CN', 'ko-KR', 'pt-BR', 'ru', 'tr', 'vi-VN', 'zh-TW', 'de-DE', 'uk-UA', 'pl']);
const LOCALE_ALIAS_TO_COMPONENT_ID = Object.freeze({
'ja': 'locale:ja',
'ja-JP': 'locale:ja',
@@ -33,7 +33,9 @@ const LOCALE_ALIAS_TO_COMPONENT_ID = Object.freeze({
'de-DE': 'locale:de-de',
'de': 'locale:de-de',
'uk-UA': 'locale:uk-ua',
- 'uk': 'locale:uk-ua'
+ 'uk': 'locale:uk-ua',
+ 'pl': 'locale:pl',
+ 'pl-PL': 'locale:pl'
});
function listSupportedLocales() {
diff --git a/scripts/lib/install/apply.js b/scripts/lib/install/apply.js
index 1776cb6ca..209e53784 100644
--- a/scripts/lib/install/apply.js
+++ b/scripts/lib/install/apply.js
@@ -9,7 +9,16 @@ const {
withCommitAttributionDisabled,
} = require('../claude-commit-attribution');
const { readInstallState, writeInstallState } = require('../install-state');
-const { assertHookConsentReady, planMaterializesHookRuntime } = require('./hook-consent');
+const {
+ assertHookConsentReady,
+ disableOpenCodeHookPluginRegistration,
+ getDisabledOpenCodePluginContent,
+ getRecordedHookConsent,
+ getOpenCodeActivationPathKind,
+ getOpenCodeSourceActivationKind,
+ planMaterializesHookRuntime,
+ shouldDisableOpenCodeHooks,
+} = require('./hook-consent');
const {
getClaudeSettingsPath,
mergeManagedHooks,
@@ -33,7 +42,10 @@ const {
prepareUserOwnedFileGuard,
preserveUnwrittenFiles,
} = require('./ownership-guard');
-const { cleanupLegacyOpencodeInstall } = 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 {
completeExcludedPathsReconciliation,
prepareExcludedPathsReconciliation,
@@ -52,6 +64,12 @@ function transformInstallContent(operation, content) {
if (operation.contentTransform === 'antigravity-agent-frontmatter') {
return adaptAntigravityAgent(content, operation.sourceRelativePath);
}
+ if (operation.contentTransform === 'opencode-disable-ecc-hooks') {
+ return disableOpenCodeHookPluginRegistration(content, operation.sourceRelativePath);
+ }
+ if (operation.contentTransform === 'opencode-disable-plugin-entrypoint') {
+ return getDisabledOpenCodePluginContent();
+ }
throw new Error(`Unknown install content transform: ${operation.contentTransform}`);
}
@@ -292,6 +310,254 @@ function comparablePath(filePath) {
return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
}
+function getOpenCodeActivationKind(plan, operation) {
+ const relative = operation.destinationPath
+ ? path.relative(plan.targetRoot, operation.destinationPath).split(path.sep).join('/').toLowerCase()
+ : '';
+ return getOpenCodeActivationPathKind(relative) || getOpenCodeSourceActivationKind(operation);
+}
+
+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;
+ }
+}
+
+// Finite, exact public ECC entrypoint history reachable from d3b8a3e908904e242ed2dbe66af62cca71131419.
+// Refusal evidence only: matching bytes never grant ownership or permission to
+// adopt, rewrite or delete an unrecorded file. Unknown modified/compiled variants
+// are not covered. No history lookup or plugin execution occurs at runtime.
+const LEGACY_OPENCODE_PLUGIN_DIGESTS = Object.freeze([
+ // a0600a00fbe3a193a44584ad55800ce82cec62af:.opencode/plugins/index.ts (blob 3a98f0ba6510d436cc9cf3e2161f8f69771d968a)
+ '7dd2d255da5d4344eb38ca93cf1765e425b0c01943f6e45428614662ebee0d4b',
+ // a0600a00fbe3a193a44584ad55800ce82cec62af:.opencode/plugins/ecc-hooks.ts (blob bf06c03f8ff6bdd835c5266921758a6db85152bf)
+ '5db9b59434af0d5971538f0176779733b8146d7a71fbd9055ae0183c26754068',
+ // 91ba9b4cf6c47c8130829004f8bb64762a76ccbb:.opencode/plugins/ecc-hooks.ts (blob 4aabde61203d4473e04d5a10803b0560b8c596e4)
+ 'c683b9321d8b5fbc6889b1740f4583c4f94c84554ee97e2072f61de45c661bda',
+ // 1a8beb71c5282ddfe77c72ab0290961a820e3d89:.opencode/plugins/ecc-hooks.ts (blob 69b59727e552991a79c196aab8ec128173329d9a)
+ '1e890ce162325c9d7c579b0716383b6c297179edb78084c4b59cc8bf766ceb71',
+ // e65f12bf7ea474a6f5ac96991a251673f474b445:.opencode/plugins/index.ts (blob c1e17a1595403080490fcec6820c1485bb6afba9)
+ '965c5fac76ce0c3ceb3836814f5eb9ede8c9db50373a508c734f949cb321a21a',
+ // e65f12bf7ea474a6f5ac96991a251673f474b445:.opencode/plugins/ecc-hooks.ts (blob 54881ad868c276ff0d50cc83d8ae938464ad02da)
+ '5c043b84693a654fffe4b407e87411b28c9af8b92f5ef49a03caab7b27f03102',
+ // 2cdc218c45a81ce46035832b13bf68d91137301e:.opencode/plugins/ecc-hooks.ts (blob d496e61a538131ff6f33b2e6d941544e3d94c5d8)
+ '73692e599d271bbb9b7aac59f97e193518af2b5db3a3505af0376c8d8657220a',
+ // 5929d246946eeb5d147612ba06d60c575c5a4e21:.opencode/plugins/ecc-hooks.ts (blob 472f80f5ae9500fa9a0a7885b6ce4dc4b409d3d6)
+ 'd7a410380ed2e0bcb613110b2810221d03a8944e50766bc7a4db2eb1b44446b6',
+ // ca185ef5f7667078a1e70a763bd3a9c71c48acf0:.opencode/plugins/ecc-hooks.ts (blob 22b1132f0964bd4ba5c1a4ad1bafa605de99eb6a)
+ '0345093b34e537d350c5b5aa0296511f558aa767e5104fb5ef05069013f3b5b6',
+ // 28e53a0bc10e286f68b53bb1e3b3f049021e57b9:.opencode/plugins/ecc-hooks.ts (blob 47265c0ebd031168d8e3a18f30036864338cd22c)
+ 'e20ecd53714b1fd55baeff796c6f4538ebd4bae71ca1e791b2b8e29575061846',
+ // 591ab5cbd3f2f65860ea91c226e410b1502c8e2e:.opencode/plugins/ecc-hooks.ts (blob 49124c255003eb5517178a8ecad7dd453303df33)
+ 'b9c22c76ae2464c9410963579ee5ff49003e4d79e32b69c228539ae7b15f5104',
+ // 6f452d48d258b39f4f6e1171b7ca18c6f7f61ad5:.opencode/plugins/ecc-hooks.ts (blob 6336081e97c4345f02adfdc0b9ad9e27dccdec04)
+ 'c7122565cf97b896cc3da9009bf06daca7513b3e9ba7448c26b8872591dbf3f7',
+ // 3a08b0c7a85bda69ee9922a103e077a04d538150:.opencode/plugins/ecc-hooks.ts (blob bad6a4cecf2270a7d8a919daeb6541c94a810c48)
+ 'e438603c13206365068b400063df0af98bd587842b80f09b97fe57f7ddef56e0',
+ // 29edd57708bee26f16363c16a28fec7f6b09f53f:.opencode/plugins/ecc-hooks.ts (blob 05792ce9ae86a785b746bdb843572e4b5bc93130)
+ '6a9063b2f67334a78d269d53f95679c33d6d126260f8e5fc7cc941fea9b903e8',
+ // 8141f6904f14fa8a83131e1cb5b6507d687e25bb:.opencode/plugins/ecc-hooks.ts (blob 606bcb7c59aa5e459d2093ffb9cf9208d1184c30)
+ 'a198b640fd1faf1c75e96909eabf4ae24899de127b2447490eed813766013836',
+ // 6d613f67dd24189a8bb7fb1a2f5e535957f46a58:.opencode/plugins/index.ts (blob ca58596901d816147ac4eff525f1a885d36bd094)
+ 'e89aaa309b7a0578bb69af4a2425744fcf14c2556cd34a1036bbcba448a0b517',
+ // 6d613f67dd24189a8bb7fb1a2f5e535957f46a58:.opencode/plugins/ecc-hooks.ts (blob 31cfa8ac31ac3cbc5c51b4b275017ef18b8f9033)
+ 'd66a43e43ef9669589de593e8f94e750ee11d3c75cb5fe79e81636ef738c3e45',
+ // affbd334858368518c5baf5f84f74034dea1ea6f:.opencode/plugins/ecc-hooks.ts (blob ff8628b5fd47181cbee54367dc4e32e5392cde1a)
+ '4874a12639fd58da59a54fe5b2461c0ddd2eeca6770111615caa402ff0e95693',
+ // 0a87323eda77ee412fa3a3bf028a577536966505:.opencode/plugins/ecc-hooks.ts (blob fa96b805685e3c3e6f86535debca5ab8a5bea1ef)
+ '4e2330f340e074208cd323c1a833667032ce8db4febc4eaeda354bc49cb58bc4',
+ // a0a1eda8fc4828e58dc8aabcec4e25f9ef038a0a:.opencode/plugins/ecc-hooks.ts (blob 51bde010b4d426676b52ffc9567b1da80f4ca510)
+ 'ca9abadee5d072121677168752fb4f3b16ce9fc7eb55a3c9c7f517377e0bf69b',
+ // 05acc275307a09eea89080619a35d7dbd20b128b:.opencode/plugins/ecc-hooks.ts (blob 9e4ab3fcd50f6610cfdfa5a7d0d71c2374f65745)
+ '96998990d6aac0b9535ab6ab60a0be1c284ffcca7e4ba04f1cfa0e67409a8146',
+ // a2b3cc1600e9cab58147ef01c03f9889b5a8cc86:.opencode/plugins/ecc-hooks.ts (blob 58a209283f70efe1dbfef5d78b4d72764c67f027)
+ '0697bfed6e6ad887443a32810e83adb5316d2c9c0490b98f9fcb6ea52bea84e3',
+ // 0c7deb26a344db095c04a213eba5634d4ccce030:.opencode/plugins/ecc-hooks.ts (blob 9193bb412920a1f1d5af98fda0a66d1e3295f46f)
+ 'd666a94e9d0ccbcfdeffd59b624938cd44706571eec3771974c57fdbe28577c1',
+ // 48b883d7412914b04c8b185d9a82685b105d1734:.opencode/plugins/ecc-hooks.ts (blob 3053314750a61dbcdb06a9cca39492304457f582)
+ '16fe21ca801a613a0ae2fc1f8dd5c8474138dc31c75ea35cd8695884397f1f15',
+ // d70bab85e33af7a03b78c70dba7a7ce3b01d1b17:.opencode/plugins/ecc-hooks.ts (blob 1f158d7999f5f100e386587a94a90a08d512e278)
+ '0354270a5fc26809d0795ecc7eef1dee91de4905d58f26d5828d43af24767b96',
+ // 0e9f613fd196f6d4157765b17d39c2c42ebbf564:.opencode/plugins/ecc-hooks.ts (blob 50d23bfde3607832446fda26b25a3ed3e527e5d1)
+ '513190b6c935dac472efd11818b20d7f2479ec1f7be06ef7f4d241c2493ad9e3',
+ // 6d440c036df2c1b2fec957627d1202c3708e0627:.opencode/plugins/index.ts (blob d19a91f1a686d6ed060d08eddeb5aa05a4be6b75)
+ 'e42c733adb177f84cea813663aa34c7868dbaa98c96950d0ef91cd211b8aa169',
+ // 6d440c036df2c1b2fec957627d1202c3708e0627:.opencode/plugins/ecc-hooks.ts (blob b64ffae7ce10cab9e5ed9b04cec23d62db9036e7)
+ '503ea491cbeadff5bf59b936a75bff65caaf1d71e47a953a9b9b790be780efef',
+]);
+
+function knownOpenCodePluginDigests(plan) {
+ // Historical refusal fingerprints do not depend on a current source checkout.
+ const digests = new Set(LEGACY_OPENCODE_PLUGIN_DIGESTS);
+ 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]) {
+ if (getOpenCodeActivationKind(plan, operation) && operation.destinationPath) {
+ candidates.set(comparablePath(operation.destinationPath), operation);
+ }
+ }
+ // 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)) {
+ 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,
+ });
+ }
+ }
+ }
+ }
+ return candidates;
+}
+
+function activationIsInactive(kind, operation, content) {
+ if (kind === 'plugin') {
+ return content.toString('utf8') === getDisabledOpenCodePluginContent();
+ }
+ const text = content.toString('utf8');
+ // Validate first so malformed JSON retains its source context.
+ disableOpenCodeHookPluginRegistration(text, operation.sourceRelativePath || operation.destinationPath);
+ const config = JSON.parse(text);
+ return !Array.isArray(config.plugin) || !config.plugin.includes('./plugins');
+}
+
+function assertOpenCodeHookDeactivationReady(plan, options = {}) {
+ if (!shouldDisableOpenCodeHooks(plan)) {
+ return new Map();
+ }
+ assertSafeInstallOperation(plan, { destinationPath: plan.installStatePath });
+ const previousState = readPreviousInstallState(plan);
+ if (previousState && (
+ previousState.target.id !== plan.adapter.id
+ || comparablePath(previousState.target.root) !== comparablePath(plan.targetRoot)
+ || comparablePath(previousState.target.installStatePath) !== comparablePath(plan.installStatePath)
+ )) {
+ throw new Error('Refusing OpenCode hook deactivation: install-state target mismatch.');
+ }
+ const previous = new Map(((previousState && previousState.operations) || [])
+ .filter(operation => operation.ownership === 'managed' && operation.destinationPath)
+ .map(operation => [comparablePath(operation.destinationPath), operation]));
+ 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(), ...(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);
+ // Validate planned activation even when its destination does not yet exist.
+ // Recorded operations may name an unrelated source or use render-template.
+ if (replacement && (replacement.kind !== 'copy-file'
+ || replacement.contentTransform !== expectedTransform)) {
+ throw new Error(`Refusing OpenCode hook deactivation: unsupported activation operation at ${operation.destinationPath}`);
+ }
+ const content = readInstalledFileNoFollow(plan, operation);
+ if (content === null && fs.existsSync(operation.destinationPath)) {
+ throw new Error(`Refusing OpenCode hook deactivation: non-file activation at ${operation.destinationPath}`);
+ }
+ const digest = content === null ? null : crypto.createHash('sha256').update(content).digest('hex');
+ snapshot.set(key, digest);
+ if (content === null) continue;
+ const inactive = activationIsInactive(kind, operation, content);
+ if (options.requireInactive) {
+ if (!inactive) {
+ throw new Error(`OpenCode hook activation remains active at ${operation.destinationPath}`);
+ }
+ continue;
+ }
+ const recorded = previous.get(key);
+ if (inactive && (kind === 'plugin' || options.allowVerifiedLegacyRemoval || !recorded)) continue;
+ 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) {
+ throw new Error(`Refusing OpenCode hook deactivation: user-owned, modified, unverifiable or stale activation at ${operation.destinationPath}`);
+ }
+ }
+ return snapshot;
+}
+
+function assertOpenCodeActivationUnchanged(plan, operation, snapshot) {
+ const key = comparablePath(operation.destinationPath);
+ if (!snapshot.has(key)) return;
+ const content = readInstalledFileNoFollow(plan, operation);
+ const digest = content === null ? null : crypto.createHash('sha256').update(content).digest('hex');
+ if (digest !== snapshot.get(key)) {
+ throw new Error(`Refusing OpenCode hook deactivation: activation changed after preflight at ${operation.destinationPath}`);
+ }
+}
+
+function getOpenCodeActivationWriteOptions(operation, snapshot) {
+ const key = comparablePath(operation.destinationPath);
+ if (!snapshot.has(key)) return {};
+ const digest = snapshot.get(key);
+ return { expectedContent: Object.freeze(digest === null
+ ? { kind: 'absent' } : { kind: 'sha256', digest }) };
+}
+
+function getOpenCodeInstallRoots(plan) {
+ const roots = [plan.targetRoot];
+ const legacy = getLegacyLocationForPlan(plan);
+ 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
@@ -347,6 +613,27 @@ function preflightClaudeSettingsOperations(plan) {
}
function prepareHookConsentMigration(plan, migration) {
+ if (shouldDisableOpenCodeHooks(plan) && migration.requiresBridgeState) {
+ const previousState = readPreviousInstallState(plan);
+ if (previousState) {
+ const previousConsent = getRecordedHookConsent(previousState);
+ return {
+ ...migration,
+ // A checkpoint is not a completed consent transition. On failure,
+ // retain the previous decision until every activation is inactive.
+ bridgeState: {
+ ...migration.bridgeState,
+ request: { ...migration.bridgeState.request, hookConsent: previousConsent },
+ resolution: {
+ ...migration.bridgeState.resolution,
+ selectedModules: previousConsent === 'enabled'
+ ? [...new Set([...migration.bridgeState.resolution.selectedModules, 'hooks-runtime'])]
+ : migration.bridgeState.resolution.selectedModules,
+ },
+ },
+ };
+ }
+ }
if (plan.hookConsent !== 'declined') {
return migration;
}
@@ -400,6 +687,7 @@ function prepareHookConsentMigration(plan, migration) {
}
function previewInstallPlan(plan) {
+ assertOpenCodeHookDeactivationReady(plan);
const migration = prepareHookConsentMigration(
plan,
prepareUserOwnedFileGuard(plan, prepareClaudeSkillMigration(plan))
@@ -429,6 +717,14 @@ function previewInstallPlan(plan) {
function applyInstallPlan(plan, dependencies = {}) {
assertHookConsentReady(plan);
+ if (plan.adapter?.target === 'opencode') {
+ assertSafeInstallOperation(plan, { destinationPath: plan.installStatePath });
+ return withOpenCodeInstallLocks(
+ getOpenCodeInstallRoots(plan),
+ lease => applyInstallPlanLocked(plan, { ...dependencies, opencodeLease: lease }, false),
+ dependencies.opencodeLease
+ );
+ }
const isClaudeManualTarget = plan.adapter
&& (plan.adapter.target === 'claude' || plan.adapter.target === 'claude-project');
const settingsPathToLock = isClaudeManualTarget
@@ -453,6 +749,9 @@ function applyInstallPlanLocked(plan, dependencies = {}, settingsLockHeld = fals
if (typeof beforeInstallStateRead === 'function') {
beforeInstallStateRead({ plan });
}
+ assertOpenCodeLeaseCoverage(plan, dependencies.opencodeLease);
+ const legacyActivation = inspectLegacyOpenCodeDeactivation(plan);
+ const activationSnapshot = assertOpenCodeHookDeactivationReady(plan);
const migration = prepareExcludedPathsReconciliation(
plan,
prepareHookConsentMigration(
@@ -499,6 +798,7 @@ function applyInstallPlanLocked(plan, dependencies = {}, settingsLockHeld = fals
beforeOperationWrite({ plan: appliedPlan, operation });
}
assertNoNewUserOwnedFile(migration, operation, appliedPlan);
+ assertOpenCodeActivationUnchanged(appliedPlan, operation, activationSnapshot);
if (
operation.kind === 'update-claude-settings'
@@ -585,7 +885,20 @@ function applyInstallPlanLocked(plan, dependencies = {}, settingsLockHeld = fals
index: linkIndex,
})
: transformed;
- fs.writeFileSync(operation.destinationPath, installedContent, 'utf8');
+ const writeOptions = getOpenCodeActivationWriteOptions(operation, activationSnapshot);
+ if (writeOptions.expectedContent) {
+ writeFileNoFollow(operation.destinationPath, installedContent, {
+ ...writeOptions,
+ action: 'install OpenCode activation',
+ validateDestination(destinationPath) {
+ assertSafeInstallOperation(appliedPlan, { destinationPath });
+ assertSafeClaudeSkillOperation(appliedPlan, { destinationPath });
+ return destinationPath;
+ },
+ });
+ } else {
+ fs.writeFileSync(operation.destinationPath, installedContent, 'utf8');
+ }
writtenDestinations.add(operation.destinationPath);
continue;
}
@@ -605,6 +918,9 @@ function applyInstallPlanLocked(plan, dependencies = {}, settingsLockHeld = fals
);
}
+ // Include preserved user configs omitted from the write plan: they must
+ // still be inactive before we record a completed install.
+ assertOpenCodeHookDeactivationReady(plan, { requireInactive: true });
finalState = stateWithContentDigests(migration.finalState, appliedPlan);
if (typeof beforeInstallStateWrite === 'function') {
beforeInstallStateWrite({ plan: appliedPlan, state: finalState });
@@ -658,6 +974,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);
@@ -673,6 +992,12 @@ function applyInstallPlanLocked(plan, dependencies = {}, settingsLockHeld = fals
];
}
+ if (legacyActivation) {
+ assertOpenCodeHookDeactivationReady(legacyActivation.plan, {
+ requireInactive: true, legacyOperations: legacyActivation.operations,
+ });
+ }
+
let excludedPathsRemoved = [];
let excludedPathsWarnings = [];
try {
@@ -705,6 +1030,13 @@ function applyInstallPlanLocked(plan, dependencies = {}, settingsLockHeld = fals
module.exports = {
applyInstallPlan,
+ assertOpenCodeActivationUnchanged,
+ assertOpenCodeLeaseCoverage,
+ assertOpenCodeHookDeactivationReady,
+ getOpenCodeActivationKind,
+ getOpenCodeActivationWriteOptions,
+ getOpenCodeInstallRoots,
assertSafeInstallOperation,
+ prepareHookConsentMigration,
previewInstallPlan,
};
diff --git a/scripts/lib/install/claude-settings-lock.js b/scripts/lib/install/claude-settings-lock.js
index 75aa6a4f0..164e887ec 100644
--- a/scripts/lib/install/claude-settings-lock.js
+++ b/scripts/lib/install/claude-settings-lock.js
@@ -5,6 +5,7 @@ const fs = require('fs');
const path = require('path');
const INVALID_LOCK_STALE_MS = 5 * 60 * 1000;
+const acquiredLockIdentities = new WeakMap();
function sameFileIdentity(left, right) {
if (left.ino !== right.ino) {
@@ -19,7 +20,7 @@ function sameFileIdentity(left, right) {
return left.dev === right.dev;
}
-function createSettingsLock(lockPath) {
+function createSettingsLock(lockPath, label = 'Claude settings') {
const tempPath = `${lockPath}.create-${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
let descriptor;
let ownedStats;
@@ -43,18 +44,28 @@ function createSettingsLock(lockPath) {
fs.rmSync(tempPath, { force: true });
let released = false;
- return () => {
+ const release = () => {
if (released) return;
const quarantinePath = `${lockPath}.release-${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
fs.renameSync(lockPath, quarantinePath);
const quarantinedStats = fs.lstatSync(quarantinePath, { bigint: true });
if (!sameFileIdentity(quarantinedStats, ownedStats)) {
if (!fs.existsSync(lockPath)) fs.renameSync(quarantinePath, lockPath);
- throw new Error(`Refusing to release a changed Claude settings lock: ${lockPath}`);
+ throw new Error(`Refusing to release a changed ${label} lock: ${lockPath}`);
}
released = true;
fs.rmSync(quarantinePath, { force: true });
};
+ // Retain the identity observed through the creation descriptor. A pathname
+ // sampled after publication may already refer to a replacement lock.
+ acquiredLockIdentities.set(release, Object.freeze({ dev: ownedStats.dev, ino: ownedStats.ino }));
+ return release;
+}
+
+function getSettingsLockIdentity(release) {
+ const identity = acquiredLockIdentities.get(release);
+ if (!identity) throw new Error('No acquired settings lock identity for this release function.');
+ return identity;
}
function inspectSettingsLock(lockPath) {
@@ -91,7 +102,7 @@ function processIsAlive(pid) {
}
}
-function recoverSettingsLock(lockPath) {
+function recoverSettingsLock(lockPath, label = 'Claude settings') {
const recoveryPath = `${lockPath}.recover`;
try {
fs.mkdirSync(recoveryPath, { mode: 0o700 });
@@ -106,7 +117,7 @@ function recoverSettingsLock(lockPath) {
try {
inspected = inspectSettingsLock(lockPath);
} catch (error) {
- if (error && error.code === 'ENOENT') return createSettingsLock(lockPath);
+ if (error && error.code === 'ENOENT') return createSettingsLock(lockPath, label);
throw error;
}
const validOwner = Number.isSafeInteger(inspected.metadata && inspected.metadata.pid)
@@ -123,27 +134,27 @@ function recoverSettingsLock(lockPath) {
return null;
}
fs.rmSync(quarantinePath, { force: true });
- return createSettingsLock(lockPath);
+ return createSettingsLock(lockPath, label);
} finally {
fs.rmSync(recoveryPath, { recursive: true, force: true });
fs.rmSync(quarantinePath, { force: true });
}
}
-function acquireSettingsLock(settingsPath) {
+function acquireSettingsLock(settingsPath, { label = 'Claude settings' } = {}) {
const lockPath = `${settingsPath}.ecc.lock`;
fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
try {
- return createSettingsLock(lockPath);
+ return createSettingsLock(lockPath, label);
} catch (error) {
if (!error || error.code !== 'EEXIST') {
throw error;
}
}
- const recovered = recoverSettingsLock(lockPath);
+ const recovered = recoverSettingsLock(lockPath, label);
if (recovered) return recovered;
throw new Error(
- `Another ECC process is updating Claude settings: ${settingsPath}. `
+ `Another ECC process is updating ${label}: ${settingsPath}. `
+ `If no ECC process is active, inspect and remove ${lockPath}.`
);
}
@@ -175,6 +186,7 @@ function runWithSettingsLock(settingsPath, callback) {
module.exports = {
acquireSettingsLock,
+ getSettingsLockIdentity,
runWithSettingsLock,
sameFileIdentity,
};
diff --git a/scripts/lib/install/config.js b/scripts/lib/install/config.js
index 32c1b47a9..ae723a2fc 100644
--- a/scripts/lib/install/config.js
+++ b/scripts/lib/install/config.js
@@ -10,7 +10,9 @@ let cachedValidator = null;
function readJson(filePath, label) {
try {
- return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+ // Windows PowerShell 5.1 writes a BOM with Set-Content -Encoding UTF8.
+ const content = fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '');
+ return JSON.parse(content);
} catch (error) {
throw new Error(`Invalid JSON in ${label}: ${error.message}`);
}
diff --git a/scripts/lib/install/guarded-write.js b/scripts/lib/install/guarded-write.js
new file mode 100644
index 000000000..ac654f6f9
--- /dev/null
+++ b/scripts/lib/install/guarded-write.js
@@ -0,0 +1,115 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { sameFileIdentity } = require('./claude-settings-lock');
+
+function snapshotExpectedContent(expectedContent) {
+ if (expectedContent === undefined) return undefined;
+ if (expectedContent && expectedContent.kind === 'absent') {
+ return Object.freeze({ kind: 'absent' });
+ }
+ if (expectedContent && expectedContent.kind === 'sha256'
+ && typeof expectedContent.digest === 'string' && /^[a-f0-9]{64}$/i.test(expectedContent.digest)) {
+ return Object.freeze({ kind: 'sha256', digest: expectedContent.digest.toLowerCase() });
+ }
+ throw new TypeError('Invalid expectedContent for guarded write.');
+}
+
+function changedDestination(action, filePath, expectedContent, cause) {
+ const message = expectedContent
+ ? `Refusing OpenCode hook deactivation: activation changed after preflight at ${filePath}`
+ : `Refusing to ${action}: managed destination changed during the write.`;
+ const error = new Error(message);
+ if (cause) {
+ error.cause = cause;
+ if (cause.code) error.code = cause.code;
+ }
+ return error;
+}
+
+function writeFileNoFollow(filePath, content, {
+ mode,
+ action = 'write managed file',
+ validateDestination,
+ expectedContent: requestedContent,
+} = {}) {
+ if (typeof validateDestination !== 'function') {
+ throw new TypeError('writeFileNoFollow requires validateDestination.');
+ }
+ const destination = path.resolve(filePath);
+ const expectedContent = snapshotExpectedContent(requestedContent);
+ const bytes = typeof content === 'string' ? Buffer.from(content) : content;
+ if (!Buffer.isBuffer(bytes)) throw new TypeError('Managed file content must be a string or Buffer.');
+ const changed = cause => changedDestination(action, destination, expectedContent, cause);
+ function validatePath() {
+ const validated = validateDestination(destination);
+ if (typeof validated !== 'string' || path.resolve(validated) !== destination) throw changed();
+ }
+ function parentStats() {
+ const stats = fs.lstatSync(path.dirname(destination), { bigint: true });
+ if (!stats.isDirectory() || stats.isSymbolicLink()) throw changed();
+ return stats;
+ }
+ validatePath();
+ const parent = parentStats();
+ const flags = (expectedContent ? fs.constants.O_RDWR : fs.constants.O_WRONLY)
+ | (!expectedContent || expectedContent.kind === 'absent' ? fs.constants.O_CREAT : 0)
+ | (expectedContent && expectedContent.kind === 'absent' ? fs.constants.O_EXCL : 0)
+ | (fs.constants.O_NOFOLLOW || 0);
+ let descriptor;
+ try {
+ descriptor = fs.openSync(destination, flags, mode);
+ } catch (error) {
+ if (expectedContent) throw changed(error);
+ throw error;
+ }
+ function assertPinned() {
+ validatePath();
+ const descriptorStat = fs.fstatSync(descriptor, { bigint: true });
+ const liveStat = fs.lstatSync(destination, { bigint: true });
+ if (!sameFileIdentity(parent, parentStats()) || !descriptorStat.isFile()
+ || !liveStat.isFile() || liveStat.isSymbolicLink() || !sameFileIdentity(descriptorStat, liveStat)) {
+ throw changed();
+ }
+ return descriptorStat;
+ }
+ let primaryError;
+ try {
+ const before = assertPinned();
+ if (expectedContent && expectedContent.kind === 'absent' && before.size !== 0n) throw changed();
+ if (expectedContent && expectedContent.kind === 'sha256') {
+ const digest = crypto.createHash('sha256').update(fs.readFileSync(descriptor)).digest('hex');
+ const after = assertPinned();
+ if (!sameFileIdentity(before, after) || before.size !== after.size
+ || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs
+ || digest !== expectedContent.digest) throw changed();
+ }
+ // Observed changes are rejected before truncation. This is not a CAS against
+ // arbitrary editors: callers coordinate participating writers with a lease.
+ fs.ftruncateSync(descriptor, 0);
+ for (let offset = 0; offset < bytes.length;) {
+ const written = fs.writeSync(descriptor, bytes, offset, bytes.length - offset, offset);
+ if (!Number.isInteger(written) || written <= 0 || written > bytes.length - offset) {
+ throw new Error(`Refusing to ${action}: file write made no valid progress.`);
+ }
+ offset += written;
+ }
+ if (mode !== undefined) fs.fchmodSync(descriptor, mode);
+ } catch (error) {
+ primaryError = error;
+ } finally {
+ try {
+ fs.closeSync(descriptor);
+ } catch (error) {
+ if (primaryError) primaryError.closeError = error;
+ else primaryError = error;
+ }
+ }
+ // An exclusive creation that later fails is not unlinked: the pathname may
+ // already belong to another writer. Keep the refusal visible to the caller.
+ if (primaryError) throw primaryError;
+}
+
+module.exports = { writeFileNoFollow };
diff --git a/scripts/lib/install/hook-consent.js b/scripts/lib/install/hook-consent.js
index 883c121d7..f954c9016 100644
--- a/scripts/lib/install/hook-consent.js
+++ b/scripts/lib/install/hook-consent.js
@@ -38,11 +38,65 @@ const HOOK_CAPABILITY_GROUPS = Object.freeze([
const HOOK_CONSENT_DECISIONS = Object.freeze(['enabled', 'declined']);
const HOOK_RUNTIME_MODULE_ID = 'hooks-runtime';
+const OPENCODE_DISABLE_ECC_HOOKS_TRANSFORM = 'opencode-disable-ecc-hooks';
+const OPENCODE_DISABLE_PLUGIN_TRANSFORM = 'opencode-disable-plugin-entrypoint';
function normalizeOperationPath(value) {
return String(value || '').replace(/\\/g, '/').toLowerCase();
}
+function disableOpenCodeHookPluginRegistration(content, sourceRelativePath) {
+ let config;
+ try {
+ config = JSON.parse(content);
+ } catch (error) {
+ throw new Error(`Failed to parse ${sourceRelativePath}: ${error.message}`);
+ }
+ if (!config || typeof config !== 'object' || Array.isArray(config)) {
+ throw new Error(`Invalid ${sourceRelativePath}: expected a JSON object`);
+ }
+ if (config.plugin !== undefined && !Array.isArray(config.plugin)) {
+ throw new Error(`Invalid ${sourceRelativePath}: plugin must be an array`);
+ }
+
+ if (!Array.isArray(config.plugin)) {
+ return `${JSON.stringify(config, null, 2)}\n`;
+ }
+
+ return `${JSON.stringify({
+ ...config,
+ plugin: config.plugin.filter(plugin => plugin !== './plugins'),
+ }, 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 getOpenCodeSourceActivationKind(operation) === 'plugin';
+}
+
+function getDisabledOpenCodePluginContent() {
+ // OpenCode discovers plugins independently of opencode.json registration.
+ // Do not import the original module: even module initialization has effects.
+ return 'export default async () => ({});\n';
+}
+
+function isOpenCodeHookActivationOperation(operation = {}) {
+ return getOpenCodeSourceActivationKind(operation) !== null;
+}
+
function isHookRuntimeOperation(operation = {}) {
if (
operation.kind === 'update-claude-settings'
@@ -51,6 +105,15 @@ function isHookRuntimeOperation(operation = {}) {
return true;
}
+ if (isOpenCodeHookActivationOperation(operation)) {
+ return !(
+ operation.kind === 'copy-file'
+ && operation.contentTransform === (isOpenCodePluginEntrypoint(operation)
+ ? OPENCODE_DISABLE_PLUGIN_TRANSFORM
+ : OPENCODE_DISABLE_ECC_HOOKS_TRANSFORM)
+ );
+ }
+
const source = normalizeOperationPath(operation.sourceRelativePath);
const destination = normalizeOperationPath(operation.destinationPath);
return (
@@ -93,6 +156,60 @@ function withoutHookRuntimeId(values) {
return (Array.isArray(values) ? values : []).filter(value => value !== HOOK_RUNTIME_MODULE_ID);
}
+function withoutOpenCodeHookActivation(operation) {
+ if (getOpenCodeSourceActivationKind(operation) === 'package') {
+ throw new Error(`Unsupported OpenCode package metadata deactivation: ${operation.sourceRelativePath}`);
+ }
+ if (
+ !isOpenCodeHookActivationOperation(operation)
+ || operation.kind !== 'copy-file'
+ ) {
+ return operation;
+ }
+ return {
+ ...operation,
+ contentTransform: isOpenCodePluginEntrypoint(operation)
+ ? OPENCODE_DISABLE_PLUGIN_TRANSFORM
+ : OPENCODE_DISABLE_ECC_HOOKS_TRANSFORM,
+ };
+}
+
+function transformOpenCodeHookActivationOperations(operations) {
+ return (Array.isArray(operations) ? operations : []).map(withoutOpenCodeHookActivation);
+}
+
+function planSelectsHookRuntime(plan = {}) {
+ return (
+ Array.isArray(plan.selectedModuleIds)
+ && plan.selectedModuleIds.includes(HOOK_RUNTIME_MODULE_ID)
+ ) || (
+ Array.isArray(plan.operations)
+ && plan.operations.some(operation => operation.moduleId === HOOK_RUNTIME_MODULE_ID)
+ );
+}
+
+function disableUnselectedOpenCodeHooks(plan) {
+ if (plan.target !== 'opencode' || planSelectsHookRuntime(plan)) {
+ return plan;
+ }
+
+ return {
+ ...plan,
+ operations: transformOpenCodeHookActivationOperations(plan.operations),
+ statePreview: plan.statePreview
+ ? {
+ ...plan.statePreview,
+ operations: transformOpenCodeHookActivationOperations(plan.statePreview.operations),
+ }
+ : plan.statePreview,
+ };
+}
+
+function shouldDisableOpenCodeHooks(plan = {}) {
+ return plan.target === 'opencode'
+ && (plan.hookConsent === 'declined' || !planSelectsHookRuntime(plan));
+}
+
function setStatePreviewHookConsent(statePreview, hookConsent) {
if (!statePreview || !statePreview.request) {
return statePreview;
@@ -123,7 +240,11 @@ function getRecordedHookConsent(state = {}) {
return 'enabled';
}
- if (planMaterializesHookRuntime(state)) {
+ // Older OpenCode installs copied activation files without asking for consent.
+ // Their presence cannot establish that the user opted in to automatic hooks.
+ if ((Array.isArray(state.operations) ? state.operations : []).some(operation => (
+ !isOpenCodeHookActivationOperation(operation) && isHookRuntimeOperation(operation)
+ ))) {
return 'enabled';
}
@@ -134,11 +255,17 @@ function stripHookRuntimeFromPlan(plan) {
const hadHookRuntimeModule = Array.isArray(plan.selectedModuleIds)
&& plan.selectedModuleIds.includes('hooks-runtime');
const operations = (Array.isArray(plan.operations) ? plan.operations : [])
+ .map(operation => (
+ plan.target === 'opencode' ? withoutOpenCodeHookActivation(operation) : operation
+ ))
.filter(operation => !isHookRuntimeOperation(operation));
const statePreview = plan.statePreview
? {
...plan.statePreview,
operations: (Array.isArray(plan.statePreview.operations) ? plan.statePreview.operations : [])
+ .map(operation => (
+ plan.target === 'opencode' ? withoutOpenCodeHookActivation(operation) : operation
+ ))
.filter(operation => !isHookRuntimeOperation(operation)),
resolution: plan.statePreview.resolution
? {
@@ -167,10 +294,11 @@ function withHookConsent(plan, hookConsent = null) {
if (hookConsent === 'declined') {
return { ...stripHookRuntimeFromPlan(plan), hookConsent };
}
+ const effectivePlan = disableUnselectedOpenCodeHooks(plan);
return {
- ...plan,
+ ...effectivePlan,
hookConsent,
- statePreview: setStatePreviewHookConsent(plan.statePreview, hookConsent),
+ statePreview: setStatePreviewHookConsent(effectivePlan.statePreview, hookConsent),
};
}
@@ -193,10 +321,18 @@ function assertHookConsentReady(plan = {}) {
module.exports = {
HOOK_CAPABILITY_GROUPS,
assertHookConsentReady,
+ disableUnselectedOpenCodeHooks,
+ disableOpenCodeHookPluginRegistration,
+ getDisabledOpenCodePluginContent,
+ getOpenCodeActivationPathKind,
+ getOpenCodeSourceActivationKind,
formatHookCapabilityDisclosure,
getRecordedHookConsent,
isHookRuntimeOperation,
+ isOpenCodeHookActivationOperation,
+ isOpenCodePluginEntrypoint,
planMaterializesHookRuntime,
resolveHookConsentFlags,
+ shouldDisableOpenCodeHooks,
withHookConsent,
};
diff --git a/scripts/lib/install/opencode-install-lock.js b/scripts/lib/install/opencode-install-lock.js
new file mode 100644
index 000000000..4b690d3d3
--- /dev/null
+++ b/scripts/lib/install/opencode-install-lock.js
@@ -0,0 +1,145 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { realpathNearestExisting } = require('../path-safety');
+const { acquireSettingsLock, getSettingsLockIdentity, sameFileIdentity } = require('./claude-settings-lock');
+
+const activeLeases = new WeakMap();
+const STATE_FILENAME = 'ecc-install-state.json';
+const comparablePath = value => process.platform === 'win32' ? value.toLowerCase() : value;
+
+function inspectEntry(filePath) {
+ try { return fs.lstatSync(filePath, { bigint: true }); }
+ catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+}
+
+function canonicalRoots(roots) {
+ if (!Array.isArray(roots)) throw new TypeError('OpenCode install roots must be an array.');
+ const deduplicated = new Map();
+ for (const root of roots) {
+ if (typeof root !== 'string' || !path.isAbsolute(root)) {
+ throw new TypeError('OpenCode install root must be an absolute trusted path.');
+ }
+ const stats = inspectEntry(root);
+ if (stats && (stats.isSymbolicLink() || !stats.isDirectory())) {
+ throw new Error(`Refusing OpenCode install lock through a non-directory or symlink root: ${root}`);
+ }
+ const canonical = realpathNearestExisting(root);
+ deduplicated.set(comparablePath(canonical), canonical);
+ }
+ return [...deduplicated.values()].sort((left, right) => {
+ const a = comparablePath(left);
+ const b = comparablePath(right);
+ return a < b ? -1 : a > b ? 1 : 0;
+ });
+}
+
+function assertLockLocation(root, expectedRoot) {
+ const stats = inspectEntry(root);
+ if (!stats || !stats.isDirectory() || stats.isSymbolicLink()
+ || comparablePath(fs.realpathSync(root)) !== comparablePath(root)
+ || (expectedRoot && !sameFileIdentity(stats, expectedRoot))) {
+ throw new Error(`Refusing changed OpenCode install lock root: ${root}`);
+ }
+ const lock = inspectEntry(path.join(root, `${STATE_FILENAME}.ecc.lock`));
+ if (lock && (!lock.isFile() || lock.isSymbolicLink())) {
+ throw new Error(`Refusing non-file or symlink OpenCode install lock: ${root}`);
+ }
+ return { root: stats, lock };
+}
+
+function assertOwnedLock(owned) {
+ const live = assertLockLocation(owned.root, owned.rootStats);
+ if (!live.lock || !sameFileIdentity(live.lock, owned.lockStats)) {
+ throw new Error(`Refusing changed OpenCode install lock: ${owned.root}`);
+ }
+}
+
+function annotateCleanupFailure(primary, property, value) {
+ try {
+ // Own data properties avoid invoking caller getters/setters. Frozen values,
+ // primitives and rejecting proxy traps simply retain no extra diagnostic.
+ Object.defineProperty(primary, property, { value, configurable: true, enumerable: true, writable: true });
+ } catch {
+ // Diagnostics must never replace the exact primary thrown value.
+ }
+}
+
+function releaseOwned(ownedLocks) {
+ const failures = [];
+ for (const owned of [...ownedLocks].reverse()) {
+ try {
+ assertOwnedLock(owned);
+ owned.release();
+ } catch (error) {
+ failures.push(error);
+ }
+ }
+ // Finish every safe release before touching any caller-owned error object.
+ if (failures.length > 0) {
+ if (failures.length > 1) annotateCleanupFailure(failures[0], 'releaseErrors', failures.slice(1));
+ throw failures[0];
+ }
+}
+
+function acquireOpenCodeInstallLocks(roots, existingLease) {
+ const orderedRoots = canonicalRoots(roots);
+ if (existingLease !== undefined) {
+ const existing = existingLease && typeof existingLease === 'object' && activeLeases.get(existingLease);
+ if (!existing) throw new Error('Invalid or inactive OpenCode install lease.');
+ const covered = new Set(existing.map(owned => comparablePath(owned.root)));
+ if (orderedRoots.some(root => !covered.has(comparablePath(root)))) {
+ throw new Error('OpenCode install lease does not cover every required root.');
+ }
+ existing.forEach(assertOwnedLock);
+ return { lease: existingLease, release() {} };
+ }
+ const ownedLocks = [];
+ try {
+ for (const root of orderedRoots) {
+ fs.mkdirSync(root, { recursive: true });
+ const before = assertLockLocation(root);
+ const release = acquireSettingsLock(path.join(root, STATE_FILENAME), { label: 'OpenCode installation' });
+ // Bind descriptor-derived ownership before any path revalidation. Never
+ // adopt the identity of a replacement published at the lock pathname.
+ const owned = { root, rootStats: before.root, release,
+ lockStats: getSettingsLockIdentity(release) };
+ ownedLocks.push(owned);
+ assertOwnedLock(owned);
+ }
+ } catch (error) {
+ try { releaseOwned(ownedLocks); }
+ catch (releaseError) { annotateCleanupFailure(error, 'releaseError', releaseError); }
+ throw error;
+ }
+ const lease = Object.freeze({});
+ activeLeases.set(lease, ownedLocks);
+ return {
+ lease,
+ release() {
+ if (!activeLeases.has(lease)) return;
+ activeLeases.delete(lease);
+ releaseOwned(ownedLocks);
+ },
+ };
+}
+
+function withOpenCodeInstallLocks(roots, callback, existingLease) {
+ if (typeof callback !== 'function') throw new TypeError('OpenCode install lock callback must be a function.');
+ const holder = acquireOpenCodeInstallLocks(roots, existingLease);
+ let didThrow = false;
+ let primaryError;
+ let result;
+ try { result = callback(holder.lease); }
+ catch (error) { didThrow = true; primaryError = error; }
+ try { holder.release(); }
+ catch (error) {
+ if (didThrow) annotateCleanupFailure(primaryError, 'releaseError', error);
+ else { didThrow = true; primaryError = error; }
+ }
+ if (didThrow) throw primaryError;
+ return result;
+}
+
+module.exports = { acquireOpenCodeInstallLocks, withOpenCodeInstallLocks };
diff --git a/scripts/lib/install/opencode-legacy-migration.js b/scripts/lib/install/opencode-legacy-migration.js
index baf3472f1..bca8c01fa 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,19 @@ function inspectLegacyOpencodeState(location) {
}
}
-function hashFileNoFollow(filePath) {
+function hashFileNoFollow(filePath, fileSystem = fs) {
+ // The filesystem seam supplies operations, never the read-only access policy.
const flags = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0);
- const descriptor = fs.openSync(filePath, flags);
+ // Read-only opens ignore mode; adapters still receive an owner-only default.
+ const descriptor = fileSystem.openSync(filePath, flags, 0o600);
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 +133,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 +213,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 +268,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;
@@ -393,6 +411,8 @@ function cleanupLegacyOpencodeInstall(plan) {
module.exports = {
cleanupLegacyOpencodeInstall,
getLegacyOpencodeLocation,
+ getLegacyLocationForPlan,
inspectLegacyOpencodeState,
removeVerifiedLegacyFile,
+ verifyManagedLegacyFile,
};
diff --git a/scripts/lib/install/plan.js b/scripts/lib/install/plan.js
index 1400557c7..afcb4f06b 100644
--- a/scripts/lib/install/plan.js
+++ b/scripts/lib/install/plan.js
@@ -7,6 +7,7 @@ const { execFileSync } = require('child_process');
const { resolveInstallPlan } = require('../install-manifests');
const { getInstallTargetAdapter } = require('../install-targets/registry');
const { resolveInvocationEnvironment } = require('../invocation-environment');
+const { disableUnselectedOpenCodeHooks } = require('./hook-consent');
const { readHooksConfig } = require('../hooks-config');
const {
materializeManagedHooks,
@@ -315,7 +316,7 @@ function createManifestInstallPlan(options = {}) {
source
});
- return {
+ return disableUnselectedOpenCodeHooks({
mode: options.mode || 'manifest',
sourceRoot,
target,
@@ -341,7 +342,7 @@ function createManifestInstallPlan(options = {}) {
excludedModuleIds: plan.excludedModuleIds,
operations,
statePreview
- };
+ });
}
module.exports = {
diff --git a/scripts/lib/plan-canvas/server.js b/scripts/lib/plan-canvas/server.js
index 11b44062a..ae0a83468 100644
--- a/scripts/lib/plan-canvas/server.js
+++ b/scripts/lib/plan-canvas/server.js
@@ -15,7 +15,7 @@ const http = require('http');
const path = require('path');
const { buildAllowedHostnames, isAllowedHostHeader, isAllowedOrigin } = require('../loopback-guard');
-const { renderMarkdown } = require('./markdown');
+const { escapeHtml, renderMarkdown } = require('./markdown');
const { artifactSdkJs } = require('./sdk');
const {
canvasCss,
@@ -101,9 +101,21 @@ function sendJson(res, statusCode, payload) {
res.end(body);
}
+// Artifact pages render inside a sandboxed iframe (no allow-same-origin) and
+// legitimately run CDN scripts (Mermaid) plus inline loaders, so the default
+// restrictive CSP cannot apply. A sandbox-only CSP mirrors the iframe
+// attribute instead: scripts keep working, but the document gets an opaque
+// origin, which neuters direct-navigation abuse of the loopback API (no CORS
+// reads, JSON POSTs are preflight-blocked) without changing in-iframe
+// behavior. A hostile
CSP in a raw HTML artifact can only narrow this
+// further, never loosen it.
+const ARTIFACT_CSP = 'sandbox allow-scripts allow-forms allow-popups';
+
function sendHtml(res, statusCode, html, { csp = true } = {}) {
const headers = { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' };
- if (csp) {
+ if (csp === 'artifact') {
+ headers['content-security-policy'] = ARTIFACT_CSP;
+ } else if (csp) {
headers['content-security-policy'] =
"default-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; frame-src 'self'";
}
@@ -111,6 +123,112 @@ function sendHtml(res, statusCode, html, { csp = true } = {}) {
res.end(html);
}
+// Sibling assets have an explicit 64 MiB resource limit (413 above it), separate
+// from request-body limits. Reads use at most the sampled size plus one sentinel.
+const MAX_ARTIFACT_ASSET_BYTES = 64 * 1024 * 1024;
+
+function assetReadError(code = 'EARTIFACT_UNSAFE') {
+ return Object.assign(new Error('Artifact sibling read refused'), { code });
+}
+
+function sameAssetIdentity(before, after) {
+ return before.dev === after.dev && before.ino === after.ino && before.mode === after.mode;
+}
+
+function sameAssetFile(before, after) {
+ return after.isFile() && sameAssetIdentity(before, after) && before.size === after.size
+ && (before.mtimeNs ?? before.mtimeMs) === (after.mtimeNs ?? after.mtimeMs)
+ && (before.ctimeNs ?? before.ctimeMs) === (after.ctimeNs ?? after.ctimeMs);
+}
+
+function assetByteLength(stats) {
+ if (typeof stats.size !== 'bigint' && !Number.isSafeInteger(stats.size)) throw assetReadError();
+ const size = BigInt(stats.size);
+ if (size < 0n) throw assetReadError();
+ if (size > BigInt(MAX_ARTIFACT_ASSET_BYTES)) throw assetReadError('EARTIFACT_TOO_LARGE');
+ return Number(size);
+}
+
+function snapshotAssetChain(realTarget) {
+ const root = path.parse(realTarget).root;
+ const parts = path.relative(root, realTarget).split(path.sep).filter(Boolean);
+ const paths = [root];
+ for (const part of parts) paths.push(path.join(paths[paths.length - 1], part));
+ return paths.map((entryPath, index) => {
+ const stats = fs.lstatSync(entryPath, { bigint: true });
+ const leaf = index === paths.length - 1;
+ if (stats.isSymbolicLink() || !(leaf ? stats.isFile() : stats.isDirectory())) throw assetReadError();
+ return { path: entryPath, stats, leaf };
+ });
+}
+
+function revalidateAssetPath({ baseDir, resolved, realBase, realTarget, chain }) {
+ if (fs.realpathSync(baseDir) !== realBase || fs.realpathSync(resolved) !== realTarget) throw assetReadError();
+ for (const entry of chain) {
+ const current = fs.lstatSync(entry.path, { bigint: true });
+ if (current.isSymbolicLink() || !(entry.leaf ? sameAssetFile(entry.stats, current)
+ : current.isDirectory() && sameAssetIdentity(entry.stats, current))) throw assetReadError();
+ }
+}
+
+function readAssetDescriptor(fd, size) {
+ const buffer = Buffer.alloc(size + 1);
+ let bytes = 0;
+ while (bytes < buffer.length) {
+ const requested = buffer.length - bytes;
+ const count = fs.readSync(fd, buffer, bytes, requested, bytes);
+ if (!Number.isInteger(count) || count < 0 || count > requested) throw assetReadError();
+ if (count === 0) break;
+ bytes += count;
+ }
+ if (bytes !== size) throw assetReadError();
+ return buffer.subarray(0, bytes);
+}
+
+// Canonical ancestors are sampled from the filesystem root, not just realBase.
+// Revalidation detects observed replacements, but portable pathname operations
+// are not atomic openat confinement: repeated swap/restore or same-inode content
+// races can evade observations. This helper covers siblings only, not the direct
+// session.file read. O_NOFOLLOW protects the leaf only where the flag exists.
+function readSiblingAsset(baseDir, resolved) {
+ const realBase = fs.realpathSync(baseDir);
+ const realTarget = fs.realpathSync(resolved);
+ const relative = path.relative(realBase, realTarget);
+ if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) throw assetReadError();
+ const chain = snapshotAssetChain(realTarget);
+ const expected = chain[chain.length - 1].stats;
+ const size = assetByteLength(expected);
+ const snapshot = { baseDir, resolved, realBase, realTarget, chain };
+ revalidateAssetPath(snapshot);
+ const flags = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0) | (fs.constants.O_NONBLOCK || 0);
+ let fd;
+ try {
+ fd = fs.openSync(realTarget, flags);
+ } catch (error) {
+ if (error.code === 'ELOOP' || error.code === 'ENOTDIR') throw assetReadError();
+ throw error;
+ }
+ let primaryError;
+ let data;
+ try {
+ if (!sameAssetFile(expected, fs.fstatSync(fd, { bigint: true }))) throw assetReadError();
+ revalidateAssetPath(snapshot);
+ data = readAssetDescriptor(fd, size);
+ if (!sameAssetFile(expected, fs.fstatSync(fd, { bigint: true }))) throw assetReadError();
+ revalidateAssetPath(snapshot);
+ } catch (error) {
+ primaryError = error;
+ } finally {
+ try { fs.closeSync(fd); } catch (error) {
+ // A close error may mean the fd is already released; never retry it or
+ // replace the primary read/validation failure. Close-only failure refuses.
+ if (!primaryError) primaryError = error;
+ }
+ }
+ if (primaryError) throw primaryError;
+ return { data, realTarget };
+}
+
function createPlanCanvasServer({
store,
host = DEFAULT_HOST,
@@ -493,7 +611,7 @@ function createPlanCanvasServer({
try {
content = fs.readFileSync(session.file, 'utf8');
} catch {
- return sendHtml(res, 404, `
Artifact missing
${session.file} no longer exists.
`, { csp: false });
+ return sendHtml(res, 404, `
Artifact missing
${escapeHtml(session.file)} no longer exists.
`);
}
const ext = path.extname(session.file).toLowerCase();
if (ext === '.md' || ext === '.markdown') {
@@ -501,30 +619,43 @@ function createPlanCanvasServer({
title: path.basename(session.file),
sdkSrc: '/sdk.js'
});
- return sendHtml(res, 200, html, { csp: false });
+ return sendHtml(res, 200, html, { csp: 'artifact' });
}
const sdkTag = '';
const injected = content.includes('')
? content.replace('
- 
