@cjhyy/code-shell-core 0.7.1 → 0.8.1

package/dist/plugins/pluginCommandsLoader.js

@@ -5,12 +5,16 @@
  * MVP subset (single-level commands directory, no nested subcommands,
  * no inline-via-plugin.json commands).
  */
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { closeSync, constants, existsSync, fstatSync, openSync, readdirSync, readSync, realpathSync, statSync, } from "node:fs";
+import { isAbsolute, join, relative, sep } from "node:path";
 import { homedir } from "node:os";
 import { memoize } from "../utils/memoize.js";
 import { parseFrontmatter, coerceDescription } from "../skills/frontmatter.js";
 import { installedPluginsPath, readInstalledPlugins } from "./installedPlugins.js";
+/** Bounded prompt contribution limits shared by Desktop, TUI, and protocol hosts. */
+export const MAX_PLUGIN_COMMAND_FILE_BYTES = 256 * 1024;
+export const MAX_PLUGIN_COMMAND_ARGUMENT_CHARS = 32 * 1024;
+export const MAX_PLUGIN_COMMAND_EXPANDED_CHARS = 512 * 1024;
 function isENOENT(e) {
     return (typeof e === "object" && e !== null && "code" in e && e.code === "ENOENT");
 }
@@ -18,14 +22,34 @@ function isInaccessible(e) {
     if (typeof e !== "object" || e === null || !("code" in e))
         return false;
     const code = e.code;
-    return code === "EACCES" || code === "EPERM" || code === "EIO";
+    return code === "EACCES" || code === "EPERM" || code === "EIO" || code === "ELOOP";
 }
 function userHome() {
     return process.env.HOME ?? homedir();
 }
 function readCommandFile(filePath) {
+    let fd;
     try {
-        return readFileSync(filePath, "utf-8");
+        fd = openSync(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > MAX_PLUGIN_COMMAND_FILE_BYTES)
+            return null;
+        const chunks = [];
+        let total = 0;
+        while (true) {
+            const remaining = MAX_PLUGIN_COMMAND_FILE_BYTES + 1 - total;
+            if (remaining <= 0)
+                return null;
+            const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, remaining));
+            const bytesRead = readSync(fd, chunk, 0, chunk.length, null);
+            if (bytesRead === 0)
+                break;
+            total += bytesRead;
+            if (total > MAX_PLUGIN_COMMAND_FILE_BYTES)
+                return null;
+            chunks.push(chunk.subarray(0, bytesRead));
+        }
+        return Buffer.concat(chunks, total).toString("utf-8");
     }
     catch (e) {
         if (isENOENT(e))
@@ -37,6 +61,29 @@ function readCommandFile(filePath) {
         }
         throw e;
     }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+/**
+ * Resolve a plugin contribution through symlinks and require it to remain
+ * inside its declared owner directory. Installed plugin trees are untrusted:
+ * without this check `commands -> /some/private/dir` or `command.md` symlinks
+ * could make the host read arbitrary local Markdown and expose it as a prompt.
+ */
+function resolveContainedPath(root, candidate) {
+    try {
+        const realRoot = realpathSync(root);
+        const realCandidate = realpathSync(candidate);
+        const rel = relative(realRoot, realCandidate);
+        if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+            return null;
+        return realCandidate;
+    }
+    catch {
+        return null;
+    }
 }
 function scanOnce() {
     const data = readInstalledPlugins();
@@ -51,14 +98,17 @@ function scanOnce() {
             const commandsDir = join(entry.installPath, "commands");
             if (!existsSync(commandsDir))
                 continue;
+            const resolvedCommandsDir = resolveContainedPath(entry.installPath, commandsDir);
+            if (!resolvedCommandsDir)
+                continue;
             let dirEntries;
             try {
-                dirEntries = readdirSync(commandsDir, { withFileTypes: true });
+                dirEntries = readdirSync(resolvedCommandsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
             }
             catch (e) {
                 if (isInaccessible(e)) {
                     // eslint-disable-next-line no-console
-                    console.warn(`[plugin-commands] cannot read ${commandsDir}: ${e.message}`);
+                    console.warn(`[plugin-commands] cannot read ${resolvedCommandsDir}: ${e.message}`);
                     continue;
                 }
                 throw e;
@@ -68,7 +118,17 @@ function scanOnce() {
                     continue;
                 if (!dirent.name.endsWith(".md"))
                     continue;
-                const filePath = join(commandsDir, dirent.name);
+                const filePath = resolveContainedPath(resolvedCommandsDir, join(resolvedCommandsDir, dirent.name));
+                if (!filePath)
+                    continue;
+                try {
+                    const fileStat = statSync(filePath);
+                    if (!fileStat.isFile() || fileStat.size > MAX_PLUGIN_COMMAND_FILE_BYTES)
+                        continue;
+                }
+                catch {
+                    continue;
+                }
                 const raw = readCommandFile(filePath);
                 if (raw === null)
                     continue;
@@ -112,3 +172,117 @@ export function scanPluginCommands() {
 export function invalidatePluginCommandsCache() {
     memoized.cache.clear?.();
 }
+function parsePluginCommandArguments(input) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let escaping = false;
+    const push = () => {
+        if (current.length === 0)
+            return;
+        tokens.push(current);
+        current = "";
+    };
+    for (const character of input.trim()) {
+        if (escaping) {
+            current += character;
+            escaping = false;
+            continue;
+        }
+        if (character === "\\" && quote !== "'") {
+            escaping = true;
+            continue;
+        }
+        if (quote) {
+            if (character === quote)
+                quote = null;
+            else
+                current += character;
+            continue;
+        }
+        if (character === "'" || character === '"') {
+            quote = character;
+            continue;
+        }
+        if (/\s/u.test(character)) {
+            push();
+            continue;
+        }
+        current += character;
+    }
+    if (escaping)
+        current += "\\";
+    push();
+    const positional = [];
+    const named = new Map();
+    for (const token of tokens) {
+        const assignment = /^([A-Z][A-Z0-9_]*)=(.*)$/u.exec(token);
+        if (assignment)
+            named.set(assignment[1], assignment[2]);
+        else
+            positional.push(token);
+    }
+    return { positional, named };
+}
+export function describePluginCommands(commands, disabledPluginNames = new Set()) {
+    return commands
+        .filter((command) => !disabledPluginNames.has(command.pluginName))
+        .map((command) => ({
+        name: command.name,
+        pluginName: command.pluginName,
+        description: command.description,
+        ...(command.argumentHint ? { argumentHint: command.argumentHint } : {}),
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+const PLUGIN_COMMAND_PLACEHOLDER = /\$\$|\$ARGUMENTS|\{args\}|\$([1-9])|\$([A-Z][A-Z0-9_]*)(?![A-Z0-9_])/gu;
+function pluginCommandReplacement(token, positionalIndex, namedPlaceholder, rawArguments, parsed) {
+    if (token === "$$")
+        return "$";
+    if (token === "$ARGUMENTS" || token === "{args}")
+        return rawArguments;
+    if (positionalIndex)
+        return parsed.positional[Number(positionalIndex) - 1] ?? "";
+    if (namedPlaceholder && parsed.named.has(namedPlaceholder)) {
+        return parsed.named.get(namedPlaceholder);
+    }
+    return token;
+}
+function assertExpansionBudget(body, rawArguments, parsed) {
+    if (Buffer.byteLength(body, "utf-8") > MAX_PLUGIN_COMMAND_FILE_BYTES) {
+        throw new Error(`plugin command body exceeds ${MAX_PLUGIN_COMMAND_FILE_BYTES} bytes`);
+    }
+    if (rawArguments.length > MAX_PLUGIN_COMMAND_ARGUMENT_CHARS) {
+        throw new Error(`plugin command arguments exceed ${MAX_PLUGIN_COMMAND_ARGUMENT_CHARS} characters`);
+    }
+    let projected = body.length;
+    for (const match of body.matchAll(PLUGIN_COMMAND_PLACEHOLDER)) {
+        projected +=
+            pluginCommandReplacement(match[0], match[1], match[2], rawArguments, parsed).length -
+                match[0].length;
+        if (projected > MAX_PLUGIN_COMMAND_EXPANDED_CHARS)
+            break;
+    }
+    if (projected > MAX_PLUGIN_COMMAND_EXPANDED_CHARS) {
+        throw new Error(`expanded plugin command exceeds ${MAX_PLUGIN_COMMAND_EXPANDED_CHARS} characters`);
+    }
+}
+/**
+ * Expand CC/CodeShell and deprecated Codex custom-prompt placeholders.
+ *
+ * Codex plugins in the wild still ship `prompts/*.md`, so compatibility needs
+ * `$1`…`$9`, named `KEY=value` placeholders, `$ARGUMENTS`, and `$$` literals
+ * even though new upstream workflows are expected to use skills.
+ */
+export function expandPluginCommandBody(body, rawArguments = "") {
+    if (rawArguments.length > MAX_PLUGIN_COMMAND_ARGUMENT_CHARS) {
+        throw new Error(`plugin command arguments exceed ${MAX_PLUGIN_COMMAND_ARGUMENT_CHARS} characters`);
+    }
+    const parsed = parsePluginCommandArguments(rawArguments);
+    assertExpansionBudget(body, rawArguments, parsed);
+    const expanded = body.replace(PLUGIN_COMMAND_PLACEHOLDER, (token, positionalIndex, namedPlaceholder) => pluginCommandReplacement(token, positionalIndex, namedPlaceholder, rawArguments, parsed));
+    if (expanded.length > MAX_PLUGIN_COMMAND_EXPANDED_CHARS) {
+        throw new Error(`expanded plugin command exceeds ${MAX_PLUGIN_COMMAND_EXPANDED_CHARS} characters`);
+    }
+    return expanded;
+}

package/dist/plugins/pluginContent.d.ts

@@ -6,6 +6,11 @@
  * loaders use so the inventory can't drift from what actually loads.
  */
 import { type PluginHookEntry } from "./loadPluginHooks.js";
+import { type PluginHookReview } from "./pluginHookApproval.js";
+import { type PluginAutomationTemplate } from "./installer/types.js";
+export type PluginAutomationTemplateDescriptor = PluginAutomationTemplate & {
+    revision: string;
+};
 export interface PluginContentInventory {
     /** skills/<name>/SKILL.md — name + frontmatter description when present. */
     skills: {
@@ -18,8 +23,12 @@ export interface PluginContentInventory {
     agents: string[];
     /** hooks/hooks.json entries (event + command), owner-filtered. */
     hooks: PluginHookEntry[];
+    /** Current hook definition compared with the last explicitly approved snapshot. */
+    hookReview?: PluginHookReview;
     /** MCP server names as merged (keyed `<plugin>:<server>` — bare name here). */
     mcpServers: string[];
+    /** Reusable scheduled-task templates; never instantiated automatically. */
+    automationTemplates: PluginAutomationTemplateDescriptor[];
 }
 /**
  * Inventory one plugin's contributions. `pluginName` is the bare name (no
@@ -27,4 +36,4 @@ export interface PluginContentInventory {
  * scanners the runtime loaders use (filtered to this plugin) so naming —
  * e.g. MCP's `<plugin>:<server>` record keys — matches what users see live.
  */
-export declare function describePluginContent(pluginName: string, installPath: string): PluginContentInventory;
+export declare function describePluginContent(pluginName: string, installPath: string, installKey?: string): PluginContentInventory;

package/dist/plugins/pluginContent.js

@@ -5,17 +5,46 @@
  * actually installs (feedback#15). Read-only; reuses the same parsers the
  * loaders use so the inventory can't drift from what actually loads.
  */
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, sep } from "node:path";
 import { parseFrontmatter } from "../skills/frontmatter.js";
 import { listPluginHooks } from "./loadPluginHooks.js";
-import { mergePluginMcpServers } from "./installer/loadPluginMcp.js";
-function listMdNames(dir) {
-    if (!existsSync(dir))
+import { reviewPluginHooks } from "./pluginHookApproval.js";
+import { readPluginMcp } from "./installer/loadPluginMcp.js";
+import { CANONICAL_PLUGIN_MANIFEST_FILE, CanonicalPluginManifest, } from "./installer/types.js";
+import { pluginAutomationTemplateRevision } from "./pluginCatalog.js";
+function resolveContainedPath(root, candidate) {
+    try {
+        const realRoot = realpathSync(root);
+        const realCandidate = realpathSync(candidate);
+        const rel = relative(realRoot, realCandidate);
+        if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+            return null;
+        return realCandidate;
+    }
+    catch {
+        return null;
+    }
+}
+function listMdNames(installPath, dirName) {
+    const dir = resolveContainedPath(installPath, join(installPath, dirName));
+    if (!dir)
         return [];
     try {
         return readdirSync(dir)
-            .filter((f) => f.endsWith(".md"))
+            .filter((file) => {
+            if (!file.endsWith(".md"))
+                return false;
+            const target = resolveContainedPath(dir, join(dir, file));
+            if (!target)
+                return false;
+            try {
+                return statSync(target).isFile();
+            }
+            catch {
+                return false;
+            }
+        })
             .map((f) => f.replace(/\.md$/, ""))
             .sort();
     }
@@ -24,15 +53,18 @@ function listMdNames(dir) {
     }
 }
 function listSkills(installPath) {
-    const dir = join(installPath, "skills");
-    if (!existsSync(dir))
+    const dir = resolveContainedPath(installPath, join(installPath, "skills"));
+    if (!dir)
         return [];
     const out = [];
     try {
         for (const entry of readdirSync(dir).sort()) {
-            const skillMd = join(dir, entry, "SKILL.md");
             try {
-                if (!statSync(join(dir, entry)).isDirectory() || !existsSync(skillMd))
+                const skillDir = resolveContainedPath(dir, join(dir, entry));
+                if (!skillDir || !statSync(skillDir).isDirectory())
+                    continue;
+                const skillMd = resolveContainedPath(skillDir, join(skillDir, "SKILL.md"));
+                if (!skillMd || !statSync(skillMd).isFile())
                     continue;
                 const { frontmatter } = parseFrontmatter(readFileSync(skillMd, "utf-8"));
                 const desc = typeof frontmatter.description === "string" ? frontmatter.description : undefined;
@@ -54,30 +86,55 @@ function listSkills(installPath) {
  * scanners the runtime loaders use (filtered to this plugin) so naming —
  * e.g. MCP's `<plugin>:<server>` record keys — matches what users see live.
  */
-export function describePluginContent(pluginName, installPath) {
+export function describePluginContent(pluginName, installPath, installKey) {
     const mcpPrefix = `${pluginName}:`;
-    let mcpServers = [];
-    try {
-        mcpServers = Object.keys(mergePluginMcpServers({}))
-            .filter((k) => k.startsWith(mcpPrefix))
-            .map((k) => k.slice(mcpPrefix.length))
-            .sort();
-    }
-    catch {
-        mcpServers = [];
-    }
-    let hooks = [];
-    try {
-        hooks = listPluginHooks().filter((h) => h.plugin === pluginName);
-    }
-    catch {
-        hooks = [];
-    }
+    const mcpServers = (() => {
+        try {
+            return Object.keys(readPluginMcp(installPath, pluginName))
+                .filter((k) => k.startsWith(mcpPrefix))
+                .map((k) => k.slice(mcpPrefix.length))
+                .sort();
+        }
+        catch {
+            return [];
+        }
+    })();
+    const hooks = (() => {
+        try {
+            return listPluginHooks().filter((h) => h.plugin === pluginName && (installKey === undefined || h.installKey === installKey));
+        }
+        catch {
+            return [];
+        }
+    })();
+    const hookReview = (() => {
+        if (!installKey)
+            return undefined;
+        try {
+            return reviewPluginHooks(installKey)[0];
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const manifest = (() => {
+        try {
+            return CanonicalPluginManifest.parse(JSON.parse(readFileSync(join(installPath, CANONICAL_PLUGIN_MANIFEST_FILE), "utf-8")));
+        }
+        catch {
+            return null;
+        }
+    })();
     return {
         skills: listSkills(installPath),
-        commands: listMdNames(join(installPath, "commands")),
-        agents: listMdNames(join(installPath, "agents")),
+        commands: listMdNames(installPath, "commands"),
+        agents: listMdNames(installPath, "agents"),
         hooks,
+        ...(hookReview ? { hookReview } : {}),
         mcpServers,
+        automationTemplates: (manifest?.automations?.templates ?? []).map((template) => ({
+            ...template,
+            revision: pluginAutomationTemplateRevision(installKey ?? pluginName, template),
+        })),
     };
 }

package/dist/plugins/pluginHookApproval.d.ts

@@ -0,0 +1,30 @@
+import { type PluginHookApprovalState } from "./pluginHookIntegrity.js";
+import type { StoredPluginHookReview } from "./types.js";
+export interface PluginHookApprovalResult {
+    installKey: string;
+    plugin: string;
+    status: PluginHookApprovalState;
+    changed: boolean;
+}
+export interface PluginHookReviewDiffItem {
+    change: "added" | "removed" | "changed" | "unchanged";
+    current?: StoredPluginHookReview;
+    previous?: StoredPluginHookReview;
+}
+export interface PluginHookReview {
+    installKey: string;
+    plugin: string;
+    status: PluginHookApprovalState;
+    baselineAvailable: boolean;
+    items: PluginHookReviewDiffItem[];
+    error?: string;
+}
+/** Review current hooks against the last explicitly approved per-command snapshot. */
+export declare function reviewPluginHooks(target: string): PluginHookReview[];
+/** Approve the exact install-time digest; changed-on-disk hooks cannot be blessed. */
+export declare function approvePluginHooks(target: string): PluginHookApprovalResult[];
+/**
+ * Revoke hook execution. Legacy entries are first migrated to a recorded
+ * digest so revocation fails closed instead of falling back to legacy trust.
+ */
+export declare function revokePluginHooks(target: string): PluginHookApprovalResult[];

package/dist/plugins/pluginHookApproval.js

@@ -0,0 +1,160 @@
+import { readInstalledPlugins, writeInstalledPlugins } from "./installedPlugins.js";
+import { inspectPluginHooks, pluginHookReviewSnapshot, pluginHookApprovalState, } from "./pluginHookIntegrity.js";
+function pluginNameFromKey(key) {
+    const at = key.lastIndexOf("@");
+    return at > 0 ? key.slice(0, at) : key;
+}
+function matchingInstallKeys(data, target) {
+    if (!target.trim())
+        throw new Error("plugin hook approval requires a plugin name or install key");
+    if (data.plugins[target])
+        return [target];
+    const matches = Object.keys(data.plugins).filter((key) => pluginNameFromKey(key) === target);
+    if (matches.length === 0)
+        throw new Error(`plugin "${target}" is not installed`);
+    if (matches.length > 1) {
+        throw new Error(`plugin "${target}" has multiple installs; use one of: ${matches.join(", ")}`);
+    }
+    return matches;
+}
+function result(installKey, entry, changed, snapshot) {
+    return {
+        installKey,
+        plugin: pluginNameFromKey(installKey),
+        status: pluginHookApprovalState(entry, snapshot),
+        changed,
+    };
+}
+function sameReviewHook(a, b) {
+    return (a.rawEvent === b.rawEvent &&
+        a.matcher === b.matcher &&
+        a.commandDigest === b.commandDigest &&
+        a.async === b.async &&
+        a.timeoutMs === b.timeoutMs);
+}
+function diffHookReview(current, previous) {
+    if (previous === undefined)
+        return current.map((hook) => ({ change: "added", current: hook }));
+    const unused = new Set(previous.map((_, index) => index));
+    const items = [];
+    for (const hook of current) {
+        const exact = [...unused].find((index) => sameReviewHook(hook, previous[index]));
+        if (exact !== undefined) {
+            unused.delete(exact);
+            items.push({ change: "unchanged", current: hook, previous: previous[exact] });
+            continue;
+        }
+        let changed = [...unused].find((index) => {
+            const old = previous[index];
+            return (old.rawEvent === hook.rawEvent &&
+                (old.commandDigest === hook.commandDigest || old.matcher === hook.matcher));
+        });
+        // If both command and matcher changed, pair the remaining command at the
+        // same event when that match is unambiguous instead of presenting a noisy
+        // remove+add pair.
+        if (changed === undefined) {
+            const sameEvent = [...unused].filter((index) => previous[index].rawEvent === hook.rawEvent);
+            if (sameEvent.length === 1)
+                changed = sameEvent[0];
+        }
+        if (changed !== undefined) {
+            unused.delete(changed);
+            items.push({ change: "changed", current: hook, previous: previous[changed] });
+            continue;
+        }
+        items.push({ change: "added", current: hook });
+    }
+    for (const index of unused)
+        items.push({ change: "removed", previous: previous[index] });
+    return items;
+}
+function review(installKey, entry) {
+    const snapshot = inspectPluginHooks(entry.installPath);
+    return {
+        installKey,
+        plugin: pluginNameFromKey(installKey),
+        status: pluginHookApprovalState(entry, snapshot),
+        baselineAvailable: entry.approvedHookSnapshot !== undefined,
+        items: diffHookReview(pluginHookReviewSnapshot(snapshot), entry.approvedHookSnapshot),
+        ...(snapshot.error ? { error: snapshot.error } : {}),
+    };
+}
+/** Review current hooks against the last explicitly approved per-command snapshot. */
+export function reviewPluginHooks(target) {
+    const data = readInstalledPlugins();
+    return matchingInstallKeys(data, target).flatMap((installKey) => (data.plugins[installKey] ?? []).map((entry) => review(installKey, entry)));
+}
+/** Approve the exact install-time digest; changed-on-disk hooks cannot be blessed. */
+export function approvePluginHooks(target) {
+    const data = readInstalledPlugins();
+    const keys = matchingInstallKeys(data, target);
+    const out = [];
+    let writeNeeded = false;
+    for (const installKey of keys) {
+        for (const entry of data.plugins[installKey] ?? []) {
+            let entryChanged = false;
+            const snapshot = inspectPluginHooks(entry.installPath);
+            if (snapshot.state === "invalid") {
+                throw new Error(`plugin "${installKey}" hooks definition is invalid and cannot be approved: ${snapshot.error ?? "unknown error"}`);
+            }
+            if (entry.hookDigest && snapshot.digest !== entry.hookDigest) {
+                throw new Error(`plugin "${installKey}" hooks changed after install; reinstall or update before approving`);
+            }
+            if (!entry.hookDigest) {
+                entry.hookDigest = snapshot.digest;
+                entryChanged = true;
+                writeNeeded = true;
+            }
+            if (entry.approvedHookDigest !== entry.hookDigest) {
+                entry.approvedHookDigest = entry.hookDigest;
+                entryChanged = true;
+                writeNeeded = true;
+            }
+            const nextReview = pluginHookReviewSnapshot(snapshot);
+            if (JSON.stringify(entry.approvedHookSnapshot) !== JSON.stringify(nextReview)) {
+                entry.approvedHookSnapshot = nextReview;
+                entryChanged = true;
+                writeNeeded = true;
+            }
+            out.push(result(installKey, entry, entryChanged, snapshot));
+        }
+    }
+    if (writeNeeded)
+        writeInstalledPlugins(data);
+    return out;
+}
+/**
+ * Revoke hook execution. Legacy entries are first migrated to a recorded
+ * digest so revocation fails closed instead of falling back to legacy trust.
+ */
+export function revokePluginHooks(target) {
+    const data = readInstalledPlugins();
+    const keys = matchingInstallKeys(data, target);
+    const out = [];
+    let writeNeeded = false;
+    for (const installKey of keys) {
+        for (const entry of data.plugins[installKey] ?? []) {
+            let entryChanged = false;
+            const snapshot = inspectPluginHooks(entry.installPath);
+            if (!entry.hookDigest) {
+                entry.hookDigest = snapshot.digest;
+                entryChanged = true;
+            }
+            if (snapshot.hasExecutableHooks || snapshot.state === "invalid") {
+                if (entry.approvedHookDigest !== undefined) {
+                    delete entry.approvedHookDigest;
+                    entryChanged = true;
+                }
+            }
+            else if (entry.approvedHookDigest !== entry.hookDigest) {
+                entry.approvedHookDigest = entry.hookDigest;
+                entryChanged = true;
+            }
+            writeNeeded ||= entryChanged;
+            out.push(result(installKey, entry, entryChanged, snapshot));
+        }
+    }
+    if (writeNeeded)
+        writeInstalledPlugins(data);
+    return out;
+}