@code-yeongyu/senpi 2026.7.20 → 2026.7.22

package/dist/core/extensions/builtin/config-reload/index.js

@@ -0,0 +1,659 @@
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { basename, dirname, relative, resolve, sep } from "node:path";
+import { CONFIG_DIR_NAME, getAgentDir } from "../../../../config.js";
+import { resolvePath } from "../../../../utils/paths.js";
+import { ModelConfig } from "../../../model-config.js";
+import { SettingsManager, wasSelfWrite } from "../../../settings-manager.js";
+import { createConfigReloadLogger } from "./log.js";
+import { CONFIG_WATCH_CHANGED, CONFIG_WATCH_READY, CONFIG_WATCH_REGISTER, CONFIG_WATCH_REJECTED, CONFIG_WATCH_RELOADED, CONFIG_WATCH_UNREGISTER, isConfigWatchRegistration, isConfigWatchUnregistration, isConfigWatchValidation, matchesConfigWatchFilter, } from "./protocol.js";
+import { ConfigReloadWatchEngine, createFsWatchEventSource, } from "./watch-engine.js";
+const BUILTIN_REGISTRATION_ID = "builtin";
+const DEFAULT_DEBOUNCE_MS = 200;
+const COMPACTION_RECHECK_MS = 250;
+const CONFIG_FILE_NAMES = ["settings.json", "models.json", "keybindings.json"];
+/**
+ * The builtin module is statically imported, so this survives replacement extension
+ * factories during session.reload(). It closes the watcher-to-watcher race window.
+ */
+let reloadHandoff;
+/**
+ * Watch config resources and request the host's existing full reload flow.
+ *
+ * The optional options are test seams. Production registration uses the default
+ * filesystem event source and agent directory.
+ */
+export function configReloadExtension(pi, options = {}) {
+    const agentDir = resolve(options.agentDir ?? getAgentDir());
+    const subscribe = options.subscribe ?? createFsWatchEventSource();
+    const logger = options.logger ?? createConfigReloadLogger(agentDir);
+    const registrations = new Map();
+    const eventUnsubscribes = [];
+    const pending = new Map();
+    let engine;
+    let activeTargets = [];
+    let currentContext;
+    let started = false;
+    let tornDown = false;
+    let reloadInFlight = false;
+    let deferredNoticeShown = false;
+    let unavailableReloadLogged = false;
+    let compactionRecheck;
+    let changeChain = Promise.resolve();
+    const closeWatchers = () => {
+        engine?.close();
+        engine = undefined;
+        activeTargets = [];
+    };
+    const clearCompactionRecheck = () => {
+        if (compactionRecheck === undefined)
+            return;
+        (options.clock ?? defaultClock).clearTimeout(compactionRecheck);
+        compactionRecheck = undefined;
+    };
+    const cleanupEventListeners = () => {
+        for (const unsubscribe of eventUnsubscribes.splice(0)) {
+            unsubscribe();
+        }
+    };
+    const rejectRegistration = (registrationId, errors) => {
+        pi.events.emit(CONFIG_WATCH_REJECTED, {
+            registrationId,
+            paths: [],
+            errors: [...errors],
+        });
+        logger.warn("registration_rejected", { registrationId, errorCount: errors.length });
+    };
+    const handleRegistration = (payload) => {
+        if (!isConfigWatchRegistration(payload))
+            return;
+        const cwd = currentContext?.cwd ?? process.cwd();
+        if (registrationHasRestrictedTarget(payload, cwd, agentDir)) {
+            rejectRegistration(payload.id, ["Configuration watch target is restricted"]);
+            return;
+        }
+        // A component may re-emit its unchanged registration when it receives the
+        // ready event from rebuildWatchers. Rebuilding for that same payload emits
+        // ready again and creates an unbounded synchronous rebuild loop.
+        if (registrations.get(payload.id) === payload)
+            return;
+        registrations.set(payload.id, payload);
+        pending.delete(payload.id);
+        logger.info("registration_added", { id: payload.id });
+        if (started && currentContext) {
+            rebuildWatchers(currentContext);
+        }
+    };
+    const handleUnregistration = (payload) => {
+        if (!isConfigWatchUnregistration(payload))
+            return;
+        if (!registrations.delete(payload.id))
+            return;
+        pending.delete(payload.id);
+        logger.info("registration_removed", { id: payload.id });
+        if (started && currentContext) {
+            rebuildWatchers(currentContext);
+        }
+    };
+    const processChange = async (change) => {
+        if (reloadInFlight || !currentContext)
+            return;
+        const groups = groupChangedPaths(change.changedPaths, activeTargets);
+        const rearmDirectoryWatch = change.created.some((path) => activeTargets.some((target) => target.rearmOnCreation === resolve(path)));
+        for (const [registrationId, paths] of groups) {
+            const watchedPaths = excludeSelfWrites(paths, engine, agentDir, currentContext.cwd, logger);
+            if (watchedPaths.length === 0)
+                continue;
+            const errors = await validateChangedPaths(registrationId, watchedPaths, registrations, agentDir, currentContext.cwd);
+            if (errors.length > 0) {
+                rejectChange(currentContext, registrationId, watchedPaths, errors, logger, pi);
+                continue;
+            }
+            addPending(pending, registrationId, watchedPaths);
+            const deferred = !canRequestReload(currentContext);
+            pi.events.emit(CONFIG_WATCH_CHANGED, {
+                registrationId,
+                paths: [...watchedPaths],
+                deferred,
+            });
+            logger.info("change_detected", { registrationId, paths: watchedPaths, deferred });
+        }
+        if (rearmDirectoryWatch)
+            rebuildWatchers(currentContext);
+        await flushPending();
+    };
+    const enqueueChange = (change) => {
+        if (reloadInFlight)
+            return;
+        changeChain = changeChain
+            .then(() => processChange(change))
+            .catch((error) => {
+            logger.error("watcher_error", { path: "config reload", message: errorMessage(error) });
+        });
+    };
+    const rebuildWatchers = (ctx) => {
+        closeWatchers();
+        clearCompactionRecheck();
+        const settingsManager = SettingsManager.create(ctx.cwd, agentDir, { projectTrusted: ctx.isProjectTrusted() });
+        const settings = resolveConfigReloadSettings(settingsManager);
+        if (!settings.enabled || ctx.mode === "print" || ctx.mode === "json") {
+            pi.events.emit(CONFIG_WATCH_READY, { enabled: false });
+            return;
+        }
+        activeTargets = buildWatchTargets({
+            cwd: ctx.cwd,
+            agentDir,
+            projectTrusted: ctx.isProjectTrusted(),
+            settings,
+            skillPaths: settings.watch.skills ? settingsManager.getSkillPaths() : [],
+            registrations,
+        });
+        engine = new ConfigReloadWatchEngine({
+            targets: activeTargets.map((entry) => entry.target),
+            subscribe,
+            debounceMs: settings.debounceMs,
+            clock: options.clock,
+            hashFile: options.hashFile,
+            onRealChange: enqueueChange,
+            onError: (error, path) => {
+                logger.error("watcher_error", { path, message: errorMessage(error) });
+            },
+        });
+        logger.info("watcher_started", { targetCount: activeTargets.length });
+        pi.events.emit(CONFIG_WATCH_READY, { enabled: true });
+    };
+    const flushPending = async () => {
+        const ctx = currentContext;
+        if (!ctx || pending.size === 0 || reloadInFlight)
+            return;
+        if (!ctx.isIdle() || ctx.hasPendingMessages())
+            return;
+        if (ctx.isCompacting?.() ?? false) {
+            armCompactionRecheck();
+            return;
+        }
+        clearCompactionRecheck();
+        if (!ctx.requestReload) {
+            if (!unavailableReloadLogged) {
+                unavailableReloadLogged = true;
+                logger.info("reload_requested", { reason: "requestReload unavailable", paths: [] });
+            }
+            return;
+        }
+        const changes = pendingChanges(pending);
+        const paths = uniquePaths(changes.flatMap((change) => change.paths));
+        reloadInFlight = true;
+        tornDown = false;
+        reloadHandoff = {
+            hashesAtRequest: engine?.getBaselineSnapshot() ?? new Map(),
+            requestedAt: Date.now(),
+            changes,
+        };
+        ctx.ui.notify(`Hot-reloading: ${formatPaths(paths)}`, "info");
+        logger.info("reload_requested", { reason: "config changed", paths });
+        try {
+            await ctx.requestReload();
+            if (!tornDown) {
+                reloadInFlight = false;
+                reloadHandoff = undefined;
+            }
+        }
+        catch (error) {
+            reloadInFlight = false;
+            reloadHandoff = undefined;
+            logger.error("watcher_error", { path: "reload", message: errorMessage(error) });
+        }
+    };
+    const armCompactionRecheck = () => {
+        if (compactionRecheck !== undefined)
+            return;
+        const clock = options.clock ?? defaultClock;
+        compactionRecheck = clock.setTimeout(() => {
+            compactionRecheck = undefined;
+            void flushPending();
+        }, COMPACTION_RECHECK_MS);
+    };
+    const processReloadHandoff = async (event, ctx) => {
+        if (event.reason !== "reload" || !reloadHandoff)
+            return;
+        const handoff = reloadHandoff;
+        reloadHandoff = undefined;
+        const paths = uniquePaths(handoff.changes.flatMap((change) => change.paths));
+        for (const change of handoff.changes) {
+            pi.events.emit(CONFIG_WATCH_RELOADED, {
+                registrationId: change.registrationId,
+                paths: [...change.paths],
+            });
+        }
+        ctx.ui.notify(`Hot-reloaded: ${formatPaths(paths)}`, "info");
+        logger.info("reload_completed", { durationMs: Math.max(0, Date.now() - handoff.requestedAt) });
+        const changedPaths = compareSnapshots(handoff.hashesAtRequest, engine?.getBaselineSnapshot() ?? new Map());
+        if (changedPaths.length > 0) {
+            enqueueChange({ changedPaths, created: [], deleted: [] });
+            await changeChain;
+        }
+    };
+    eventUnsubscribes.push(pi.events.on(CONFIG_WATCH_REGISTER, handleRegistration));
+    eventUnsubscribes.push(pi.events.on(CONFIG_WATCH_UNREGISTER, handleUnregistration));
+    pi.on("session_start", async (event, ctx) => {
+        tornDown = false;
+        started = true;
+        currentContext = ctx;
+        rebuildWatchers(ctx);
+        await processReloadHandoff(event, ctx);
+    });
+    pi.on("agent_end", async (_event, ctx) => {
+        currentContext = ctx;
+        await flushPending();
+    });
+    pi.on("agent_settled", async (_event, ctx) => {
+        currentContext = ctx;
+        await flushPending();
+    });
+    pi.on("project_trust", () => {
+        if (currentContext)
+            rebuildWatchers(currentContext);
+        return { trusted: "undecided" };
+    });
+    pi.on("session_shutdown", (event) => {
+        tornDown = true;
+        started = false;
+        currentContext = undefined;
+        closeWatchers();
+        clearCompactionRecheck();
+        cleanupEventListeners();
+        pending.clear();
+        if (event.reason !== "reload")
+            reloadHandoff = undefined;
+    });
+    function canRequestReload(ctx) {
+        return (ctx.isIdle() &&
+            !ctx.hasPendingMessages() &&
+            !(ctx.isCompacting?.() ?? false) &&
+            ctx.requestReload !== undefined);
+    }
+    function armDeferredNotice(ctx) {
+        if (deferredNoticeShown || pending.size === 0 || !ctx.requestReload)
+            return;
+        deferredNoticeShown = true;
+        ctx.ui.notify("Config changed; reloading when idle", "info");
+    }
+    function rejectChange(ctx, registrationId, paths, errors, activeLogger, api) {
+        ctx.ui.notify(`Config change rejected: ${errors.join("; ")}`, "error");
+        api.events.emit(CONFIG_WATCH_REJECTED, { registrationId, paths: [...paths], errors: [...errors] });
+        activeLogger.warn("validation_rejected", { registrationId, errorCount: errors.length });
+    }
+    function addPending(changes, registrationId, paths) {
+        const pendingChange = changes.get(registrationId) ?? { registrationId, paths: new Set() };
+        for (const path of paths)
+            pendingChange.paths.add(path);
+        changes.set(registrationId, pendingChange);
+        if (!canRequestReload(currentContext))
+            armDeferredNotice(currentContext);
+    }
+}
+export default configReloadExtension;
+const defaultClock = {
+    setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+    clearTimeout: (timer) => clearTimeout(timer),
+};
+function resolveConfigReloadSettings(settingsManager) {
+    const global = readConfigReloadPatch(settingsManager.getGlobalSettings());
+    const project = readConfigReloadPatch(settingsManager.getProjectSettings());
+    return {
+        enabled: project.enabled ?? global.enabled ?? true,
+        debounceMs: project.debounceMs ?? global.debounceMs ?? DEFAULT_DEBOUNCE_MS,
+        watch: {
+            settings: project.watch?.settings ?? global.watch?.settings ?? true,
+            models: project.watch?.models ?? global.watch?.models ?? true,
+            keybindings: project.watch?.keybindings ?? global.watch?.keybindings ?? true,
+            prompts: project.watch?.prompts ?? global.watch?.prompts ?? true,
+            skills: project.watch?.skills ?? global.watch?.skills ?? true,
+            extensions: project.watch?.extensions ?? global.watch?.extensions ?? true,
+        },
+    };
+}
+function readConfigReloadPatch(settings) {
+    const candidate = settings.configReload;
+    if (!isPlainObject(candidate))
+        return {};
+    const watch = isPlainObject(candidate.watch) ? candidate.watch : undefined;
+    return {
+        enabled: typeof candidate.enabled === "boolean" ? candidate.enabled : undefined,
+        debounceMs: validDebounce(candidate.debounceMs),
+        watch: watch
+            ? {
+                settings: booleanOrUndefined(watch.settings),
+                models: booleanOrUndefined(watch.models),
+                keybindings: booleanOrUndefined(watch.keybindings),
+                prompts: booleanOrUndefined(watch.prompts),
+                skills: booleanOrUndefined(watch.skills),
+                extensions: booleanOrUndefined(watch.extensions),
+            }
+            : undefined,
+    };
+}
+function validDebounce(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        return undefined;
+    return Math.floor(value);
+}
+function booleanOrUndefined(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function buildWatchTargets(options) {
+    const targets = [];
+    const addBuiltin = (id, target, rearmOnCreation) => {
+        targets.push({ registrationId: BUILTIN_REGISTRATION_ID, target: { ...target, id }, rearmOnCreation });
+    };
+    const addBuiltinDirectory = (id, path) => {
+        const resourcePath = resolve(path);
+        if (isExistingDirectory(resourcePath)) {
+            addBuiltin(id, { kind: "dir-recursive", path: resourcePath });
+            return;
+        }
+        const watchPath = nearestExistingDirectory(dirname(resourcePath));
+        const firstMissingSegment = relative(watchPath, resourcePath).split(sep)[0] || basename(resourcePath);
+        const createdPath = resolve(watchPath, firstMissingSegment);
+        addBuiltin(`${id}-presence`, {
+            kind: "dir",
+            path: watchPath,
+            allowList: [firstMissingSegment],
+        }, createdPath);
+    };
+    const { cwd, agentDir, projectTrusted, settings } = options;
+    const projectDir = joinConfigDir(cwd);
+    const jsonAllowList = CONFIG_FILE_NAMES.filter((name) => {
+        if (name === "settings.json")
+            return settings.watch.settings;
+        if (name === "models.json")
+            return settings.watch.models;
+        return settings.watch.keybindings;
+    });
+    if (jsonAllowList.length > 0) {
+        addBuiltin("builtin-global-json", { kind: "dir", path: agentDir, allowList: jsonAllowList });
+    }
+    if (settings.watch.prompts) {
+        addBuiltinDirectory("builtin-global-prompts", resolve(agentDir, "prompts"));
+    }
+    if (settings.watch.extensions) {
+        addBuiltinDirectory("builtin-global-extensions", resolve(agentDir, "extensions"));
+    }
+    if (settings.watch.skills) {
+        for (const [index, skillPath] of options.skillPaths.entries()) {
+            const target = targetForSkillPath(resolvePath(skillPath, cwd, { trim: true }));
+            if (target.kind === "dir-recursive") {
+                addBuiltinDirectory(`builtin-skill-${index}`, target.path);
+            }
+            else {
+                addBuiltin(`builtin-skill-${index}`, target);
+            }
+        }
+    }
+    if (projectTrusted) {
+        const projectDirExists = isExistingDirectory(projectDir);
+        const projectWatchEnabled = Object.values(settings.watch).some(Boolean);
+        if (projectWatchEnabled) {
+            addBuiltin("builtin-project-presence", { kind: "dir", path: cwd, allowList: [CONFIG_DIR_NAME] }, projectDirExists ? undefined : projectDir);
+        }
+        if (projectDirExists) {
+            if (settings.watch.settings) {
+                addBuiltin("builtin-project-settings", {
+                    kind: "dir",
+                    path: projectDir,
+                    allowList: ["settings.json"],
+                });
+            }
+            if (settings.watch.prompts) {
+                addBuiltinDirectory("builtin-project-prompts", resolve(projectDir, "prompts"));
+            }
+            if (settings.watch.skills) {
+                addBuiltinDirectory("builtin-project-skills", resolve(projectDir, "skills"));
+            }
+            if (settings.watch.extensions) {
+                addBuiltinDirectory("builtin-project-extensions", resolve(projectDir, "extensions"));
+            }
+        }
+    }
+    for (const registration of options.registrations.values()) {
+        for (const [index, target] of registration.targets.entries()) {
+            const path = resolvePath(target.path, cwd, { trim: true });
+            const watchTarget = externalTargetToWatchTarget(path, target.kind, target.filterGlobs);
+            targets.push({
+                registrationId: registration.id,
+                target: { ...watchTarget, id: `external-${registration.id}-${index}` },
+            });
+        }
+    }
+    return targets;
+}
+function isExistingDirectory(path) {
+    try {
+        return lstatSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function nearestExistingDirectory(path) {
+    let candidate = resolve(path);
+    while (!isExistingDirectory(candidate)) {
+        const parent = dirname(candidate);
+        if (parent === candidate)
+            return candidate;
+        candidate = parent;
+    }
+    return candidate;
+}
+function targetForSkillPath(path) {
+    try {
+        if (lstatSync(path).isFile()) {
+            return { kind: "dir", path: dirname(path), allowList: [basename(path)] };
+        }
+    }
+    catch {
+        // A missing configured skill path is treated as a directory so it becomes watchable when present.
+    }
+    return { kind: "dir-recursive", path };
+}
+function externalTargetToWatchTarget(path, kind, filterGlobs) {
+    if (kind === "file") {
+        const name = basename(path);
+        return {
+            kind: "dir",
+            path: dirname(path),
+            allowList: [name],
+            filter: (relativePath) => relativePath === name && matchesConfigWatchFilter(relativePath, filterGlobs),
+        };
+    }
+    return {
+        kind: "dir-recursive",
+        path,
+        // Literal filters also declare explicitly watched dot-directories. Without
+        // this, an external ancestor target filtered to ".omo" drops its creation
+        // event before the validator can inspect the new config beneath it.
+        allowList: literalFilterNames(filterGlobs),
+        filter: (relativePath) => matchesConfigWatchFilter(relativePath, filterGlobs),
+    };
+}
+function literalFilterNames(filterGlobs) {
+    if (!filterGlobs)
+        return undefined;
+    const literalNames = filterGlobs.filter((filterGlob) => !filterGlob.includes("*") && !filterGlob.includes("/") && !filterGlob.includes("\\\\"));
+    return literalNames.length > 0 ? literalNames : undefined;
+}
+function groupChangedPaths(paths, targets) {
+    const groups = new Map();
+    for (const path of paths) {
+        let matched = false;
+        for (const activeTarget of targets) {
+            if (!targetMatchesPath(activeTarget.target, path))
+                continue;
+            const group = groups.get(activeTarget.registrationId) ?? [];
+            if (!group.includes(path))
+                group.push(path);
+            groups.set(activeTarget.registrationId, group);
+            matched = true;
+        }
+        if (!matched) {
+            const group = groups.get(BUILTIN_REGISTRATION_ID) ?? [];
+            group.push(path);
+            groups.set(BUILTIN_REGISTRATION_ID, group);
+        }
+    }
+    return groups;
+}
+function targetMatchesPath(target, path) {
+    const relativePath = relative(resolve(target.path), resolve(path));
+    if (relativePath === ".." || relativePath.startsWith(`..${sep}`))
+        return false;
+    if (target.kind === "dir" && relativePath.includes(sep))
+        return false;
+    if (target.allowList &&
+        !target.allowList.some((allowed) => relativePath === allowed || relativePath.startsWith(`${allowed}${sep}`))) {
+        return false;
+    }
+    return target.filter?.(relativePath) ?? true;
+}
+function excludeSelfWrites(paths, engine, agentDir, cwd, logger) {
+    const snapshot = engine?.getBaselineSnapshot();
+    return paths.filter((path) => {
+        if (!isSettingsPath(path, agentDir, cwd))
+            return true;
+        const hash = snapshot?.get(path);
+        if (hash === undefined || !wasSelfWrite(path, hash))
+            return true;
+        logger.debug("self_write_suppressed", { path });
+        return false;
+    });
+}
+async function validateChangedPaths(registrationId, paths, registrations, agentDir, cwd) {
+    if (registrationId === BUILTIN_REGISTRATION_ID) {
+        return validateBuiltinPaths(paths, agentDir, cwd);
+    }
+    const registration = registrations.get(registrationId);
+    if (!registration?.validate)
+        return [];
+    try {
+        const result = await registration.validate(paths);
+        if (!isConfigWatchValidation(result))
+            return ["Configuration validator returned an invalid result"];
+        return result.ok ? [] : result.errors;
+    }
+    catch (error) {
+        return [errorMessage(error)];
+    }
+}
+function validateBuiltinPaths(paths, agentDir, cwd) {
+    const errors = [];
+    for (const path of paths) {
+        if (isSettingsPath(path, agentDir, cwd)) {
+            const error = validateSettingsFile(path);
+            if (error)
+                errors.push(error);
+            continue;
+        }
+        if (resolve(path) === resolve(agentDir, "models.json")) {
+            const error = ModelConfig.loadSync(path).getError();
+            if (error)
+                errors.push(error);
+            continue;
+        }
+        if (resolve(path) === resolve(agentDir, "keybindings.json")) {
+            const error = validateKeybindingsFile(path);
+            if (error)
+                errors.push(error);
+        }
+    }
+    return errors;
+}
+function validateSettingsFile(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (!isPlainObject(parsed))
+            return "settings.json must contain an object";
+        // Keep validation aligned with SettingsManager's loader and migrations without duplicating migration rules.
+        SettingsManager.inMemory(parsed);
+        return undefined;
+    }
+    catch (error) {
+        return `Invalid settings.json: ${errorMessage(error)}`;
+    }
+}
+function validateKeybindingsFile(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (!isPlainObject(parsed))
+            return "keybindings.json must contain an object";
+        for (const value of Object.values(parsed)) {
+            if (typeof value === "string")
+                continue;
+            if (Array.isArray(value) && value.every((entry) => typeof entry === "string"))
+                continue;
+            return "keybindings.json bindings must be strings or string arrays";
+        }
+        return undefined;
+    }
+    catch (error) {
+        return `Invalid keybindings.json: ${errorMessage(error)}`;
+    }
+}
+function registrationHasRestrictedTarget(registration, cwd, agentDir) {
+    const authPath = resolve(agentDir, "auth.json");
+    const sessionsPath = resolve(agentDir, "sessions");
+    const logsPath = resolve(agentDir, "logs");
+    return registration.targets.some((target) => {
+        const path = resolvePath(target.path, cwd, { trim: true });
+        return (isWithin(path, authPath) ||
+            isWithin(authPath, path) ||
+            isWithin(path, sessionsPath) ||
+            isWithin(path, logsPath));
+    });
+}
+function pendingChanges(pending) {
+    return [...pending.values()].map((change) => ({
+        registrationId: change.registrationId,
+        paths: [...change.paths].sort(),
+    }));
+}
+function compareSnapshots(previous, next) {
+    const changed = new Set();
+    for (const [path, hash] of next) {
+        if (previous.get(path) !== hash)
+            changed.add(path);
+    }
+    for (const path of previous.keys()) {
+        if (!next.has(path))
+            changed.add(path);
+    }
+    return [...changed].sort();
+}
+function uniquePaths(paths) {
+    return [...new Set(paths)].sort();
+}
+function joinConfigDir(cwd) {
+    return resolve(cwd, CONFIG_DIR_NAME);
+}
+function isSettingsPath(path, agentDir, cwd) {
+    return (resolve(path) === resolve(agentDir, "settings.json") ||
+        resolve(path) === resolve(joinConfigDir(cwd), "settings.json"));
+}
+function isWithin(path, root) {
+    return path === root || path.startsWith(`${root}${sep}`);
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function formatPaths(paths) {
+    return paths.length === 0 ? "configuration" : paths.join(", ");
+}
+//# sourceMappingURL=index.js.map