peaks-loop 4.1.2 → 4.1.4

package/dist/services/config/config-validation.d.ts

@@ -0,0 +1,19 @@
+import type { ModelProviderConfig, PeaksConfig } from './config-types.js';
+export declare function isSensitiveConfigPath(path: string): boolean;
+export declare function isLegacyConfigKey(path: string): boolean;
+export declare function isProviderConfigPath(path: string): boolean;
+export declare function isSecretKey(key: string): boolean;
+export declare function isProviderBaseUrlPath(path: string): boolean;
+export declare function validateProviderBaseUrl(value: unknown): void;
+export declare function getProxyUrlCandidate(key: string, value: unknown): unknown;
+export declare function isProxyConfigPath(path: string): boolean;
+export declare function validateModelProviderConfig(providers: ModelProviderConfig): void;
+export declare function validateProviderConfig(partial: Partial<PeaksConfig>): void;
+export declare function isValidProxyUrl(value: string): boolean;
+export declare function validateProxyUrl(value: unknown): void;
+export declare function validateProxyConfig(partial: Partial<PeaksConfig>): void;
+export declare function containsSensitiveConfigValue(value: unknown): boolean;
+export type RedactedConfigValue = string | number | boolean | null | RedactedConfigValue[] | {
+    [key: string]: RedactedConfigValue;
+};
+export declare function redactConfigSecrets(value: unknown, path?: string): RedactedConfigValue;

package/dist/services/config/config-validation.js

@@ -0,0 +1,152 @@
+/**
+ * Config key/URL validators and the secret-redaction surface.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+import { isRecord } from './config-primitives.js';
+export function isSensitiveConfigPath(path) {
+    const normalized = path.toLowerCase().replace(/[^a-z0-9]/g, '');
+    return (normalized.includes('apikey') ||
+        normalized.includes('accesskey') ||
+        normalized.includes('privatekey') ||
+        normalized.includes('token') ||
+        normalized.includes('secret') ||
+        normalized.includes('password') ||
+        normalized.includes('bearer') ||
+        normalized.includes('credential') ||
+        normalized.includes('auth'));
+}
+/**
+ * 2.0.1 slim-config contract: `~/.peaks/config.json` only stores
+ * `version` + `ocr.llm.*` placeholders. The 1.x → 2.0 migration
+ * moved per-project fields (`language`, `model`, `economyMode`,
+ * `swarmMode`) to `<project>/.peaks/preferences.json` (per spec
+ * §10.4). `setConfig` rejects writes to those keys and points the
+ * user to the preferences path; tokens / providers / proxy still
+ * live in `~/.peaks/config.json` (the loader is tolerant of them
+ * but does not synthesise defaults for them anymore).
+ */
+const LEGACY_CONFIG_KEYS = new Set([
+    'language',
+    'model',
+    'economyMode',
+    'swarmMode'
+]);
+export function isLegacyConfigKey(path) {
+    const topLevel = path.split(/[.[].*/, 1)[0] ?? '';
+    return LEGACY_CONFIG_KEYS.has(topLevel);
+}
+export function isProviderConfigPath(path) {
+    return path === 'providers' || path.startsWith('providers.');
+}
+export function isSecretKey(key) {
+    return isSensitiveConfigPath(key);
+}
+function sanitizeBaseUrlForDisplay(value) {
+    try {
+        const url = new URL(value);
+        url.username = '';
+        url.password = '';
+        url.search = '';
+        url.hash = '';
+        return url.toString();
+    }
+    catch {
+        return '[invalid-url-redacted]';
+    }
+}
+export function isProviderBaseUrlPath(path) {
+    return /^providers\.[^.]+\.baseUrl$/.test(path);
+}
+function isValidProviderBaseUrl(value) {
+    try {
+        const url = new URL(value);
+        return (url.protocol === 'https:' &&
+            url.username.length === 0 &&
+            url.password.length === 0 &&
+            url.search.length === 0 &&
+            url.hash.length === 0);
+    }
+    catch {
+        return false;
+    }
+}
+export function validateProviderBaseUrl(value) {
+    if (value !== undefined && (typeof value !== 'string' || !isValidProviderBaseUrl(value))) {
+        throw new Error('Provider base URL must be HTTPS without embedded credentials, query, or fragment');
+    }
+}
+export function getProxyUrlCandidate(key, value) {
+    if (key === 'proxy.httpProxy') {
+        return value;
+    }
+    if (key === 'proxy' && isRecord(value)) {
+        return value.httpProxy;
+    }
+    return undefined;
+}
+export function isProxyConfigPath(path) {
+    return path === 'proxy' || path.startsWith('proxy.');
+}
+export function validateModelProviderConfig(providers) {
+    for (const provider of Object.values(providers)) {
+        validateProviderBaseUrl(provider?.baseUrl);
+    }
+}
+export function validateProviderConfig(partial) {
+    validateModelProviderConfig(partial.providers ?? {});
+}
+export function isValidProxyUrl(value) {
+    try {
+        const url = new URL(value);
+        return ((url.protocol === 'http:' || url.protocol === 'https:') &&
+            url.username.length === 0 &&
+            url.password.length === 0 &&
+            url.pathname === '/' &&
+            url.search.length === 0 &&
+            url.hash.length === 0);
+    }
+    catch {
+        return false;
+    }
+}
+export function validateProxyUrl(value) {
+    if (value !== undefined && (typeof value !== 'string' || !isValidProxyUrl(value))) {
+        throw new Error('Proxy URL must be an HTTP or HTTPS URL without embedded credentials');
+    }
+}
+export function validateProxyConfig(partial) {
+    validateProxyUrl(partial.proxy?.httpProxy);
+}
+export function containsSensitiveConfigValue(value) {
+    if (Array.isArray(value)) {
+        return value.some(containsSensitiveConfigValue);
+    }
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    return Object.entries(value).some(([key, entry]) => isSecretKey(key) || containsSensitiveConfigValue(entry));
+}
+export function redactConfigSecrets(value, path = '') {
+    if (Array.isArray(value)) {
+        return value.map((item, index) => redactConfigSecrets(item, `${path}[${index}]`));
+    }
+    if (value === null || typeof value !== 'object') {
+        if (isProviderBaseUrlPath(path) && typeof value === 'string') {
+            return sanitizeBaseUrlForDisplay(value);
+        }
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
+        const nextPath = path ? `${path}.${key}` : key;
+        if (isSecretKey(key)) {
+            return [key, '***'];
+        }
+        if (isProviderBaseUrlPath(nextPath) && typeof entry === 'string') {
+            return [key, sanitizeBaseUrlForDisplay(entry)];
+        }
+        return [key, redactConfigSecrets(entry, nextPath)];
+    }));
+}

package/dist/services/config/config-workspace.d.ts

@@ -0,0 +1,10 @@
+import type { ConfigLayer, WorkspaceConfig } from './config-types.js';
+export declare function getWorkspaceConfig(workspaceId: string, _projectRoot?: string | null): WorkspaceConfig | null;
+export declare function addWorkspace(workspace: WorkspaceConfig, layer?: ConfigLayer): void;
+export declare function removeWorkspace(workspaceId: string, layer?: ConfigLayer): boolean;
+export declare function setCurrentWorkspace(workspaceId: string, layer?: ConfigLayer): boolean;
+export declare function getCurrentWorkspaceConfig(): WorkspaceConfig | null;
+export declare function getWorkspaceConfigForPath(path?: string): WorkspaceConfig | null;
+export declare function ensureWorkspaceConfigForPath(path?: string): WorkspaceConfig | null;
+export declare function getWorkspaceConfigForCurrentPath(): WorkspaceConfig | null;
+export declare function ensureWorkspaceConfigForCurrentPath(): WorkspaceConfig | null;

package/dist/services/config/config-workspace.js

@@ -0,0 +1,158 @@
+/**
+ * Workspace registry: the raw `workspaces` / `currentWorkspace` fields and the artifact marker.
+ *
+ * Split out of `config-service.ts` (file-size cap campaign). The service
+ * re-exports every name declared here, so existing importers keep using
+ * `./config-service.js` unchanged.
+ */
+import { existsSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { stablePath } from '../../shared/path-utils.js';
+import { getUserConfigPath, isInsidePath, resolveProjectRootForConfig, validateArtifactWorkspaceMarkerPath, validateArtifactWorkspaceRoot, validateProjectBootstrapConfigPathForWrite, validateUserConfigPathForWrite, writeConfigFileSafely, writeProjectConfigFile, writeUserConfigFile } from './config-safety.js';
+import { toWorkspaceConfigs } from './config-coercion.js';
+import { ensureDir, getProjectWriteTarget, readJsonFile } from './config-file-io.js';
+import { getConfig } from './config-get.js';
+import { isRecord, isSafeConfigSegment } from './config-primitives.js';
+function readRawWorkspaceData(layer) {
+    const config = getConfig({ layer });
+    return isRecord(config)
+        ? {
+            currentWorkspace: typeof config.currentWorkspace === 'string' ? config.currentWorkspace : null,
+            workspaces: toWorkspaceConfigs(config.workspaces)
+        }
+        : { currentWorkspace: null, workspaces: [] };
+}
+function writeRawWorkspaceData(data, layer) {
+    const projectTarget = layer === 'project' ? getProjectWriteTarget() : null;
+    const targetPath = projectTarget?.configPath ?? getUserConfigPath();
+    ensureDir(dirname(targetPath));
+    const existing = projectTarget
+        ? (readJsonFile(targetPath, () => validateProjectBootstrapConfigPathForWrite(projectTarget.projectRoot, targetPath)) ?? {})
+        : (readJsonFile(targetPath, () => validateUserConfigPathForWrite(targetPath)) ?? {});
+    const merged = { ...existing, ...data };
+    const content = JSON.stringify(merged, null, 2);
+    if (projectTarget) {
+        writeProjectConfigFile(projectTarget.projectRoot, targetPath, content);
+    }
+    else {
+        writeUserConfigFile(targetPath, content);
+    }
+}
+function readAllWorkspaces() {
+    const userData = readRawWorkspaceData('user');
+    const projectData = readRawWorkspaceData('project');
+    const mergedWorkspaces = new Map();
+    for (const w of userData.workspaces)
+        mergedWorkspaces.set(w.workspaceId, w);
+    for (const w of projectData.workspaces)
+        mergedWorkspaces.set(w.workspaceId, w);
+    return {
+        currentWorkspace: projectData.currentWorkspace ?? userData.currentWorkspace,
+        workspaces: [...mergedWorkspaces.values()]
+    };
+}
+export function getWorkspaceConfig(workspaceId, _projectRoot) {
+    // Accepted for signature stability: the registry spans the user and project
+    // layers, so the id alone identifies the workspace.
+    void _projectRoot;
+    const { workspaces } = readAllWorkspaces();
+    return workspaces.find((w) => w.workspaceId === workspaceId) ?? null;
+}
+function readLayerConfig(layer) {
+    return readRawWorkspaceData(layer);
+}
+export function addWorkspace(workspace, layer = 'user') {
+    if (!isSafeConfigSegment(workspace.workspaceId)) {
+        throw new Error('Workspace id must only contain letters, numbers, dots, underscores, or hyphens and must not contain path traversal');
+    }
+    const config = readRawWorkspaceData(layer);
+    const workspaces = config.workspaces;
+    const existing = workspaces.findIndex((w) => w.workspaceId === workspace.workspaceId);
+    const updatedWorkspaces = existing >= 0
+        ? workspaces.map((existingWorkspace) => existingWorkspace.workspaceId === workspace.workspaceId ? workspace : existingWorkspace)
+        : [...workspaces, workspace];
+    writeRawWorkspaceData({ workspaces: updatedWorkspaces }, layer);
+}
+export function removeWorkspace(workspaceId, layer = 'user') {
+    if (!isSafeConfigSegment(workspaceId))
+        return false;
+    const config = readRawWorkspaceData(layer);
+    const workspaces = config.workspaces;
+    const idx = workspaces.findIndex((w) => w.workspaceId === workspaceId);
+    if (idx < 0)
+        return false;
+    const updatedWorkspaces = workspaces.filter((w) => w.workspaceId !== workspaceId);
+    const currentWorkspace = config.currentWorkspace === workspaceId
+        ? (updatedWorkspaces[0]?.workspaceId ?? null)
+        : (config.currentWorkspace ?? null);
+    writeRawWorkspaceData({ workspaces: updatedWorkspaces, currentWorkspace }, layer);
+    return true;
+}
+export function setCurrentWorkspace(workspaceId, layer = 'user') {
+    if (!isSafeConfigSegment(workspaceId))
+        return false;
+    const config = readRawWorkspaceData(layer);
+    const workspaces = config.workspaces;
+    const exists = workspaces.some((w) => w.workspaceId === workspaceId);
+    if (!exists)
+        return false;
+    writeRawWorkspaceData({ currentWorkspace: workspaceId }, layer);
+    return true;
+}
+export function getCurrentWorkspaceConfig() {
+    const { currentWorkspace, workspaces } = readAllWorkspaces();
+    if (!currentWorkspace)
+        return null;
+    return workspaces.find((w) => w.workspaceId === currentWorkspace) ?? null;
+}
+export function getWorkspaceConfigForPath(path = process.cwd()) {
+    const { workspaces } = readAllWorkspaces();
+    return findWorkspaceForPath(workspaces, path);
+}
+function findWorkspaceForPath(workspaces, path) {
+    const targetPath = stablePath(path);
+    const matches = workspaces.flatMap((workspace) => {
+        if (!isAbsolute(workspace.rootPath) || !existsSync(workspace.rootPath))
+            return [];
+        const rootPath = stablePath(workspace.rootPath);
+        return isInsidePath(targetPath, rootPath) ? [{ workspace, rootPath }] : [];
+    });
+    if (matches.length === 0)
+        return null;
+    return matches.reduce((best, match) => match.rootPath.length > best.rootPath.length ? match : best).workspace;
+}
+function getWorkspaceArtifactRoot(workspace) {
+    return workspace.artifactStorage?.localPath
+        ? resolve(workspace.artifactStorage.localPath)
+        : resolve(workspace.rootPath, '.peaks', 'artifacts');
+}
+function ensureArtifactWorkspaceMarker(workspace) {
+    const artifactRoot = getWorkspaceArtifactRoot(workspace);
+    const peaksPath = resolve(artifactRoot, '.peaks');
+    const markerPath = resolve(peaksPath, 'config.json');
+    ensureDir(artifactRoot);
+    validateArtifactWorkspaceRoot(artifactRoot, workspace.rootPath);
+    ensureDir(peaksPath);
+    validateArtifactWorkspaceMarkerPath(artifactRoot, peaksPath, markerPath);
+    if (!existsSync(markerPath)) {
+        writeConfigFileSafely(markerPath, '{}\n', () => validateArtifactWorkspaceMarkerPath(artifactRoot, peaksPath, markerPath), 'Artifact workspace marker must stay inside the artifact workspace');
+    }
+}
+export function ensureWorkspaceConfigForPath(path = process.cwd()) {
+    const projectRoot = resolveProjectRootForConfig(path);
+    if (!isAbsolute(projectRoot) || !existsSync(projectRoot))
+        return null;
+    const config = readLayerConfig('user');
+    const existingWorkspace = findWorkspaceForPath(config.workspaces, path);
+    if (existingWorkspace) {
+        ensureArtifactWorkspaceMarker(existingWorkspace);
+        return existingWorkspace;
+    }
+    return null;
+}
+export function getWorkspaceConfigForCurrentPath() {
+    return getWorkspaceConfigForPath(process.cwd());
+}
+export function ensureWorkspaceConfigForCurrentPath() {
+    return ensureWorkspaceConfigForPath(process.cwd());
+}

package/dist/services/distribution/mcp-install-runner.d.ts

@@ -0,0 +1,21 @@
+import type { McpInstallCommand, McpInstallOutcome, McpInstallRunner } from './mcp-install.js';
+/**
+ * Ceiling on ONE harness command. `spawnSync` without `timeout` has no ceiling
+ * at all, and the failure it lets through is measured, not hypothetical: a
+ * real harness binary on this host starts and then does not return within 25 s.
+ * Unbounded, that blocks `peaks mcp install` in the foreground forever. Same
+ * class the MCP CLI executor bounds (`cli-executor.ts`), set to twice its 15 s
+ * because the child is the harness's binary and its startup is its own to
+ * spend. A plan is at most three commands, so the install is bounded at 3x.
+ */
+export declare const MCP_INSTALL_TIMEOUT_MS = 30000;
+/**
+ * One harness command, with the deadline applied. `windowsHide` is the tree's
+ * spawn contract: a CLI that briefly runs a harness must not flash a console
+ * window on a desktop OS. `timeoutMs` is a parameter only so a test can watch
+ * the deadline fire without waiting out the production value — callers want
+ * `spawnMcpInstallRunner`, which fixes it.
+ */
+export declare function spawnMcpInstallCommand(command: McpInstallCommand, timeoutMs?: number): McpInstallOutcome;
+/** The production runner: the deadline above, and nothing else left to decide. */
+export declare const spawnMcpInstallRunner: McpInstallRunner;

package/dist/services/distribution/mcp-install-runner.js

@@ -0,0 +1,59 @@
+// src/services/distribution/mcp-install-runner.ts
+//
+// The production runner behind the vendor-neutral MCP registration engine
+// (`mcp-install.ts`): it runs one harness command under a deadline and reports
+// what the process said. It lives in its own module only so the engine keeps its
+// size; the engine RE-EXPORTS it, so every caller still imports it from
+// `mcp-install.js` and no import path moved.
+//
+// THE FIELD THIS MODULE EXISTS FOR. A run that exits non-zero ANSWERED the
+// question — "no such registration" — and a run the deadline kills, or one that
+// never launches, did not: `answered: false` is the only place that distinction
+// is born, and it is what stops `peaks mcp uninstall` from reporting a hung
+// harness's scope as "nothing was there".
+import { spawnSync } from 'node:child_process';
+/**
+ * Ceiling on ONE harness command. `spawnSync` without `timeout` has no ceiling
+ * at all, and the failure it lets through is measured, not hypothetical: a
+ * real harness binary on this host starts and then does not return within 25 s.
+ * Unbounded, that blocks `peaks mcp install` in the foreground forever. Same
+ * class the MCP CLI executor bounds (`cli-executor.ts`), set to twice its 15 s
+ * because the child is the harness's binary and its startup is its own to
+ * spend. A plan is at most three commands, so the install is bounded at 3x.
+ */
+export const MCP_INSTALL_TIMEOUT_MS = 30_000;
+/**
+ * One harness command, with the deadline applied. `windowsHide` is the tree's
+ * spawn contract: a CLI that briefly runs a harness must not flash a console
+ * window on a desktop OS. `timeoutMs` is a parameter only so a test can watch
+ * the deadline fire without waiting out the production value — callers want
+ * `spawnMcpInstallRunner`, which fixes it.
+ */
+export function spawnMcpInstallCommand(command, timeoutMs = MCP_INSTALL_TIMEOUT_MS) {
+    const result = spawnSync(command.command, [...command.args], {
+        stdio: 'pipe',
+        windowsHide: true,
+        encoding: 'utf8',
+        timeout: timeoutMs
+    });
+    if (result.error !== undefined) {
+        // `spawnSync` kills the child at the deadline and reports its own timeout as
+        // ETIMEDOUT. A deadline and a launch failure are different facts, but they
+        // share the one that matters here: the harness never rendered a verdict.
+        const timedOut = result.error.code === 'ETIMEDOUT';
+        return {
+            ok: false,
+            answered: false,
+            detail: timedOut
+                ? `timed out after ${timeoutMs} ms and was killed: ${command.command} ${command.args.join(' ')}`
+                : result.error.message
+        };
+    }
+    if (result.status === 0) {
+        return { ok: true, detail: '' };
+    }
+    const stderr = (result.stderr ?? '').trim();
+    return { ok: false, detail: stderr.length > 0 ? stderr : `exit ${result.status ?? 'unknown'}` };
+}
+/** The production runner: the deadline above, and nothing else left to decide. */
+export const spawnMcpInstallRunner = (command) => spawnMcpInstallCommand(command);

package/dist/services/distribution/mcp-install.d.ts

@@ -0,0 +1,95 @@
+import type { IdeAdapter, IdeId } from '../ide/ide-types.js';
+import { type IdeMcpInstallProfile } from '../ide/ide-mcp-install-types.js';
+/** One process the plan wants run, as command + args. Never a joined string. */
+export interface McpInstallCommand {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+/** What one operation is for, so a report can say which step did what. */
+export type McpInstallOperation = 'remove' | 'add';
+export interface McpInstallStep {
+    readonly operation: McpInstallOperation;
+    /** The scope this step acts on; the target scope for an `add`. */
+    readonly scope: string;
+    readonly command: McpInstallCommand;
+}
+/** What a runner says happened. `detail` is surfaced verbatim when it did not. */
+export interface McpInstallOutcome {
+    readonly ok: boolean;
+    readonly detail: string;
+    /**
+     * `false` only when the harness NEVER RENDERED A VERDICT — the deadline killed
+     * it, or it never launched. A non-zero exit answered ("no such registration"),
+     * so an absent value reads as `true`, as does every outcome that predates this
+     * field.
+     */
+    readonly answered?: boolean;
+}
+/** The seam: a test supplies one, the CLI supplies the spawning one below. */
+export type McpInstallRunner = (command: McpInstallCommand) => McpInstallOutcome;
+export interface McpInstallReport {
+    readonly serverName: string;
+    /** Scopes where the removal reported success — i.e. there was something to remove. */
+    readonly removed: readonly string[];
+    /** Scopes where the removal reported failure — normally "nothing was there". */
+    readonly absent: readonly string[];
+    /**
+     * Scopes whose removal never reached a verdict — the harness timed out or never
+     * launched — so it is neither `removed` nor honestly `absent`. Optional because
+     * the install sweep tolerates a failed removal (it is about to write) and never
+     * populates it; the uninstall sweep always does.
+     */
+    readonly unknown?: readonly string[];
+    readonly added: boolean;
+    readonly ok: boolean;
+    readonly detail: string;
+}
+/**
+ * The argv that launches THIS installation's read-only MCP server.
+ *
+ * An interpreter and an entry path, in array form: the same shape `mcp serve`
+ * spawns and the same one the read-only executor uses. A bare CLI name would be
+ * a `.cmd` shim on some platforms, and picking a spelling per platform is the
+ * branch this tree forbids — resolving the pair needs none.
+ */
+export declare function resolveMcpServerArgv(): readonly string[];
+/** The plan: one removal per declared scope, then the addition. Order is the contract. */
+export declare function buildMcpInstallPlan(profile: IdeMcpInstallProfile, serverArgv: readonly string[]): readonly McpInstallStep[];
+/** Every removal, then the addition. A failed removal is a fact, not a failure. */
+export declare function runMcpInstallPlan(profile: IdeMcpInstallProfile, serverArgv: readonly string[], runner: McpInstallRunner): McpInstallReport;
+/**
+ * The removal sweep on its own — what `uninstall` is, and all that it is.
+ *
+ * `exit 0` removed it, `exit != 0` answered "no" (absent, unchanged) — but a run the
+ * deadline killed, or one that never launched, ANSWERED NOTHING, and calling that
+ * "nothing was there" is the lie this sweep used to tell. Those scopes are `unknown`,
+ * and `ok` is false whenever any scope is unknown: with a scope the harness never
+ * spoke for, the removal is unconfirmed and the state is not known.
+ */
+export declare function runMcpUninstallPlan(profile: IdeMcpInstallProfile, serverArgv: readonly string[], runner: McpInstallRunner): McpInstallReport;
+/**
+ * One adapter's outcome. `skipped` is a FIRST-CLASS result and not an error: the
+ * install's contract with an adapter that declares no registration entry is
+ * silence, and a caller that has to distinguish "did nothing" from
+ * "failed" needs the distinction to be in the value, not in a log line.
+ */
+export type AdapterMcpInstallResult = {
+    readonly ideId: IdeId;
+    readonly skipped: true;
+    readonly reason: string;
+} | {
+    readonly ideId: IdeId;
+    readonly skipped: false;
+    readonly report: McpInstallReport;
+};
+export declare const NO_MCP_INSTALL_REASON = "adapter declares no mcpInstall profile";
+/** Register this adapter's harness, or report that there is nothing to register. */
+export declare function installMcpForAdapter(adapter: IdeAdapter, serverArgv: readonly string[], runner: McpInstallRunner): AdapterMcpInstallResult;
+/** The same, for the removal side. */
+export declare function uninstallMcpForAdapter(adapter: IdeAdapter, serverArgv: readonly string[], runner: McpInstallRunner): AdapterMcpInstallResult;
+/**
+ * The production runner and its deadline live in `mcp-install-runner.ts` — split
+ * out only to keep this engine within the file-size cap. They are re-exported, so
+ * the boundary is invisible: every caller still imports them from here.
+ */
+export { MCP_INSTALL_TIMEOUT_MS, spawnMcpInstallCommand, spawnMcpInstallRunner } from './mcp-install-runner.js';