@uluops/setup 0.6.5 → 0.8.1

package/dist/commands/uninstall.js

@@ -1,14 +1,18 @@
 import chalk from "chalk";
-import { loadManifest, deleteManifest, validateManifest, } from "../lib/manifest.js";
+import { loadManifest, saveManifest, deleteManifest, validateManifest, } from "../lib/manifest.js";
+import { acquireInstallLock, } from "../lib/install-lock.js";
 import { uninstallMcp } from "../steps/mcp.js";
 import { uninstallAgents } from "../steps/agents.js";
 import { uninstallCommands } from "../steps/commands.js";
+import { uninstallSkills } from "../steps/skills.js";
 import { removeShellExport } from "../steps/shell.js";
 import { uninstallMetrics } from "../steps/metrics.js";
 import { uninstallCli, CLI_PACKAGE } from "../steps/cli.js";
+import { uninstallAgentMetricsCli, AGENT_METRICS_PACKAGE, } from "../steps/agent-metrics-cli.js";
 import { ok, warn, fail, info } from "../lib/display.js";
 import { getVersion } from "../lib/version.js";
 import { getProfile } from "../harnesses/index.js";
+import { resolveUninstallFilter, UninstallFilterError, } from "./uninstall-filter.js";
 export async function runUninstall(opts) {
     const version = await getVersion();
     console.log();
@@ -17,110 +21,214 @@ export async function runUninstall(opts) {
     if (opts.dryRun) {
         info(chalk.dim("(dry run — no changes will be made)\n"));
     }
-    const manifest = await loadManifest();
-    if (!manifest) {
-        warn("No manifest found — nothing to uninstall.");
-        return;
-    }
-    const validation = await validateManifest(manifest);
-    if (!validation.valid) {
-        fail("Manifest references paths that no longer exist:");
-        for (const err of validation.errors)
-            info(`  ${err}`);
-        console.log();
-        info("Uninstall may be incomplete. Proceeding with what's available.");
-        console.log();
-    }
-    if (validation.warnings.length > 0) {
-        for (const w of validation.warnings)
-            warn(w);
-        console.log();
+    // Same lock as runSetup — concurrent setup+uninstall would race the same
+    // shared state. Skipped on dry-run (read-only).
+    let lock = null;
+    if (!opts.dryRun) {
+        lock = await acquireInstallLock();
     }
-    for (const [harnessName, hm] of Object.entries(manifest.harnesses)) {
-        let profile;
-        try {
-            profile = getProfile(harnessName);
+    try {
+        const manifest = await loadManifest();
+        if (!manifest) {
+            warn("No manifest found — nothing to uninstall.");
+            return;
         }
-        catch {
-            warn(`Unknown harness "${harnessName}" in manifest — skipping`);
-            continue;
+        const validation = await validateManifest(manifest);
+        if (!validation.valid) {
+            fail("Manifest references paths that no longer exist:");
+            for (const err of validation.errors)
+                info(`  ${err}`);
+            console.log();
+            info("Uninstall may be incomplete. Proceeding with what's available.");
+            console.log();
         }
-        info(chalk.bold(profile.displayName));
-        if (!opts.dryRun) {
-            const agentCount = await uninstallAgents(hm.agents, hm.defsPath);
-            ok(`Removed ${agentCount} agent(s)`);
+        if (validation.warnings.length > 0) {
+            for (const w of validation.warnings)
+                warn(w);
+            console.log();
         }
-        else {
-            ok(`Would remove ${hm.agents.length} agent(s)`);
+        // Resolve the subset of harnesses to uninstall. `null` means "all
+        // harnesses in the manifest" (today's no-filter behavior). String[]
+        // means "only these — leave the rest of the manifest intact".
+        const manifestHarnesses = Object.keys(manifest.harnesses);
+        let filter;
+        try {
+            filter = resolveUninstallFilter({
+                harnessArg: opts.harnessArg,
+                harnessFromCli: opts.harnessFromCli ?? false,
+                allDetected: opts.allDetected ?? false,
+                manifestHarnesses,
+            });
         }
-        if (hm.commands.length > 0) {
+        catch (err) {
+            if (err instanceof UninstallFilterError) {
+                fail(err.message);
+                console.log();
+                process.exit(1);
+            }
+            throw err;
+        }
+        const toUninstall = filter ?? manifestHarnesses;
+        const isFullUninstall = toUninstall.length === manifestHarnesses.length;
+        if (!isFullUninstall) {
+            info(chalk.dim(`Uninstalling subset (${toUninstall.length} of ${manifestHarnesses.length}): ${toUninstall.join(", ")}`));
+            console.log();
+        }
+        for (const harnessName of toUninstall) {
+            const hm = manifest.harnesses[harnessName];
+            if (!hm) {
+                // Defense — filter already validated, but keep the guard so a
+                // mid-run manifest mutation doesn't crash.
+                continue;
+            }
+            let profile;
+            try {
+                profile = getProfile(harnessName);
+            }
+            catch {
+                warn(`Unknown harness "${harnessName}" in manifest — skipping`);
+                continue;
+            }
+            info(chalk.bold(profile.displayName));
             if (!opts.dryRun) {
-                const cmdCount = await uninstallCommands(hm.commands, hm.defsPath);
-                ok(`Removed ${cmdCount} command(s)`);
+                const agentCount = await uninstallAgents(hm.agents, hm.defsPath);
+                ok(`Removed ${agentCount} agent(s)`);
             }
             else {
-                ok(`Would remove ${hm.commands.length} command(s)`);
+                ok(`Would remove ${hm.agents.length} agent(s)`);
+            }
+            if (hm.commands.length > 0) {
+                if (!opts.dryRun) {
+                    const cmdCount = await uninstallCommands(hm.commands, hm.defsPath);
+                    ok(`Removed ${cmdCount} command(s)`);
+                }
+                else {
+                    ok(`Would remove ${hm.commands.length} command(s)`);
+                }
             }
+            if ((hm.skills?.length ?? 0) > 0) {
+                if (!opts.dryRun) {
+                    const skillCount = await uninstallSkills(hm.skills ?? [], hm.defsPath);
+                    ok(`Removed ${skillCount} skill file(s)`);
+                }
+                else {
+                    ok(`Would remove ${hm.skills?.length ?? 0} skill file(s)`);
+                }
+            }
+            if (!opts.dryRun) {
+                try {
+                    await uninstallMcp(profile, hm.mcpConfigPath);
+                    ok(`Removed MCP servers from ${hm.mcpConfigPath}`);
+                }
+                catch {
+                    warn(`Could not remove MCP servers from ${hm.mcpConfigPath}`);
+                }
+            }
+            else {
+                ok(`Would remove MCP servers from ${hm.mcpConfigPath}`);
+            }
+            if (hm.hooksInstalled) {
+                if (!opts.dryRun) {
+                    await uninstallMetrics(profile, false);
+                    ok("Removed agent-metrics hook and tool files");
+                }
+                else {
+                    ok("Would remove agent-metrics hook and tool files");
+                }
+            }
+            console.log();
         }
-        if (!opts.dryRun) {
-            try {
-                await uninstallMcp(profile, hm.mcpConfigPath);
-                ok(`Removed MCP servers from ${hm.mcpConfigPath}`);
+        // Globals (CLI, agent-metrics CLI, shell export) are only removed on
+        // a FULL uninstall — they're shared infrastructure that may serve
+        // remaining harnesses or other tools after a subset uninstall.
+        if (isFullUninstall) {
+            if (manifest.cliInstalled) {
+                const res = await uninstallCli({ dryRun: opts.dryRun });
+                if (opts.dryRun) {
+                    ok(`Would remove ${CLI_PACKAGE} (global)`);
+                }
+                else if (res.removed) {
+                    ok(`Removed ${CLI_PACKAGE} (global)`);
+                }
+                else {
+                    warn(`Could not remove ${CLI_PACKAGE} (global) — try \`npm uninstall -g ${CLI_PACKAGE}\` manually`);
+                    if (res.error) {
+                        const oneLine = res.error.split("\n")[0]?.slice(0, 120) ?? "";
+                        if (oneLine)
+                            info(`  ${oneLine}`);
+                    }
+                }
             }
-            catch {
-                warn(`Could not remove MCP servers from ${hm.mcpConfigPath}`);
+            if (manifest.agentMetricsCliInstalled) {
+                const res = await uninstallAgentMetricsCli({ dryRun: opts.dryRun });
+                if (opts.dryRun) {
+                    ok(`Would remove ${AGENT_METRICS_PACKAGE} (global)`);
+                }
+                else if (res.removed) {
+                    ok(`Removed ${AGENT_METRICS_PACKAGE} (global)`);
+                }
+                else {
+                    warn(`Could not remove ${AGENT_METRICS_PACKAGE} (global) — try \`npm uninstall -g ${AGENT_METRICS_PACKAGE}\` manually`);
+                    if (res.error) {
+                        const oneLine = res.error.split("\n")[0]?.slice(0, 120) ?? "";
+                        if (oneLine)
+                            info(`  ${oneLine}`);
+                    }
+                }
+            }
+            if (manifest.shellModified) {
+                const { getShellProfile } = await import("../lib/paths.js");
+                const shellProfile = getShellProfile();
+                if (shellProfile && !opts.dryRun) {
+                    await removeShellExport(shellProfile.path);
+                    ok(`Removed export from ${shellProfile.path}`);
+                }
+                else if (shellProfile) {
+                    ok(`Would remove export from ${shellProfile.path}`);
+                }
             }
         }
         else {
-            ok(`Would remove MCP servers from ${hm.mcpConfigPath}`);
+            info(chalk.dim(`Preserving global @uluops/cli, @uluops/agent-metrics, and shell export — subset uninstall does not touch shared infrastructure`));
+            console.log();
         }
-        if (hm.hooksInstalled) {
-            if (!opts.dryRun) {
-                await uninstallMetrics(profile, false);
-                ok("Removed agent-metrics hook and tool files");
+        // Manifest update / delete logic:
+        //   full uninstall → delete the manifest entirely (today's behavior)
+        //   subset uninstall, entries remain → save the trimmed manifest
+        //   subset uninstall, no entries remain → delete (manifest loader
+        //     would reject an empty-harnesses file)
+        if (!opts.dryRun) {
+            if (isFullUninstall) {
+                await deleteManifest();
+                ok("Manifest deleted");
             }
             else {
-                ok("Would remove agent-metrics hook and tool files");
+                for (const name of toUninstall) {
+                    delete manifest.harnesses[name];
+                }
+                const remaining = Object.keys(manifest.harnesses).length;
+                if (remaining > 0) {
+                    await saveManifest(manifest);
+                    ok(`Manifest updated — ${remaining} harness(es) remain: ${Object.keys(manifest.harnesses).join(", ")}`);
+                }
+                else {
+                    await deleteManifest();
+                    ok("Manifest deleted (no harnesses remain)");
+                }
             }
         }
         console.log();
-    }
-    // Remove global @uluops/cli if WE installed it (per manifest).
-    // We never auto-remove a user-installed CLI — manifest.cliInstalled gates this.
-    if (manifest.cliInstalled) {
-        const res = await uninstallCli({ dryRun: opts.dryRun });
-        if (opts.dryRun) {
-            ok(`Would remove ${CLI_PACKAGE} (global)`);
-        }
-        else if (res.removed) {
-            ok(`Removed ${CLI_PACKAGE} (global)`);
+        if (isFullUninstall) {
+            info("UluOps has been removed. Restart your harness to complete.");
         }
         else {
-            warn(`Could not remove ${CLI_PACKAGE} (global) — try \`npm uninstall -g ${CLI_PACKAGE}\` manually`);
-            if (res.error) {
-                const oneLine = res.error.split("\n")[0]?.slice(0, 120) ?? "";
-                if (oneLine)
-                    info(`  ${oneLine}`);
-            }
-        }
-    }
-    // Remove shell export
-    if (manifest.shellModified) {
-        const { getShellProfile } = await import("../lib/paths.js");
-        const shellProfile = getShellProfile();
-        if (shellProfile && !opts.dryRun) {
-            await removeShellExport(shellProfile.path);
-            ok(`Removed export from ${shellProfile.path}`);
-        }
-        else if (shellProfile) {
-            ok(`Would remove export from ${shellProfile.path}`);
+            const removed = toUninstall.join(", ");
+            info(`Removed UluOps from ${removed}. Restart the affected harness(es) to complete.`);
         }
+        console.log();
     }
-    if (!opts.dryRun) {
-        await deleteManifest();
-        ok("Manifest deleted");
+    finally {
+        if (lock)
+            await lock.release();
     }
-    console.log();
-    info("UluOps has been removed. Restart your harness to complete.");
-    console.log();
 }

package/dist/harnesses/codex.d.ts

@@ -1,15 +1,10 @@
 /**
- * Codex Harness Profile (Scaffold)
+ * Codex Harness Profile
  *
- * Paths and metadata are verified from vendor docs.
- * Codex uses TOML config with `mcp_servers` key (nested tables).
+ * Codex uses TOML config with `mcp_servers` nested tables.
  * Agent definitions are TOML, not markdown.
- * Skills use a different path ($HOME/.agents/skills/) than agents (~/.codex/agents/).
- *
- * NOT YET TESTED with UluOps agents. McpConfigStrategy throws
- * until integration testing is complete.
- *
- * Will require `smol-toml` dependency when fully implemented.
+ * Skills live under ~/.codex/skills and are the preferred Codex-native
+ * surface for UluOps operator workflows.
  */
-import type { HarnessProfile } from "./types.js";
+import { type HarnessProfile } from "./types.js";
 export declare const codexProfile: HarnessProfile;

package/dist/harnesses/codex.js

@@ -1,34 +1,101 @@
 /**
- * Codex Harness Profile (Scaffold)
+ * Codex Harness Profile
  *
- * Paths and metadata are verified from vendor docs.
- * Codex uses TOML config with `mcp_servers` key (nested tables).
+ * Codex uses TOML config with `mcp_servers` nested tables.
  * Agent definitions are TOML, not markdown.
- * Skills use a different path ($HOME/.agents/skills/) than agents (~/.codex/agents/).
- *
- * NOT YET TESTED with UluOps agents. McpConfigStrategy throws
- * until integration testing is complete.
- *
- * Will require `smol-toml` dependency when fully implemented.
+ * Skills live under ~/.codex/skills and are the preferred Codex-native
+ * surface for UluOps operator workflows.
  */
+import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { HarnessNotTestedError } from "./types.js";
+import { ULUOPS_SERVERS, } from "./types.js";
+import { atomicWrite } from "../lib/atomic-write.js";
+const RAW_TOML = "__rawToml";
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function serverBlock(name, pkg, apiKey) {
+    return [
+        `[mcp_servers.${tomlString(name)}]`,
+        `command = "npx"`,
+        `args = ["-y", ${tomlString(pkg)}]`,
+        ``,
+        `[mcp_servers.${tomlString(name)}.env]`,
+        `ULUOPS_API_KEY = ${tomlString(apiKey)}`,
+    ].join("\n");
+}
+function isServerTableFor(name, table) {
+    return table === `mcp_servers.${name}` || table === `mcp_servers."${name}"`;
+}
+function isServerSubtableFor(name, table) {
+    const unquotedPrefix = `mcp_servers.${name}.`;
+    const quotedPrefix = `mcp_servers."${name}".`;
+    return table.startsWith(unquotedPrefix) || table.startsWith(quotedPrefix);
+}
+function removeServerConfigBlocks(raw, name) {
+    const lines = raw.split("\n");
+    const kept = [];
+    let skipping = false;
+    for (const line of lines) {
+        const table = line.trim().match(/^\[([^\]]+)\]$/)?.[1];
+        if (table) {
+            skipping = isServerTableFor(name, table) || table === `mcp_servers.${name}.env` || table === `mcp_servers."${name}".env`;
+        }
+        if (!skipping)
+            kept.push(line);
+    }
+    return kept.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+function removeServerSubtree(raw, name) {
+    const lines = raw.split("\n");
+    const kept = [];
+    let skipping = false;
+    for (const line of lines) {
+        const table = line.trim().match(/^\[([^\]]+)\]$/)?.[1];
+        if (table) {
+            skipping = isServerTableFor(name, table) || isServerSubtableFor(name, table);
+        }
+        if (!skipping)
+            kept.push(line);
+    }
+    return kept.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
 class CodexMcpConfig {
-    async read() {
-        throw new HarnessNotTestedError("Codex (agent format compatibility under review)");
+    async read(path) {
+        try {
+            return { [RAW_TOML]: await readFile(path, "utf-8") };
+        }
+        catch {
+            return { [RAW_TOML]: "" };
+        }
     }
-    merge() {
-        throw new HarnessNotTestedError("Codex (agent format compatibility under review)");
+    merge(config, apiKey) {
+        let raw = typeof config[RAW_TOML] === "string" ? config[RAW_TOML] : "";
+        raw = removeServerConfigBlocks(removeServerConfigBlocks(raw, "uluops-tracker"), "uluops-registry");
+        const blocks = [
+            serverBlock("uluops-tracker", "@uluops/ops-mcp", apiKey),
+            serverBlock("uluops-registry", "@uluops/registry-mcp", apiKey),
+        ].join("\n\n");
+        return { [RAW_TOML]: [raw.trimEnd(), blocks].filter(Boolean).join("\n\n") + "\n" };
     }
-    remove() {
-        throw new HarnessNotTestedError("Codex (agent format compatibility under review)");
+    remove(config) {
+        let raw = typeof config[RAW_TOML] === "string" ? config[RAW_TOML] : "";
+        for (const name of ULUOPS_SERVERS) {
+            raw = removeServerSubtree(raw, name);
+        }
+        return { [RAW_TOML]: raw.trimEnd() ? `${raw.trimEnd()}\n` : "" };
     }
-    async write() {
-        throw new HarnessNotTestedError("Codex (agent format compatibility under review)");
+    async write(path, config) {
+        const raw = typeof config[RAW_TOML] === "string" ? config[RAW_TOML] : "";
+        await atomicWrite(path, raw, { mode: 0o600 });
     }
-    check() {
-        throw new HarnessNotTestedError("Codex (MCP config check not supported)");
+    check(config) {
+        const raw = typeof config[RAW_TOML] === "string" ? config[RAW_TOML] : "";
+        return ULUOPS_SERVERS.every((name) => {
+            const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            return new RegExp(String.raw `\[mcp_servers\.(?:"${escaped}"|${escaped})\]`).test(raw);
+        });
     }
 }
 const home = join(homedir(), ".codex");
@@ -45,7 +112,8 @@ export const codexProfile = {
         globalMcpConfig: join(home, "config.toml"),
         localMcpConfig: ".codex/config.toml",
         agentsDir: join(home, "agents"),
-        commandsDir: join(homedir(), ".agents", "skills"),
+        commandsDir: join(home, "commands"),
+        skillsDir: join(home, "skills"),
         settingsPath: null,
         toolsDir: null,
     },

package/dist/harnesses/index.js

@@ -6,7 +6,7 @@
  */
 import { existsSync } from "node:fs";
 import { claudeCodeProfile } from "./claude-code.js";
-import { opencodeProfile } from "./opencode.js";
+import { opencodeProfile, assertOpencodeEnvironment } from "./opencode.js";
 import { geminiCliProfile } from "./gemini-cli.js";
 import { codexProfile } from "./codex.js";
 export { ConfigParseError, HarnessNotTestedError, } from "./types.js";
@@ -33,6 +33,11 @@ export function getProfile(name) {
         const available = ALL_PROFILES.map((p) => p.name).join(", ");
         throw new Error(`Unknown harness "${name}". Available: ${available}`);
     }
+    // Harness-specific environment validation deferred from module-load to
+    // selection time. Keeps `--help` and `--uninstall` usable even when an
+    // unrelated harness's env is misconfigured.
+    if (resolved === "opencode")
+        assertOpencodeEnvironment();
     return profile;
 }
 /**

package/dist/harnesses/opencode.d.ts

@@ -11,4 +11,12 @@
  * Verified working shape from ~/opencode.jsonc (2026-04-30).
  */
 import { type HarnessProfile } from "./types.js";
+/**
+ * Throws the deferred XDG_CONFIG_HOME validation error, if any. Called by
+ * the harness registry when the user actually selects opencode (via
+ * `--harness opencode` or auto-detection picking it). Other entry points
+ * (`--help`, `--uninstall` of an unrelated harness, `--list`) never trigger
+ * this and remain usable.
+ */
+export declare function assertOpencodeEnvironment(): void;
 export declare const opencodeProfile: HarnessProfile;

package/dist/harnesses/opencode.js

@@ -106,17 +106,40 @@ class OpenCodeMcpConfig {
         return ULUOPS_SERVERS.every((name) => name in mcp);
     }
 }
+/**
+ * XDG_CONFIG_HOME validation is deferred from module-load to first opencode
+ * use. The previous design threw at import, which crashed `uluops-setup
+ * --help` and `--uninstall` for any user with an invalid XDG_CONFIG_HOME —
+ * blocking them from running the very commands they need to recover. Now
+ * the IIFE caches any validation error and the harness registry calls
+ * `assertOpencodeEnvironment()` only when the opencode profile is actually
+ * selected. Unselected, the module loads cleanly and the fallback path is
+ * used for shape-only computations.
+ */
+let deferredXdgConfigError = null;
 const xdgConfig = (() => {
     const env = process.env["XDG_CONFIG_HOME"];
     if (env) {
         if (!isAbsolute(env) || env.includes("..")) {
-            throw new Error(`XDG_CONFIG_HOME must be an absolute path without traversal: ${env}`);
+            deferredXdgConfigError = new Error(`XDG_CONFIG_HOME must be an absolute path without traversal: ${env}`);
+            return join(homedir(), ".config");
         }
         return env;
     }
     return join(homedir(), ".config");
 })();
 const home = join(xdgConfig, "opencode");
+/**
+ * Throws the deferred XDG_CONFIG_HOME validation error, if any. Called by
+ * the harness registry when the user actually selects opencode (via
+ * `--harness opencode` or auto-detection picking it). Other entry points
+ * (`--help`, `--uninstall` of an unrelated harness, `--list`) never trigger
+ * this and remain usable.
+ */
+export function assertOpencodeEnvironment() {
+    if (deferredXdgConfigError)
+        throw deferredXdgConfigError;
+}
 export const opencodeProfile = {
     name: "opencode",
     displayName: "OpenCode",

package/dist/harnesses/types.d.ts

@@ -54,6 +54,8 @@ export interface HarnessPaths {
     readonly agentsDir: string;
     /** Global commands/skills dir */
     readonly commandsDir: string;
+    /** Global Codex-style skills dir, when the harness supports skills as first-class install assets */
+    readonly skillsDir?: string | null;
     /** Settings file path, or null if harness has no settings file */
     readonly settingsPath: string | null;
     /** Tool installation dir, or null if harness has no tool installation */

package/dist/harnesses/types.js

@@ -20,7 +20,11 @@ export class ConfigParseError extends Error {
 /** Thrown when a harness is scaffolded but not yet tested/implemented. */
 export class HarnessNotTestedError extends Error {
     constructor(harnessName) {
-        super(`${harnessName} harness is not yet tested. Use --harness claude-code or --harness opencode.`);
+        super(
+        // Keep this list in sync with profiles whose `status === "stable"`.
+        // Today: claude-code, opencode, gemini-cli. When a new stable profile
+        // lands, add it here so the error stays actionable.
+        `${harnessName} harness is not yet tested. Use --harness claude-code, --harness opencode, or --harness gemini-cli.`);
         this.name = "HarnessNotTestedError";
     }
 }

package/dist/lib/atomic-write.js

@@ -5,10 +5,18 @@
  * from corrupting user config files.
  */
 import { writeFile, rename, unlink, chmod } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
 export async function atomicWrite(path, content, options) {
-    const tmp = `${path}.uluops-tmp`;
+    // Random suffix + 'wx' flag (O_CREAT|O_EXCL) prevents symlink races:
+    // an attacker cannot pre-position a symlink at an unpredictable path,
+    // and 'wx' fails atomically rather than following one that exists.
+    const tmp = `${path}.uluops-tmp.${randomBytes(8).toString("hex")}`;
     try {
-        await writeFile(tmp, content, { encoding: "utf-8", mode: options?.mode });
+        await writeFile(tmp, content, {
+            encoding: "utf-8",
+            mode: options?.mode,
+            flag: "wx",
+        });
         if (options?.mode) {
             // Ensure mode is applied even if umask is permissive
             await chmod(tmp, options.mode);

package/dist/lib/config-merger.d.ts

@@ -8,11 +8,14 @@ export interface ClaudeConfig {
     mcpServers?: Record<string, McpServerConfig>;
     [key: string]: unknown;
 }
-/** Check whether the UluOps MCP client packages exist on the npm registry. Returns lists of available and missing packages. */
-export declare function checkMcpPackageAvailability(): Promise<{
+interface AvailabilityResult {
     available: string[];
     missing: string[];
-}>;
+}
+/** Test-only: drop the memoized availability promise so the next call re-probes. */
+export declare function __resetAvailabilityCacheForTesting(): void;
+/** Check whether the UluOps MCP client packages exist on the npm registry. Returns lists of available and missing packages. */
+export declare function checkMcpPackageAvailability(): Promise<AvailabilityResult>;
 /**
  * Read an existing config file, or return empty object if it doesn't exist.
  * Throws on malformed JSON to prevent silent data loss during merge+write.