@kylecheng3146/agent-ops 0.1.4 → 0.1.6

package/dist/runtime/src/install/hooks.js

@@ -1,6 +1,5 @@
-import { buildClaudeHookSettings, mergeClaudeSettings, stripClaudeManagedHooks } from "../adapters/claude/config.js";
-import { buildCodexHookConfig, mergeCodexHookConfig, stripCodexManagedHooks } from "../adapters/codex/config.js";
 import { AgentOpsError } from "../fs/paths.js";
+import { harnessDescriptor, harnessHookPath } from "./harness.js";
 export const CLAUDE_HOOK_PATH = ".claude/settings.json";
 export const CODEX_HOOK_PATH = ".codex/hooks.json";
 function format(value) {
@@ -17,31 +16,34 @@ function parseSettings(path, source) {
         throw new AgentOpsError("HOOK_SETTINGS_INVALID_JSON", `Hook settings are not valid JSON: ${path}`, { cause: error });
     }
 }
-export function hookRegistrationPath(harness, scope) {
+export function hookRegistrationPath(harness, scope, root) {
     // ponytail: user scope resolves against AGENT_OPS_HOME, so the same
-    // relative path serves both scopes.
-    void scope;
-    return harness === "claude" ? CLAUDE_HOOK_PATH : CODEX_HOOK_PATH;
+    // root can resolve a scope-specific harness path.
+    return harnessHookPath(harness, scope, root);
 }
 /**
  * Builds the merged settings file for one harness, preserving foreign hooks.
  * Returns null when the selected capabilities register no events at all.
  */
 export function planHookRegistration(options) {
-    const path = hookRegistrationPath(options.harness, options.scope);
-    const managed = options.harness === "claude"
-        ? buildClaudeHookSettings(options.capabilities, options.runtimePath)
-        : buildCodexHookConfig(options.capabilities);
+    const descriptor = harnessDescriptor(options.harness);
+    if (descriptor.control.buildHooks === undefined ||
+        descriptor.control.mergeHooks === undefined) {
+        // File-backed adapters (currently opencode) track their plugin as a
+        // managed artifact rather than as a ManagedHookRecord.
+        return null;
+    }
+    const path = options.path ?? hookRegistrationPath(options.harness, options.scope);
+    const managed = descriptor.control.buildHooks(options.capabilities, options.runtimePath);
     const events = Object.keys(managed.hooks);
     if (events.length === 0) {
         return null;
     }
     const existing = parseSettings(path, options.currentSource);
-    const merged = options.harness === "claude"
-        ? mergeClaudeSettings(existing, managed)
-        : mergeCodexHookConfig(existing, managed);
+    const merged = descriptor.control.mergeHooks(existing, managed);
     return {
         content: format(merged),
+        disclosure: "opaque",
         record: {
             id: `${options.harness}-hooks`,
             path,
@@ -52,7 +54,7 @@ export function planHookRegistration(options) {
     };
 }
 function onlyManagedRemains(harness, value) {
-    const ownKeys = new Set(harness === "codex" ? ["hooks", "description"] : ["hooks"]);
+    const ownKeys = new Set(harnessDescriptor(harness).control.ownSettingsKeys ?? []);
     const hooks = value.hooks;
     return (Object.keys(value).every((key) => ownKeys.has(key)) &&
         typeof hooks === "object" &&
@@ -64,12 +66,15 @@ function onlyManagedRemains(harness, value) {
  * when nothing but agent-ops content is left, so foreign settings survive.
  */
 export function planHookRemoval(record, currentSource) {
+    const descriptor = harnessDescriptor(record.harness);
+    if (descriptor.control.stripHooks === undefined) {
+        throw new AgentOpsError("HOOK_REMOVAL_UNSUPPORTED", `Harness hook records are not supported for ${record.harness}.`);
+    }
     const existing = parseSettings(record.path, currentSource);
-    const stripped = record.harness === "claude"
-        ? stripClaudeManagedHooks(existing)
-        : stripCodexManagedHooks(existing);
+    const stripped = descriptor.control.stripHooks(existing);
     return {
         path: record.path,
+        disclosure: "opaque",
         content: onlyManagedRemains(record.harness, stripped)
             ? null
             : format(stripped)

package/dist/runtime/src/install/ownership.js

@@ -1,27 +1,38 @@
 import { applyManagedBlock, managedBlockMarkers } from "../fs/managed-block.js";
 import { AgentOpsError } from "../fs/paths.js";
-import { COMMON_AGENTS_BLOCK, COMMON_CLAUDE_BLOCK } from "./harness.js";
-import { hookRegistrationPath } from "./hooks.js";
-function selectedHarnesses(manifest) {
-    return manifest.harness === "both"
-        ? ["codex", "claude"]
-        : [manifest.harness];
-}
-function expectedMarker(manifest, id) {
-    const isCodex = id === "codex";
-    const markerId = `${id}-routing`;
-    const markers = managedBlockMarkers(markerId, 1);
-    const instructionFile = isCodex ? "AGENTS.md" : "CLAUDE.md";
+import { harnessDescriptor, harnessHookPath, routingBlockId, selectHarnessHookSurface, rulesArtifactId } from "./harness.js";
+import { isOpencodePluginPath } from "../adapters/opencode/config.js";
+import { LOOP_MARKER_ID, LOOP_MARKER_VERSION, loopIgnoreContent, loopLauncherArtifactId, loopLauncherPath, selectedLoopHarnesses } from "./codex-loop.js";
+function expectedMarker(manifest, id, markerId) {
+    const descriptor = harnessDescriptor(id);
+    const markers = managedBlockMarkers(markerId, 1, "html");
     return {
         id: markerId,
         path: manifest.scope === "project"
-            ? instructionFile
-            : `.${id}/${instructionFile}`,
+            ? descriptor.control.instructionFile
+            : `.${id}/${descriptor.control.instructionFile}`,
+        startMarker: markers.start,
+        endMarker: markers.end,
+        markerStyle: "html",
+        content: descriptor.control.routing.desired,
+        legacyContent: descriptor.control.routing.legacy
+    };
+}
+function expectedLoopMarker(manifest) {
+    const markers = managedBlockMarkers(LOOP_MARKER_ID, LOOP_MARKER_VERSION, "hash");
+    return {
+        id: LOOP_MARKER_ID,
+        path: ".gitignore",
         startMarker: markers.start,
         endMarker: markers.end,
-        content: isCodex ? COMMON_AGENTS_BLOCK : COMMON_CLAUDE_BLOCK
+        markerStyle: "hash",
+        content: loopIgnoreContent(manifest.harness),
+        legacyContent: []
     };
 }
+function pathKey(path) {
+    return path.toLowerCase();
+}
 function manifestOwnershipError() {
     return new AgentOpsError("MANIFEST_OWNERSHIP_INVALID", "The manifest does not match a supported managed installation shape.");
 }
@@ -29,37 +40,129 @@ function manifestOwnershipError() {
  * Hook records are optional: installations without hook capabilities, and
  * manifests written before hook registration existed, carry none.
  */
-function assertSupportedHookRecords(manifest, harnesses) {
+function assertSupportedHookRecords(manifest, harnesses, root) {
     const selected = new Set(harnesses);
     const seen = new Set();
     for (const hook of manifest.hooks ?? []) {
         if (!selected.has(hook.harness) ||
             seen.has(hook.harness) ||
+            harnessDescriptor(hook.harness).control.buildHooks === undefined ||
             hook.id !== `${hook.harness}-hooks` ||
-            hook.path !== hookRegistrationPath(hook.harness, manifest.scope) ||
             hook.events.length === 0) {
             throw manifestOwnershipError();
         }
+        try {
+            selectHarnessHookSurface({
+                harness: hook.harness,
+                scope: manifest.scope,
+                root,
+                persistedPath: hook.path
+            });
+        }
+        catch {
+            throw manifestOwnershipError();
+        }
         seen.add(hook.harness);
     }
 }
-export function assertSupportedManifestOwnership(manifest) {
-    const harnesses = selectedHarnesses(manifest);
-    const expectedArtifacts = new Map([
-        ["config", ".agent-ops/config.json"]
+export function assertSupportedManifestOwnership(manifest, root) {
+    const harnesses = manifest.harness;
+    const expectedArtifactPaths = new Map([
+        [
+            pathKey(".agent-ops/config.json"),
+            { path: ".agent-ops/config.json", ids: new Set(["config"]) }
+        ]
+    ]);
+    const requiredArtifactPaths = new Set([
+        pathKey(".agent-ops/config.json")
     ]);
     const expectedMarkers = new Map();
+    const expectedMarkerPaths = new Set();
+    const loopHarnesses = selectedLoopHarnesses(harnesses);
+    const hasLoopArtifacts = manifest.artifacts.some(({ id }) => loopHarnesses.some((harness) => id === loopLauncherArtifactId(harness)));
+    const hasLoopMarker = manifest.markers.some(({ id }) => id === LOOP_MARKER_ID);
+    const hasLoop = hasLoopArtifacts || hasLoopMarker;
+    if (hasLoop &&
+        (manifest.scope !== "project" || loopHarnesses.length === 0)) {
+        throw manifestOwnershipError();
+    }
+    const recordedOpencodePluginPath = manifest.artifacts.find(({ id }) => id === "opencode-plugin")?.path;
+    if (recordedOpencodePluginPath !== undefined &&
+        (!harnesses.includes("opencode") ||
+            !isOpencodePluginPath(manifest.scope, recordedOpencodePluginPath))) {
+        throw manifestOwnershipError();
+    }
     for (const id of harnesses) {
-        expectedArtifacts.set(`${id}-rules`, `.agent-ops/${id === "codex" ? "AGENTS.md" : "CLAUDE.md"}`);
-        const marker = expectedMarker(manifest, id);
-        expectedMarkers.set(marker.id, marker);
+        const descriptor = harnessDescriptor(id);
+        const artifactPath = `.agent-ops/${descriptor.control.instructionFile}`;
+        const artifactKey = pathKey(artifactPath);
+        const artifactEntry = expectedArtifactPaths.get(artifactKey);
+        const artifactIds = artifactEntry?.ids ?? new Set();
+        artifactIds.add(rulesArtifactId(descriptor));
+        // Accept the PR 2 per-harness spelling while update rewrites it to the
+        // path-derived ID. This keeps already-installed manifests removable.
+        artifactIds.add(`${id}-rules`);
+        expectedArtifactPaths.set(artifactKey, {
+            path: artifactEntry?.path ?? artifactPath,
+            ids: artifactIds
+        });
+        requiredArtifactPaths.add(artifactKey);
+        const markerPath = manifest.scope === "project"
+            ? descriptor.control.instructionFile
+            : `.${id}/${descriptor.control.instructionFile}`;
+        const markerKey = pathKey(markerPath);
+        expectedMarkerPaths.add(markerKey);
+        const currentId = routingBlockId(id, manifest.scope, descriptor);
+        const markerIds = new Set([currentId, `${id}-routing`]);
+        for (const markerId of markerIds) {
+            expectedMarkers.set(markerId, expectedMarker(manifest, id, markerId));
+        }
+        if (id === "opencode") {
+            const pluginPath = recordedOpencodePluginPath ?? harnessHookPath(id, manifest.scope, root);
+            const pluginKey = pathKey(pluginPath);
+            const pluginEntry = expectedArtifactPaths.get(pluginKey);
+            if (pluginEntry !== undefined && pluginEntry.path !== pluginPath) {
+                throw manifestOwnershipError();
+            }
+            const pluginIds = pluginEntry?.ids ?? new Set();
+            pluginIds.add("opencode-plugin");
+            expectedArtifactPaths.set(pluginKey, {
+                path: pluginPath,
+                ids: pluginIds
+            });
+        }
+    }
+    if (hasLoop) {
+        for (const harness of loopHarnesses) {
+            const path = loopLauncherPath(harness);
+            expectedArtifactPaths.set(pathKey(path), {
+                path,
+                ids: new Set([loopLauncherArtifactId(harness)])
+            });
+            requiredArtifactPaths.add(pathKey(path));
+        }
+        expectedMarkerPaths.add(pathKey(".gitignore"));
+        expectedMarkers.set(LOOP_MARKER_ID, expectedLoopMarker(manifest));
     }
-    if (manifest.artifacts.length !== expectedArtifacts.size ||
-        manifest.markers.length !== expectedMarkers.size) {
+    const opencodePluginPath = harnesses.includes("opencode")
+        ? recordedOpencodePluginPath ??
+            harnessHookPath("opencode", manifest.scope, root)
+        : null;
+    const optionalArtifactCount = opencodePluginPath !== null &&
+        expectedArtifactPaths.has(pathKey(opencodePluginPath))
+        ? 1
+        : 0;
+    if ((manifest.artifacts.length !== requiredArtifactPaths.size &&
+        manifest.artifacts.length !== requiredArtifactPaths.size +
+            optionalArtifactCount) ||
+        manifest.markers.length !== expectedMarkerPaths.size) {
         throw manifestOwnershipError();
     }
     for (const artifact of manifest.artifacts) {
-        if (expectedArtifacts.get(artifact.id) !== artifact.path) {
+        const expected = expectedArtifactPaths.get(pathKey(artifact.path));
+        if (expected === undefined ||
+            expected.path !== artifact.path ||
+            !expected.ids.has(artifact.id)) {
             throw manifestOwnershipError();
         }
     }
@@ -72,7 +175,7 @@ export function assertSupportedManifestOwnership(manifest) {
             throw manifestOwnershipError();
         }
     }
-    assertSupportedHookRecords(manifest, harnesses);
+    assertSupportedHookRecords(manifest, harnesses, root);
     return expectedMarkers;
 }
 function exactMarkerCount(source, marker) {
@@ -92,13 +195,21 @@ export function assertExpectedManagedBlock(source, marker, expected) {
         startIndex >= endIndex) {
         throw new AgentOpsError("MANAGED_BLOCK_CHANGED", `Managed block boundaries changed after installation: ${marker.path}`);
     }
-    const expectedBlock = applyManagedBlock("", {
-        id: expected.id,
-        version: 1,
-        content: expected.content
-    }).replace(/\n$/u, "");
     const currentBlock = source.slice(startIndex, endIndex + marker.endMarker.length);
-    if (currentBlock !== expectedBlock) {
-        throw new AgentOpsError("MANAGED_BLOCK_CHANGED", `Managed block content changed after installation: ${marker.path}`);
+    const candidates = [
+        ["desired", expected.content],
+        ...expected.legacyContent.map((content) => ["legacy", content])
+    ];
+    for (const [kind, content] of candidates) {
+        const expectedBlock = applyManagedBlock("", {
+            id: expected.id,
+            version: 1,
+            content,
+            markerStyle: expected.markerStyle
+        }).replace(/\n$/u, "");
+        if (currentBlock === expectedBlock) {
+            return kind;
+        }
     }
+    throw new AgentOpsError("MANAGED_BLOCK_CHANGED", `Managed block content changed after installation: ${marker.path}`);
 }