@uluops/setup 0.2.0 → 0.4.0

package/dist/lib/paths.js

@@ -1,33 +1,91 @@
 import { homedir, platform } from "node:os";
-import { join, dirname } from "node:path";
+import { join, dirname, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
+import { access } from "node:fs/promises";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 /** Root of the npm package (where assets/ lives) */
 export const PACKAGE_ROOT = join(__dirname, "..", "..");
 /** Assets directory containing pre-rendered .md files */
 export const ASSETS_DIR = join(PACKAGE_ROOT, "assets");
+/** Explicit project root override via --project-root flag or env var. */
+let projectRootOverride = null;
+export function setProjectRoot(path) {
+    projectRootOverride = path;
+}
+/** Walk upward from cwd to find the nearest directory containing .git or package.json. Falls back to cwd. */
+export async function findProjectRoot() {
+    if (projectRootOverride)
+        return projectRootOverride;
+    const envRoot = process.env["ULUOPS_PROJECT_ROOT"];
+    if (envRoot) {
+        if (!isAbsolute(envRoot)) {
+            throw new Error(`ULUOPS_PROJECT_ROOT must be an absolute path, got: ${envRoot}`);
+        }
+        if (envRoot.includes("..")) {
+            throw new Error(`ULUOPS_PROJECT_ROOT must not contain traversal sequences: ${envRoot}`);
+        }
+        return envRoot;
+    }
+    let dir = process.cwd();
+    const root = dirname(dir);
+    while (dir !== root) {
+        if (await isProjectMarker(dir))
+            return dir;
+        dir = dirname(dir);
+    }
+    if (await isProjectMarker(dir))
+        return dir;
+    return process.cwd();
+}
+async function isProjectMarker(dir) {
+    try {
+        await access(join(dir, ".git"));
+        return true;
+    }
+    catch {
+        // continue
+    }
+    try {
+        await access(join(dir, "package.json"));
+        return true;
+    }
+    catch {
+        // continue
+    }
+    return false;
+}
+/** Return the Claude config home directory (~/.claude by default, or CLAUDE_HOME env override). */
 export function getClaudeHome() {
-    return join(homedir(), ".claude");
+    return process.env["CLAUDE_HOME"] ?? join(homedir(), ".claude");
 }
+/** Return the path to Claude's global config file (~/.claude.json by default, or CLAUDE_JSON_PATH env override). */
 export function getClaudeJsonPath() {
+    const envPath = process.env["CLAUDE_JSON_PATH"];
+    if (envPath)
+        return envPath;
     return join(homedir(), ".claude.json");
 }
-export function getLocalMcpPath() {
-    return join(process.cwd(), ".mcp.json");
+/** Return the path to the project-local MCP config file (.mcp.json in project root). */
+export async function getLocalMcpPath() {
+    return join(await findProjectRoot(), ".mcp.json");
 }
+/** Return the UluOps state directory (~/.uluops/). Harness-neutral. */
+export function getUluopsDir() {
+    return join(homedir(), ".uluops");
+}
+/** Return the path to the UluOps install manifest file (new location). */
 export function getManifestPath() {
-    return join(getClaudeHome(), "uluops-manifest.json");
+    return join(getUluopsDir(), "manifest.json");
 }
-export function getAgentsDir(localDefs) {
-    if (localDefs)
-        return join(process.cwd(), "uluops", "agents");
-    return join(getClaudeHome(), "agents");
+/** Return the legacy manifest path for migration. */
+export function getLegacyManifestPath() {
+    return join(getClaudeHome(), "uluops-manifest.json");
 }
-export function getCommandsDir(localDefs) {
-    if (localDefs)
-        return join(process.cwd(), "uluops", "commands");
-    return join(getClaudeHome(), "commands");
+/** Return the backup directory for a harness's config files. */
+export function getBackupDir(harnessName) {
+    return join(getUluopsDir(), "backups", harnessName);
 }
+/** Detect the user's shell and return its name and profile path, or null if unsupported. */
 export function getShellProfile() {
     const shell = process.env["SHELL"] ?? "";
     const home = homedir();

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

@@ -13,13 +13,21 @@ interface HookMatcher {
     matcher?: string;
     hooks: HookEntry[];
 }
-interface ClaudeSettings {
+export interface ClaudeSettings {
     permissions?: Record<string, unknown>;
     hooks?: Record<string, HookMatcher[]>;
     [key: string]: unknown;
 }
+export interface HookProbeResult {
+    hookType: string;
+    supported: boolean;
+    warning?: string;
+}
+/** Check whether the configured hook event type is in the known supported set. Returns the resolved hook type and a warning if unsupported. */
+export declare function probeHookSupport(): HookProbeResult;
 /**
  * Read an existing settings.json, or return empty object if it doesn't exist.
+ * Throws on malformed JSON to prevent silent data loss during merge+write.
  */
 export declare function readSettings(path: string): Promise<ClaudeSettings>;
 /**

package/dist/lib/settings-merger.js

@@ -4,37 +4,63 @@
  * Safe read/merge/remove for Claude Code's settings.json.
  * Only touches UluOps-managed hook entries — all other settings preserved.
  */
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
+import { atomicWrite } from "./atomic-write.js";
 /** Marker embedded in hook commands to identify UluOps-managed entries */
 const ULUOPS_HOOK_MARKER = "tools/agent-metrics";
+/** Supported hook event types in Claude Code. Update when Claude Code adds/renames types. */
+const SUPPORTED_HOOK_TYPES = new Set([
+    "SubagentStop",
+    "PreToolUse",
+    "PostToolUse",
+    "Notification",
+    "Stop",
+]);
+/** Configurable hook type via env var. Falls back to SubagentStop. */
+function getHookEventType() {
+    return process.env["ULUOPS_HOOK_TYPE"] ?? "SubagentStop";
+}
+/** Check whether the configured hook event type is in the known supported set. Returns the resolved hook type and a warning if unsupported. */
+export function probeHookSupport() {
+    const hookType = getHookEventType();
+    if (SUPPORTED_HOOK_TYPES.has(hookType)) {
+        return { hookType, supported: true };
+    }
+    return {
+        hookType,
+        supported: false,
+        warning: `Hook type "${hookType}" is not in the known supported set {${[...SUPPORTED_HOOK_TYPES].join(", ")}}. Metrics may silently fail if this hook type does not exist in Claude Code.`,
+    };
+}
 /**
  * Read an existing settings.json, or return empty object if it doesn't exist.
+ * Throws on malformed JSON to prevent silent data loss during merge+write.
  */
 export async function readSettings(path) {
+    let raw;
     try {
-        const raw = await readFile(path, "utf-8");
-        return JSON.parse(raw);
+        raw = await readFile(path, "utf-8");
     }
     catch {
-        return {};
+        return {}; // File doesn't exist — fresh config
     }
+    return JSON.parse(raw);
 }
 /**
  * Write settings back to file with stable formatting.
  */
 export async function writeSettings(path, settings) {
-    await writeFile(path, JSON.stringify(settings, null, 2) + "\n");
+    await atomicWrite(path, JSON.stringify(settings, null, 2) + "\n");
 }
 /**
  * Merge the UluOps SubagentStop hook into settings, preserving all other
  * hooks and settings. If a UluOps hook already exists, it is replaced.
  */
 export function mergeUluopsHook(settings, hookCommand) {
+    const hookType = getHookEventType();
     const hooks = settings.hooks ?? {};
-    const existing = hooks["SubagentStop"] ?? [];
-    // Remove any existing UluOps hook entries
+    const existing = hooks[hookType] ?? [];
     const filtered = existing.filter((m) => !m.hooks.some((h) => h.command.includes(ULUOPS_HOOK_MARKER)));
-    // Add the new UluOps hook
     const uluopsHook = {
         hooks: [
             {
@@ -48,7 +74,7 @@ export function mergeUluopsHook(settings, hookCommand) {
         ...settings,
         hooks: {
             ...hooks,
-            SubagentStop: [...filtered, uluopsHook],
+            [hookType]: [...filtered, uluopsHook],
         },
     };
 }
@@ -57,19 +83,20 @@ export function mergeUluopsHook(settings, hookCommand) {
  * the key is removed. If hooks becomes empty, the key is removed.
  */
 export function removeUluopsHook(settings) {
+    const hookType = getHookEventType();
     const hooks = settings.hooks;
     if (!hooks)
         return settings;
-    const subagentStop = hooks["SubagentStop"];
-    if (!subagentStop)
+    const hookEntries = hooks[hookType];
+    if (!hookEntries)
         return settings;
-    const filtered = subagentStop.filter((m) => !m.hooks.some((h) => h.command.includes(ULUOPS_HOOK_MARKER)));
+    const filtered = hookEntries.filter((m) => !m.hooks.some((h) => h.command.includes(ULUOPS_HOOK_MARKER)));
     const updatedHooks = { ...hooks };
     if (filtered.length === 0) {
-        delete updatedHooks["SubagentStop"];
+        delete updatedHooks[hookType];
     }
     else {
-        updatedHooks["SubagentStop"] = filtered;
+        updatedHooks[hookType] = filtered;
     }
     const result = { ...settings };
     if (Object.keys(updatedHooks).length === 0) {
@@ -84,8 +111,9 @@ export function removeUluopsHook(settings) {
  * Check if a UluOps hook is configured in settings.
  */
 export function hasUluopsHook(settings) {
-    const subagentStop = settings.hooks?.["SubagentStop"];
-    if (!subagentStop)
+    const hookType = getHookEventType();
+    const hookEntries = settings.hooks?.[hookType];
+    if (!hookEntries)
         return false;
-    return subagentStop.some((m) => m.hooks.some((h) => h.command.includes(ULUOPS_HOOK_MARKER)));
+    return hookEntries.some((m) => m.hooks.some((h) => h.command.includes(ULUOPS_HOOK_MARKER)));
 }

package/dist/steps/agents.d.ts

@@ -1,8 +1,12 @@
+import type { HarnessProfile } from "../harnesses/index.js";
 export interface AgentsResult {
     copied: number;
     skipped: number;
     removed: number;
     files: string[];
 }
-export declare function installAgents(localDefs: boolean, dryRun: boolean, existingManifestAgents?: string[]): Promise<AgentsResult>;
+/** Copy agent definition files from assets to the harness agents directory,
+ *  transforming frontmatter to match the target harness format. */
+export declare function installAgents(profile: HarnessProfile, localDefs: boolean, dryRun: boolean, existingManifestAgents?: string[]): Promise<AgentsResult>;
+/** Remove previously installed agent files by name. */
 export declare function uninstallAgents(files: string[], defsPath: string): Promise<number>;

package/dist/steps/agents.js

@@ -1,14 +1,64 @@
+import { readFile, readdir, mkdir, unlink } from "node:fs/promises";
 import { join } from "node:path";
-import { ASSETS_DIR, getAgentsDir } from "../lib/paths.js";
-import { syncAssets, unlinkFiles } from "../lib/file-ops.js";
-export async function installAgents(localDefs, dryRun, existingManifestAgents) {
-    return syncAssets({
-        srcDir: join(ASSETS_DIR, "agents"),
-        destDir: getAgentsDir(localDefs),
-        dryRun,
-        oldManifestFiles: existingManifestAgents,
-    });
+import { ASSETS_DIR, findProjectRoot } from "../lib/paths.js";
+import { copyIfChanged, writeIfChanged, unlinkFiles } from "../lib/file-ops.js";
+import { transformAgent } from "../lib/agent-transform.js";
+/** Source directory for agent assets (single set, Claude Code format). */
+const AGENTS_SRC = join(ASSETS_DIR, "agents");
+/** Copy agent definition files from assets to the harness agents directory,
+ *  transforming frontmatter to match the target harness format. */
+export async function installAgents(profile, localDefs, dryRun, existingManifestAgents) {
+    const destDir = localDefs
+        ? join(await findProjectRoot(), "uluops", "agents")
+        : profile.paths.agentsDir;
+    if (!dryRun) {
+        await mkdir(destDir, { recursive: true });
+    }
+    const needsTransform = profile.name !== "claude-code";
+    let files;
+    try {
+        files = (await readdir(AGENTS_SRC)).filter((f) => f.endsWith(".md"));
+    }
+    catch {
+        return { copied: 0, skipped: 0, removed: 0, files: [] };
+    }
+    let copied = 0;
+    let skipped = 0;
+    for (const file of files) {
+        let result;
+        if (needsTransform) {
+            const markdown = await readFile(join(AGENTS_SRC, file), "utf-8");
+            const transformed = transformAgent(markdown, profile.name);
+            result = await writeIfChanged(join(destDir, file), transformed, dryRun);
+        }
+        else {
+            result = await copyIfChanged(join(AGENTS_SRC, file), join(destDir, file), dryRun);
+        }
+        if (result === "copied")
+            copied++;
+        else
+            skipped++;
+    }
+    // Remove files that were in the old manifest but no longer in the package
+    let removed = 0;
+    if (existingManifestAgents) {
+        for (const oldFile of existingManifestAgents) {
+            if (!files.includes(oldFile)) {
+                if (!dryRun) {
+                    try {
+                        await unlink(join(destDir, oldFile));
+                    }
+                    catch {
+                        // Already gone
+                    }
+                }
+                removed++;
+            }
+        }
+    }
+    return { copied, skipped, removed, files };
 }
+/** Remove previously installed agent files by name. */
 export async function uninstallAgents(files, defsPath) {
     return unlinkFiles(join(defsPath, "agents"), files);
 }

package/dist/steps/auth.js

@@ -1,6 +1,9 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
+function getKeyPrefix() {
+    return process.env["ULUOPS_KEY_PREFIX"] ?? "ulr_";
+}
 /**
  * Resolve API key from flags, env, credentials file, or interactive prompt.
  */
@@ -20,20 +23,22 @@ export async function resolveApiKey(options) {
         if (!options.interactive) {
             throw new Error("No API key found. Pass --api-key or set ULUOPS_API_KEY. Get one at app.uluops.ai/settings/api-keys");
         }
+        const prefix = getKeyPrefix();
         const { input } = await import("@inquirer/prompts");
         apiKey = await input({
             message: "Enter your UluOps API key",
             validate: (val) => {
                 if (!val.trim())
                     return "Get a key at app.uluops.ai/settings/api-keys";
-                if (!val.startsWith("ulr_"))
-                    return "API keys start with ulr_ — get one at app.uluops.ai/settings/api-keys";
+                if (!val.startsWith(prefix))
+                    return `API keys typically start with ${prefix} — if your key has a different format, just paste it and server validation will check it`;
                 return true;
             },
         });
     }
-    if (!apiKey?.startsWith("ulr_")) {
-        throw new Error("API keys start with ulr_ — get one at app.uluops.ai/settings/api-keys");
+    const prefix = getKeyPrefix();
+    if (!apiKey.startsWith(prefix) && !options.skipValidation) {
+        process.stderr.write(`  ⚠ Key does not start with expected prefix "${prefix}" — proceeding with server validation\n`);
     }
     // Validate against server
     if (!options.skipValidation) {
@@ -43,22 +48,33 @@ export async function resolveApiKey(options) {
     return { apiKey, email: null };
 }
 async function readCredentialsFile() {
+    const credsPath = join(homedir(), ".uluops", "credentials.json");
+    let raw;
     try {
-        const credsPath = join(homedir(), ".uluops", "credentials.json");
-        const raw = await readFile(credsPath, "utf-8");
-        const creds = JSON.parse(raw);
-        const defaultProfile = creds["default"];
-        return defaultProfile?.apiKey ?? defaultProfile?.api_key;
+        raw = await readFile(credsPath, "utf-8");
     }
     catch {
-        return undefined;
+        return undefined; // File doesn't exist
+    }
+    let creds;
+    try {
+        creds = JSON.parse(raw);
     }
+    catch (err) {
+        throw new Error(`Malformed credentials file at ${credsPath}: ${err instanceof Error ? err.message : "invalid JSON"}`);
+    }
+    if (typeof creds !== "object" || creds === null)
+        return undefined;
+    const profiles = creds;
+    const defaultProfile = profiles["default"];
+    return defaultProfile?.apiKey ?? defaultProfile?.api_key;
 }
 async function validateKey(apiKey) {
     const url = "https://api.uluops.ai/api/v1/registry/users/me";
     try {
         const res = await fetch(url, {
             headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(15000),
         });
         if (res.status === 401) {
             throw new Error("Invalid API key — generate a new one at app.uluops.ai/settings/api-keys");

package/dist/steps/commands.d.ts

@@ -1,9 +1,14 @@
+import type { HarnessProfile } from "../harnesses/index.js";
 export interface CommandsResult {
     agentCommands: number;
     workflowCommands: number;
+    pipelineCommands: number;
     skipped: number;
     removed: number;
     files: string[];
+    skippedReason?: string;
 }
-export declare function installCommands(localDefs: boolean, dryRun: boolean, existingManifestCommands?: string[]): Promise<CommandsResult>;
+/** Install slash-command files, transforming to target format as needed. */
+export declare function installCommands(profile: HarnessProfile, localDefs: boolean, dryRun: boolean, existingManifestCommands?: string[]): Promise<CommandsResult>;
+/** Remove previously installed command files by relative path. Returns count of successfully removed files. */
 export declare function uninstallCommands(files: string[], defsPath: string): Promise<number>;

package/dist/steps/commands.js

@@ -1,13 +1,75 @@
-import { readdir, mkdir, unlink } from "node:fs/promises";
+import { readFile, readdir, mkdir, unlink } from "node:fs/promises";
 import { join } from "node:path";
-import { ASSETS_DIR, getCommandsDir } from "../lib/paths.js";
-import { copyIfChanged } from "../lib/file-ops.js";
-const SUBDIRS = ["agents", "workflows"];
-export async function installCommands(localDefs, dryRun, existingManifestCommands) {
+import { ASSETS_DIR, findProjectRoot } from "../lib/paths.js";
+import { copyIfChanged, writeIfChanged } from "../lib/file-ops.js";
+const SUBDIRS = ["agents", "workflows", "pipelines"];
+/** Harnesses that support command installation. */
+const SUPPORTED_HARNESSES = new Set(["claude-code", "gemini-cli"]);
+// --- Gemini CLI transform ---
+/**
+ * Strip YAML frontmatter from rendered markdown, returning just the body.
+ */
+function stripFrontmatter(markdown) {
+    const first = markdown.indexOf("---");
+    if (first === -1)
+        return markdown;
+    const second = markdown.indexOf("---", first + 3);
+    if (second === -1)
+        return markdown;
+    return markdown.substring(second + 3);
+}
+/**
+ * Escape a string for use in a TOML basic string (double-quoted).
+ */
+function escapeToml(value) {
+    return value
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r")
+        .replace(/\t/g, "\\t");
+}
+/**
+ * Transform a Claude Code markdown command to a Gemini CLI TOML command.
+ * Strips frontmatter, substitutes $ARGUMENTS → {{args}}, wraps in TOML.
+ */
+function transformToGeminiToml(markdown, description) {
+    const body = stripFrontmatter(markdown)
+        .replace(/\$ARGUMENTS/g, "{{args}}")
+        .trim();
+    // Escape """ in body for TOML multi-line strings
+    const escaped = body.replace(/"""/g, '""\\"');
+    return `description = "${escapeToml(description)}"\nprompt = """\n${escaped}\n"""\n`;
+}
+/**
+ * Extract the description from a markdown command's YAML frontmatter.
+ */
+function extractDescription(markdown) {
+    const match = markdown.match(/^description:\s*(.+)$/m);
+    return match?.[1]?.trim() ?? "";
+}
+// --- Install ---
+/** Install slash-command files, transforming to target format as needed. */
+export async function installCommands(profile, localDefs, dryRun, existingManifestCommands) {
+    if (!SUPPORTED_HARNESSES.has(profile.name)) {
+        return {
+            agentCommands: 0,
+            workflowCommands: 0,
+            pipelineCommands: 0,
+            skipped: 0,
+            removed: 0,
+            files: [],
+            skippedReason: "not-supported",
+        };
+    }
     const srcBase = join(ASSETS_DIR, "commands");
-    const destBase = getCommandsDir(localDefs);
+    const destBase = localDefs
+        ? join(await findProjectRoot(), "uluops", "commands")
+        : profile.paths.commandsDir;
+    const needsTransform = profile.name === "gemini-cli";
     let agentCommands = 0;
     let workflowCommands = 0;
+    let pipelineCommands = 0;
     let skipped = 0;
     const allFiles = [];
     for (const subdir of SUBDIRS) {
@@ -24,13 +86,27 @@ export async function installCommands(localDefs, dryRun, existingManifestCommand
             continue;
         }
         for (const file of files) {
-            const relativePath = `${subdir}/${file}`;
-            const result = await copyIfChanged(join(srcDir, file), join(destDir, file), dryRun);
+            const destFile = needsTransform
+                ? file.replace(/\.md$/, ".toml")
+                : file;
+            const relativePath = `${subdir}/${destFile}`;
+            let result;
+            if (needsTransform) {
+                const markdown = await readFile(join(srcDir, file), "utf-8");
+                const description = extractDescription(markdown);
+                const toml = transformToGeminiToml(markdown, description);
+                result = await writeIfChanged(join(destDir, destFile), toml, dryRun);
+            }
+            else {
+                result = await copyIfChanged(join(srcDir, file), join(destDir, destFile), dryRun);
+            }
             if (result === "copied") {
                 if (subdir === "agents")
                     agentCommands++;
-                else
+                else if (subdir === "workflows")
                     workflowCommands++;
+                else
+                    pipelineCommands++;
             }
             else {
                 skipped++;
@@ -58,11 +134,13 @@ export async function installCommands(localDefs, dryRun, existingManifestCommand
     return {
         agentCommands,
         workflowCommands,
+        pipelineCommands,
         skipped,
         removed,
         files: allFiles,
     };
 }
+/** Remove previously installed command files by relative path. Returns count of successfully removed files. */
 export async function uninstallCommands(files, defsPath) {
     const { unlinkFiles } = await import("../lib/file-ops.js");
     return unlinkFiles(join(defsPath, "commands"), files);

package/dist/steps/detect.d.ts

@@ -1,3 +1,4 @@
+import type { HarnessProfile } from "../harnesses/index.js";
 export interface Environment {
     os: "linux" | "darwin" | "win32";
     isWsl: boolean;
@@ -5,5 +6,7 @@ export interface Environment {
     shellProfile: string | null;
     nodeVersion: string;
     claudeHomeExists: boolean;
+    detectedHarnesses: HarnessProfile[];
 }
+/** Detect the current environment: OS, shell, Node version, harnesses, and Claude home status. */
 export declare function detect(): Promise<Environment>;

package/dist/steps/detect.js

@@ -1,13 +1,18 @@
 import { platform, release } from "node:os";
 import { access } from "node:fs/promises";
 import { getClaudeHome, getShellProfile } from "../lib/paths.js";
+import { detectHarnesses } from "../harnesses/index.js";
 const SUPPORTED_PLATFORMS = new Set(["linux", "darwin", "win32"]);
+/** Detect the current environment: OS, shell, Node version, harnesses, and Claude home status. */
 export async function detect() {
     const p = platform();
     if (!SUPPORTED_PLATFORMS.has(p)) {
         throw new Error(`Unsupported platform: ${p}. Expected linux, darwin, or win32.`);
     }
     const os = p;
+    if (os === "win32") {
+        throw new Error("Windows (native) is not supported. Please use WSL2 (Ubuntu) and run setup inside WSL.");
+    }
     const isWsl = os === "linux" && release().toLowerCase().includes("microsoft");
     const profile = getShellProfile();
     const nodeVersion = process.version;
@@ -19,6 +24,7 @@ export async function detect() {
     catch {
         // Does not exist
     }
+    const detectedHarnesses = detectHarnesses();
     return {
         os,
         isWsl,
@@ -26,5 +32,6 @@ export async function detect() {
         shellProfile: profile?.path ?? null,
         nodeVersion,
         claudeHomeExists,
+        detectedHarnesses,
     };
 }

package/dist/steps/mcp.d.ts

@@ -1,6 +1,10 @@
+import type { HarnessProfile } from "../harnesses/index.js";
 export interface McpResult {
     configPath: string;
     scope: "global" | "local";
+    packageWarnings: string[];
 }
-export declare function installMcp(apiKey: string, scope: "global" | "local", dryRun: boolean): Promise<McpResult>;
-export declare function uninstallMcp(configPath: string): Promise<void>;
+/** Write UluOps MCP server entries into a harness's config file. */
+export declare function installMcp(profile: HarnessProfile, apiKey: string, scope: "global" | "local", dryRun: boolean): Promise<McpResult>;
+/** Remove UluOps MCP server entries from the harness config. */
+export declare function uninstallMcp(profile: HarnessProfile, configPath: string): Promise<void>;