codiedev 0.9.68 → 0.9.70

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/hook.js

@@ -546,6 +546,7 @@ async function main() {
     // which is what makes a pnpm install safe to upgrade.
     if (migrated.length === 0)
         (0, selfUpdate_1.maybeSpawnSelfUpdate)(process.argv[1]);
+    (0, selfUpdate_1.maybeRefreshInstructions)();
     let hookInput = {};
     try {
         const raw = await readStdin();

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/dist/selfUpdate.d.ts

@@ -38,6 +38,13 @@ export declare function readSelfUpdateState(): SelfUpdateState | null;
  * child, not one each; the child's lock covers whatever still slips through.
  */
 export declare function maybeSpawnSelfUpdate(hookEntry: string | undefined): void;
+/**
+ * First hook call on a new CLI version (self-updated or installed by hand)
+ * re-renders the codiedev block in the harness instruction files, so they
+ * stop listing commands this version no longer has. The steady-state cost is
+ * one small file read. Honors the same opt-outs as the self-update.
+ */
+export declare function maybeRefreshInstructions(refresh?: () => string[]): void;
 /**
  * Where the just-installed copy lives. npm/bun reinstall in place. pnpm's
  * `root -g` is <root>/node_modules up to v10 but the bare global/v11 parent

package/dist/selfUpdate.js

@@ -48,6 +48,7 @@ exports.planSelfUpdate = planSelfUpdate;
 exports.isSelfUpdateDue = isSelfUpdateDue;
 exports.readSelfUpdateState = readSelfUpdateState;
 exports.maybeSpawnSelfUpdate = maybeSpawnSelfUpdate;
+exports.maybeRefreshInstructions = maybeRefreshInstructions;
 exports.findInstalledHookScript = findInstalledHookScript;
 exports.runSelfUpdate = runSelfUpdate;
 const fs = __importStar(require("fs"));
@@ -58,6 +59,7 @@ const versionCheck_1 = require("./versionCheck");
 const configDir_1 = require("./configDir");
 const captureLog_1 = require("./captureLog");
 const launcher_1 = require("./launcher");
+const utils_1 = require("./utils");
 const PKG = "codiedev";
 const DAY_MS = 24 * 60 * 60 * 1000;
 const LOCK_STALE_MS = 10 * 60 * 1000;
@@ -161,6 +163,43 @@ function maybeSpawnSelfUpdate(hookEntry) {
         // Best-effort; a failed spawn retries tomorrow.
     }
 }
+function instructionsVersionPath() {
+    return path.join((0, configDir_1.codiedevStateDir)(), ".instructions-version");
+}
+/**
+ * First hook call on a new CLI version (self-updated or installed by hand)
+ * re-renders the codiedev block in the harness instruction files, so they
+ * stop listing commands this version no longer has. The steady-state cost is
+ * one small file read. Honors the same opt-outs as the self-update.
+ */
+function maybeRefreshInstructions(refresh = utils_1.refreshInstalledInstructions) {
+    if (process.env.CODIEDEV_NO_AUTO_UPDATE || process.env.CODIEDEV_NO_UPDATE_CHECK)
+        return;
+    try {
+        const marker = instructionsVersionPath();
+        try {
+            if (fs.readFileSync(marker, "utf8").trim() === version_1.CLI_VERSION)
+                return;
+        }
+        catch {
+            // No marker yet: first run on a version that ships this check.
+        }
+        const refreshed = refresh();
+        fs.mkdirSync((0, configDir_1.codiedevStateDir)(), { recursive: true });
+        fs.writeFileSync(marker, version_1.CLI_VERSION, "utf8");
+        if (refreshed.length > 0) {
+            (0, captureLog_1.appendCaptureLog)({
+                stage: "self-update",
+                sessionId: undefined,
+                outcome: "ok",
+                detail: `result=instructions-refreshed version=${version_1.CLI_VERSION} files=${refreshed.length}`,
+            });
+        }
+    }
+    catch {
+        // Best-effort; retried on the next hook call.
+    }
+}
 function acquireLock() {
     const lock = lockPath();
     try {

package/dist/utils.d.ts

@@ -129,6 +129,19 @@ export declare function installCodexInstructions(): void;
 export declare function copilotInstructionsPath(): string;
 export declare function installCopilotInstructions(): void;
 export declare function installCursorInstructions(): void;
+export interface InstructionsTarget {
+    path: string;
+    body: string;
+}
+export declare function installedInstructionsTargets(): InstructionsTarget[];
+/**
+ * Re-render the codiedev block in every instructions file that already has
+ * one, so an upgrade (background self-update or a manual `npm i`) stops
+ * teaching retired commands without the user re-running `connect`. Never
+ * creates a file or adds a block: a user who deleted it, or never connected
+ * that harness, is left alone. Returns the paths it rewrote.
+ */
+export declare function refreshInstalledInstructions(targets?: InstructionsTarget[]): string[];
 /**
  * Install the Codiedev MCP server into Claude Code's user-scope config.
  * Safe to call multiple times — updates the existing entry if present.

package/dist/utils.js

@@ -79,6 +79,8 @@ exports.installCodexInstructions = installCodexInstructions;
 exports.copilotInstructionsPath = copilotInstructionsPath;
 exports.installCopilotInstructions = installCopilotInstructions;
 exports.installCursorInstructions = installCursorInstructions;
+exports.installedInstructionsTargets = installedInstructionsTargets;
+exports.refreshInstalledInstructions = refreshInstalledInstructions;
 exports.installClaudeCodeMcp = installClaudeCodeMcp;
 exports.installCursorMcp = installCursorMcp;
 exports.installVSCodeMcp = installVSCodeMcp;
@@ -1645,6 +1647,45 @@ function installCursorInstructions() {
     }
     fs.writeFileSync(CURSOR_RULES_PATH, next, "utf8");
 }
+function installedInstructionsTargets() {
+    const withTeamContext = `${teamSkillContext_1.TEAM_SKILL_CONTEXT}\n\n${CODIEDEV_INSTRUCTIONS_BODY}`;
+    return [
+        { path: CLAUDE_USER_INSTRUCTIONS_PATH, body: CODIEDEV_INSTRUCTIONS_BODY },
+        { path: CODEX_USER_INSTRUCTIONS_PATH, body: CODIEDEV_INSTRUCTIONS_BODY },
+        { path: copilotInstructionsPath(), body: withTeamContext },
+        { path: CURSOR_RULES_PATH, body: withTeamContext },
+    ];
+}
+/**
+ * Re-render the codiedev block in every instructions file that already has
+ * one, so an upgrade (background self-update or a manual `npm i`) stops
+ * teaching retired commands without the user re-running `connect`. Never
+ * creates a file or adds a block: a user who deleted it, or never connected
+ * that harness, is left alone. Returns the paths it rewrote.
+ */
+function refreshInstalledInstructions(targets = installedInstructionsTargets()) {
+    const refreshed = [];
+    for (const target of targets) {
+        try {
+            const existing = fs.readFileSync(target.path, "utf8");
+            const beginIdx = existing.indexOf(CODIEDEV_INSTRUCTIONS_BEGIN);
+            const endIdx = existing.indexOf(CODIEDEV_INSTRUCTIONS_END);
+            if (beginIdx === -1 || endIdx === -1 || endIdx <= beginIdx)
+                continue;
+            const next = existing.slice(0, beginIdx) +
+                `${CODIEDEV_INSTRUCTIONS_BEGIN}\n${target.body}\n${CODIEDEV_INSTRUCTIONS_END}` +
+                existing.slice(endIdx + CODIEDEV_INSTRUCTIONS_END.length);
+            if (next === existing)
+                continue;
+            fs.writeFileSync(target.path, next, "utf8");
+            refreshed.push(target.path);
+        }
+        catch {
+            // Missing or unreadable file: nothing of ours to refresh.
+        }
+    }
+    return refreshed;
+}
 function readMcpConfigSafely(path) {
     if (!fs.existsSync(path))
         return {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.68",
+  "version": "0.9.70",
   "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",