codiedev 0.9.68 → 0.9.69

package/dist/codexHookTrust.d.ts

@@ -17,7 +17,13 @@ export interface CodexHookTrustEntry {
     eventName: string;
     command: string;
     currentHash: string;
+    /** Plugin hooks only: Codex also pins approval to the bundle's contents. */
+    contentHash?: string;
 }
+/** Codex's fingerprint of an installed plugin bundle, byte-for-byte the
+ * algorithm in codex-rs hooks/src/engine/plugin_fingerprint.rs. Codex skips a
+ * plugin hook unless `trusted_content_hash` equals this (Codex 0.163+). */
+export declare function codexPluginContentHash(root: string): string;
 /** Codex hashes a canonical, normalized hook identity before it will execute a
  * user hook. Keep this compatible with codex_config::version_for_toml. */
 export declare function codexCommandHookHash(eventName: string, group: MatcherGroup, handler: CommandHandler): string;
@@ -32,7 +38,10 @@ export declare function inspectCodexHookTrust(configPath: string, hooksPath: str
     trusted: number;
 };
 /** Trust entries for every command handler in a pack's hooks.json. */
-export declare function packCodexHookTrustEntries(hooksPath: string, hooksFile: unknown): CodexHookTrustEntry[];
+export declare function packCodexHookTrustEntries(hooksPath: string, hooksFile: unknown, plugin?: {
+    id: string;
+    root: string;
+}): CodexHookTrustEntry[];
 /** Regenerate the pack trust block from scratch with exactly `entries`.
  * Entries for packs that were removed or whose hooks changed disappear; the
  * `codiedev-hook-trust` block and all other config are left untouched. */

package/dist/codexHookTrust.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexPluginContentHash = codexPluginContentHash;
 exports.codexCommandHookHash = codexCommandHookHash;
 exports.codiedevCodexHookTrustEntries = codiedevCodexHookTrustEntries;
 exports.writeCodexHookTrust = writeCodexHookTrust;
@@ -69,6 +70,46 @@ const MATCHER_EVENTS = new Set([
     "SubagentStart",
     "SubagentStop",
 ]);
+/** Codex's fingerprint of an installed plugin bundle, byte-for-byte the
+ * algorithm in codex-rs hooks/src/engine/plugin_fingerprint.rs. Codex skips a
+ * plugin hook unless `trusted_content_hash` equals this (Codex 0.163+). */
+function codexPluginContentHash(root) {
+    const hash = crypto.createHash("sha256");
+    hash.update("codex-plugin-bundle-v1");
+    const u64 = (n) => {
+        const b = Buffer.alloc(8);
+        b.writeBigUInt64LE(BigInt(n));
+        return b;
+    };
+    const pending = [root];
+    while (pending.length) {
+        const current = pending.pop();
+        const relative = path.relative(root, current).split(path.sep).join("/");
+        const name = path.posix.basename(relative);
+        if (name === "__pycache__" || name === ".venv" || name.endsWith(".pyc") || name.endsWith(".egg-info"))
+            continue;
+        const nameBytes = Buffer.from(relative, "utf8");
+        hash.update(u64(nameBytes.length));
+        hash.update(nameBytes);
+        const stat = fs.lstatSync(current);
+        if (stat.isDirectory()) {
+            hash.update("directory");
+            // Rust sorts by OsString, i.e. bytewise; push reversed so the smallest pops first.
+            const entries = fs.readdirSync(current).sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
+            for (const entry of entries.reverse())
+                pending.push(path.join(current, entry));
+        }
+        else if (stat.isFile()) {
+            hash.update("file");
+            hash.update(u64(stat.size));
+            hash.update(fs.readFileSync(current));
+        }
+        else {
+            throw new Error(`unsupported plugin entry type: ${current}`);
+        }
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
 function canonicalize(value) {
     if (Array.isArray(value))
         return value.map(canonicalize);
@@ -157,6 +198,32 @@ function codiedevCodexHookTrustEntries(hooksPath, hooksFile) {
     }
     return entries;
 }
+/** Remove our marker block, keeping any table that isn't a hook-trust entry.
+ * Codex appends new tables (e.g. `[marketplaces.codiedev-packs]`,
+ * `[plugins."<id>"]`) at the end of config.toml, which lands them before our
+ * closing marker when our block is last. Dropping them with the block silently
+ * unregistered the pack from Codex on every reinstall. */
+function stripBlockKeepingForeign(text, begin, end) {
+    const foreign = [];
+    const stripped = text.replace(new RegExp(`\\n?${begin}\\n([\\s\\S]*?)${end}\\n?`, "g"), (_match, body) => {
+        let table = null;
+        const flush = () => {
+            if (table && table.join("").trim())
+                foreign.push(table.join("\n").trimEnd());
+        };
+        for (const line of body.split("\n")) {
+            if (/^\s*\[/.test(line)) {
+                flush();
+                table = /^\s*\[hooks\.state\./.test(line) ? null : [];
+            }
+            if (table)
+                table.push(line);
+        }
+        flush();
+        return "\n";
+    });
+    return foreign.length ? `${stripped.trimEnd()}\n\n${foreign.join("\n\n")}\n` : stripped;
+}
 function tableHeader(key) {
     return `[hooks.state.${JSON.stringify(key)}]`;
 }
@@ -181,7 +248,7 @@ function removeTable(lines, header) {
 function writeCodexHookTrust(configPath, hooksPath, hooksFile) {
     const entries = codiedevCodexHookTrustEntries(hooksPath, hooksFile);
     let existing = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf8") : "";
-    existing = existing.replace(new RegExp(`\\n?${TRUST_BEGIN}\\n[\\s\\S]*?${TRUST_END}\\n?`, "g"), "\n");
+    existing = stripBlockKeepingForeign(existing, TRUST_BEGIN, TRUST_END);
     let lines = existing.split("\n");
     for (const entry of entries)
         lines = removeTable(lines, tableHeader(entry.key));
@@ -237,11 +304,16 @@ function inspectCodexHookTrust(configPath, hooksPath, hooksFile, requiredSubcomm
 const PACK_TRUST_BEGIN = "# codiedev-pack-trust:begin";
 const PACK_TRUST_END = "# codiedev-pack-trust:end";
 /** Trust entries for every command handler in a pack's hooks.json. */
-function packCodexHookTrustEntries(hooksPath, hooksFile) {
+function packCodexHookTrustEntries(hooksPath, hooksFile, plugin) {
     const events = hooksFile?.hooks;
     if (!events || typeof events !== "object")
         return [];
-    const source = normalizedHooksPath(hooksPath);
+    // Codex keys a plugin's hooks by "<plugin id>:<path inside the plugin>",
+    // not by the file's absolute path (codex-rs declarations::plugin_hook_key_source).
+    const source = plugin
+        ? `${plugin.id}:${path.relative(plugin.root, hooksPath).split(path.sep).join("/")}`
+        : normalizedHooksPath(hooksPath);
+    const contentHash = plugin ? codexPluginContentHash(plugin.root) : undefined;
     const entries = [];
     for (const [eventName, groupsValue] of Object.entries(events)) {
         const eventLabel = EVENT_LABELS[eventName];
@@ -260,6 +332,7 @@ function packCodexHookTrustEntries(hooksPath, hooksFile) {
                     eventName,
                     command: handler.command,
                     currentHash: codexCommandHookHash(eventName, group, handler),
+                    ...(contentHash ? { contentHash } : {}),
                 });
             });
         });
@@ -271,7 +344,7 @@ function packCodexHookTrustEntries(hooksPath, hooksFile) {
  * `codiedev-hook-trust` block and all other config are left untouched. */
 function writeCodexPackHookTrust(configPath, entries) {
     let existing = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf8") : "";
-    existing = existing.replace(new RegExp(`\\n?${PACK_TRUST_BEGIN}\\n[\\s\\S]*?${PACK_TRUST_END}\\n?`, "g"), "\n");
+    existing = stripBlockKeepingForeign(existing, PACK_TRUST_BEGIN, PACK_TRUST_END);
     let lines = existing.split("\n");
     // A stray table for the same key outside our block would make the TOML
     // invalid (duplicate table) — drop it so ours is authoritative.
@@ -291,6 +364,7 @@ function writeCodexPackHookTrust(configPath, entries) {
         tableHeader(entry.key),
         "enabled = true",
         `trusted_hash = ${JSON.stringify(entry.currentHash)}`,
+        ...(entry.contentHash ? [`trusted_content_hash = ${JSON.stringify(entry.contentHash)}`] : []),
         "",
     ]).join("\n");
     const next = `${base}${base ? "\n\n" : ""}${PACK_TRUST_BEGIN}\n${trustBlock}${PACK_TRUST_END}\n`;

package/dist/packs/install.js

@@ -94,7 +94,9 @@ function codexPackTrustEntries(registry, codexDir) {
         if (!hooksPath)
             continue;
         try {
-            bySlug.set(slug, (0, codexHookTrust_1.packCodexHookTrustEntries)(hooksPath, JSON.parse(fs.readFileSync(hooksPath, "utf8"))));
+            // hooks/hooks.json sits at the root of the installed plugin bundle.
+            const plugin = { id: `${slug}@${paths_1.MARKETPLACE_NAME}`, root: path.dirname(path.dirname(hooksPath)) };
+            bySlug.set(slug, (0, codexHookTrust_1.packCodexHookTrustEntries)(hooksPath, JSON.parse(fs.readFileSync(hooksPath, "utf8")), plugin));
         }
         catch {
             // unreadable hooks → not trusted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.68",
+  "version": "0.9.69",
   "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",