@ory/antigravity 0.10.0 → 0.11.1

package/README.md

@@ -48,7 +48,7 @@ npx -y -p @ory/antigravity ory-antigravity status
 npx -y -p @ory/antigravity ory-antigravity uninstall
 ```
 
-If the `agy` binary isn't on your `PATH`, `npx -y -p @ory/antigravity ory-antigravity-setup` writes the plugin bundle directly into your project's `.agents/` directory (`plugin.json`, `hooks.json`, `mcp_config.json`, `skills/`, `commands/`).
+If the `agy` binary isn't on your `PATH`, `npx -y -p @ory/antigravity ory-antigravity-setup` writes the plugin bundle directly into your project's `.agents/` directory (`plugin.json`, `hooks.json`, `mcp_config.json`, `skills/`, `commands/`). Because `.agents/` is shared with your own configuration, the setup merges rather than overwrites: it only sets or replaces the Ory-owned entries in `hooks.json` and `mcp_config.json`, leaving your hook rules and MCP servers intact, and it never touches a `plugin.json` that isn't Ory's own. Uninstall is the mirror image — it removes only the Ory-owned entries and deletes a file only once nothing else is left in it.
 
 </details>
 
@@ -223,7 +223,7 @@ npx -y -p @ory/antigravity ory-antigravity configure        [--project-url <url>
 npx -y -p @ory/antigravity ory-antigravity agent <status|unregister>
 npx -y -p @ory/antigravity ory-antigravity permissions <status|bootstrap|observe|enforce>
 npx -y -p @ory/antigravity ory-antigravity local <up|down|status|seed|logs|env|configure|reset>
-npx -y -p @ory/antigravity ory-antigravity setup            [--project-dir <path>]   # .agents fallback
+npx -y -p @ory/antigravity ory-antigravity-setup            [--project-dir <path>]   # .agents fallback
 npx -y -p @ory/antigravity ory-antigravity status
 ```
 

package/dist/cli/assets.d.ts

@@ -23,7 +23,21 @@ export declare const PLUGIN_NAME = "ory";
  * Write the full Ory plugin bundle under `root`. Used both for the
  * bundle handed to `agy plugin install` and for the manual `.agents`
  * fallback.
+ *
+ * The manual fallback targets the workspace's shared `.agents/` directory,
+ * where users keep their own hook rules and MCP servers — so the JSON
+ * files are MERGED, never whole-file overwritten: only the Ory-owned key
+ * is set/replaced, everything else is preserved. (In the package-owned
+ * bundle dir the merge is a no-op over a fresh tree, so the same code
+ * path is used everywhere.)
  */
 export declare function installAntigravityOryAssets(root: string): void;
-/** Remove every Ory skill, command, and bundle file written under `root`. */
+/**
+ * Remove every Ory skill, command, and bundle entry written under `root`.
+ *
+ * Mirror of the merge-aware install: only Ory-owned keys are removed from
+ * `hooks.json` / `mcp_config.json`, and each file is deleted only when it
+ * becomes empty. `plugin.json` is deleted only when it is Ory's own
+ * manifest. Unparseable files are left untouched.
+ */
 export declare function uninstallAntigravityOryAssets(root: string): void;

package/dist/cli/assets.js

@@ -126,16 +126,47 @@ function renderMcpConfig(version) {
         },
     };
 }
+/**
+ * Read a JSON file as a plain object. Returns `undefined` when the file
+ * is missing, unparseable, or not a JSON object — callers treat all three
+ * as "nothing mergeable here".
+ */
+function readJsonObject(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        /* missing or unparseable */
+    }
+    return undefined;
+}
+function writeJson(file, obj) {
+    fs.writeFileSync(file, JSON.stringify(obj, null, 2) + "\n");
+}
+/** True when a parsed plugin.json manifest is Ory's own. */
+function isOryManifest(manifest) {
+    return manifest?.name === exports.PLUGIN_NAME;
+}
 /**
  * Write the full Ory plugin bundle under `root`. Used both for the
  * bundle handed to `agy plugin install` and for the manual `.agents`
  * fallback.
+ *
+ * The manual fallback targets the workspace's shared `.agents/` directory,
+ * where users keep their own hook rules and MCP servers — so the JSON
+ * files are MERGED, never whole-file overwritten: only the Ory-owned key
+ * is set/replaced, everything else is preserved. (In the package-owned
+ * bundle dir the merge is a no-op over a fresh tree, so the same code
+ * path is used everywhere.)
  */
 function installAntigravityOryAssets(root) {
     const version = readPackageVersion();
     fs.mkdirSync(root, { recursive: true });
     const skillsDir = path.join(root, "skills");
-    fs.rmSync(skillsDir, { recursive: true, force: true });
+    (0, argus_1.removeSkillDirs)(skillsDir, argus_1.ORY_SKILL_NAMES);
     (0, argus_1.writeSkillTree)(skillsDir, (0, argus_1.renderOrySkills)("antigravity", RENDER_OPTS));
     const cmdDir = path.join(root, "commands", CMD_SUBDIR);
     fs.rmSync(cmdDir, { recursive: true, force: true });
@@ -143,9 +174,31 @@ function installAntigravityOryAssets(root) {
     for (const cmd of (0, argus_1.renderOryCommands)("antigravity", RENDER_OPTS)) {
         fs.writeFileSync(path.join(cmdDir, `${cmd.slug}.toml`), (0, argus_1.commandToToml)(cmd));
     }
-    fs.writeFileSync(path.join(root, "hooks.json"), JSON.stringify(renderHooks(version), null, 2) + "\n");
-    fs.writeFileSync(path.join(root, "mcp_config.json"), JSON.stringify(renderMcpConfig(version), null, 2) + "\n");
-    fs.writeFileSync(path.join(root, "plugin.json"), JSON.stringify(renderManifest(version), null, 2) + "\n");
+    // hooks.json is keyed by rule id — replace only the "ory" rule and keep
+    // any rules the user has defined alongside it.
+    const hooksPath = path.join(root, "hooks.json");
+    const hooks = readJsonObject(hooksPath) ?? {};
+    hooks[exports.PLUGIN_NAME] = renderHooks(version)[exports.PLUGIN_NAME];
+    writeJson(hooksPath, hooks);
+    // mcp_config.json — replace only the Ory server entry under `mcpServers`,
+    // preserving other servers and any unrelated top-level keys.
+    const mcpPath = path.join(root, "mcp_config.json");
+    const mcp = readJsonObject(mcpPath) ?? {};
+    const existingServers = mcp.mcpServers;
+    const servers = existingServers && typeof existingServers === "object" && !Array.isArray(existingServers)
+        ? existingServers
+        : {};
+    servers[exports.PLUGIN_NAME] = renderMcpConfig(version).mcpServers[exports.PLUGIN_NAME];
+    mcp.mcpServers = servers;
+    writeJson(mcpPath, mcp);
+    // plugin.json — only write over a manifest that is Ory's own (or absent).
+    const manifestPath = path.join(root, "plugin.json");
+    if (!fs.existsSync(manifestPath) || isOryManifest(readJsonObject(manifestPath))) {
+        writeJson(manifestPath, renderManifest(version));
+    }
+    else {
+        console.warn(`Warning: ${manifestPath} exists and is not the Ory plugin manifest; leaving it untouched.`);
+    }
 }
 function safeRmEmpty(dir) {
     try {
@@ -157,7 +210,14 @@ function safeRmEmpty(dir) {
         /* leave the dir if removal fails */
     }
 }
-/** Remove every Ory skill, command, and bundle file written under `root`. */
+/**
+ * Remove every Ory skill, command, and bundle entry written under `root`.
+ *
+ * Mirror of the merge-aware install: only Ory-owned keys are removed from
+ * `hooks.json` / `mcp_config.json`, and each file is deleted only when it
+ * becomes empty. `plugin.json` is deleted only when it is Ory's own
+ * manifest. Unparseable files are left untouched.
+ */
 function uninstallAntigravityOryAssets(root) {
     const skillsDir = path.join(root, "skills");
     if (fs.existsSync(skillsDir)) {
@@ -174,9 +234,42 @@ function uninstallAntigravityOryAssets(root) {
         safeRmEmpty(cmdDir);
         safeRmEmpty(path.join(root, "commands"));
     }
-    for (const f of ["hooks.json", "mcp_config.json", "plugin.json"]) {
-        const p = path.join(root, f);
-        if (fs.existsSync(p))
-            fs.unlinkSync(p);
+    // hooks.json — drop only the Ory rule id.
+    const hooksPath = path.join(root, "hooks.json");
+    const hooks = readJsonObject(hooksPath);
+    if (hooks && exports.PLUGIN_NAME in hooks) {
+        delete hooks[exports.PLUGIN_NAME];
+        if (Object.keys(hooks).length === 0) {
+            fs.unlinkSync(hooksPath);
+        }
+        else {
+            writeJson(hooksPath, hooks);
+        }
+    }
+    // mcp_config.json — drop only the Ory server entry.
+    const mcpPath = path.join(root, "mcp_config.json");
+    const mcp = readJsonObject(mcpPath);
+    if (mcp) {
+        const servers = mcp.mcpServers;
+        if (servers &&
+            typeof servers === "object" &&
+            !Array.isArray(servers) &&
+            exports.PLUGIN_NAME in servers) {
+            delete servers[exports.PLUGIN_NAME];
+            if (Object.keys(servers).length === 0) {
+                delete mcp.mcpServers;
+            }
+            if (Object.keys(mcp).length === 0) {
+                fs.unlinkSync(mcpPath);
+            }
+            else {
+                writeJson(mcpPath, mcp);
+            }
+        }
+    }
+    // plugin.json — delete only when it is Ory's own manifest.
+    const manifestPath = path.join(root, "plugin.json");
+    if (fs.existsSync(manifestPath) && isOryManifest(readJsonObject(manifestPath))) {
+        fs.unlinkSync(manifestPath);
     }
 }

package/dist/emit.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Write-once stdout emitter for the Antigravity hook.
+ *
+ * Antigravity parses the hook's stdout as a single JSON document and
+ * FAILS CLOSED on malformed output. If two code paths both write (e.g.
+ * the main path writes the decision and then `tracer.shutdown()` rejects,
+ * landing in the top-level catch which writes FAIL_OPEN again), stdout
+ * carries two concatenated JSON documents and the harness blocks the
+ * tool. This factory guarantees exactly one write ever reaches stdout.
+ */
+export type EmitOnce<T> = (output: T) => boolean;
+/**
+ * Create an emitter that serializes `output` as JSON and writes it via
+ * `write` on the first call only. Subsequent calls are no-ops that
+ * return `false`.
+ */
+export declare function createEmitOnce<T>(write?: (chunk: string) => void): EmitOnce<T>;

package/dist/emit.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Write-once stdout emitter for the Antigravity hook.
+ *
+ * Antigravity parses the hook's stdout as a single JSON document and
+ * FAILS CLOSED on malformed output. If two code paths both write (e.g.
+ * the main path writes the decision and then `tracer.shutdown()` rejects,
+ * landing in the top-level catch which writes FAIL_OPEN again), stdout
+ * carries two concatenated JSON documents and the harness blocks the
+ * tool. This factory guarantees exactly one write ever reaches stdout.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmitOnce = createEmitOnce;
+/**
+ * Create an emitter that serializes `output` as JSON and writes it via
+ * `write` on the first call only. Subsequent calls are no-ops that
+ * return `false`.
+ */
+function createEmitOnce(write = (chunk) => {
+    process.stdout.write(chunk);
+}) {
+    let wrote = false;
+    return (output) => {
+        if (wrote)
+            return false;
+        wrote = true;
+        write(JSON.stringify(output));
+        return true;
+    };
+}

package/dist/hook.js

@@ -18,9 +18,18 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const argus_1 = require("@ory/argus");
+const emit_js_1 = require("./emit.js");
 const handlers_js_1 = require("./handlers.js");
 /** The fail-open response: explicitly allow, so a crash never blocks. */
 const FAIL_OPEN = { allow_tool: true };
+/**
+ * Single write-once gate shared by every exit path (normal, parse
+ * failure, and the top-level catch). Because Antigravity fails closed on
+ * malformed stdout, a double write (two concatenated JSON documents)
+ * would BLOCK the tool — e.g. when the main path writes its decision and
+ * `tracer.shutdown()` then rejects into the top-level catch.
+ */
+const emit = (0, emit_js_1.createEmitOnce)();
 /**
  * Read all of stdin as a string. Uses event listeners (not `for await`)
  * with an idle timer so we don't hang if the parent never sends EOF.
@@ -60,7 +69,7 @@ async function main() {
     catch {
         client.logger.error("hook.stdin.parse_failed", { raw: raw.slice(0, 200) });
         // Can't tell the event; allow to avoid wedging a PreToolUse call.
-        process.stdout.write(JSON.stringify(FAIL_OPEN));
+        emit(FAIL_OPEN);
         await client.tracer.shutdown();
         process.exit(0);
     }
@@ -75,13 +84,15 @@ async function main() {
         });
         output = FAIL_OPEN;
     }
-    process.stdout.write(JSON.stringify(output));
+    emit(output);
     await client.tracer.shutdown();
     process.exit(0);
 }
 main().catch((err) => {
-    // Last-resort guard: allow rather than block, then exit cleanly.
+    // Last-resort guard: allow rather than block, then exit cleanly. The
+    // write-once emitter makes this a no-op when the decision was already
+    // written before the rejection (e.g. a failing tracer shutdown).
     process.stderr.write(`[ory-agent] fatal: ${err}\n`);
-    process.stdout.write(JSON.stringify(FAIL_OPEN));
+    emit(FAIL_OPEN);
     process.exit(0);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ory/antigravity",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Ory plugin for Google Antigravity: scaffolding skills, a local Ory instance, and authentication, authorization, and audit for every tool call",
   "license": "Apache-2.0",
   "homepage": "https://github.com/ory/ory-agent-plugins/tree/main/packages/antigravity",
@@ -72,7 +72,7 @@
     "!dist/**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@ory/argus": "0.10.0"
+    "@ory/argus": "0.11.1"
   },
   "devDependencies": {
     "typescript": "^6.0.2",