@evomap/evolver-mcp 2.0.0-beta.9 → 2.0.1

package/dist/installerShared.d.ts

@@ -0,0 +1,103 @@
+import type { McpServerCmd, RuntimeId } from './injection.js';
+/** Minimal gene projection consumed by the Cursor rules renderer. */
+export interface CursorGene {
+    id: string;
+    category?: string;
+    hint?: string;
+}
+/** Default command used by runtimes that support a SessionStart hook. The flag enables session-id capture. */
+export declare const DEFAULT_HOOK_COMMAND = "evolver inject session-start --hook-stdin";
+export declare const DEFAULT_PROMPT_RECALL_HOOK_COMMAND = "evolver inject prompt-recall --hook-stdin";
+export declare const EVOLVER_HOOK_STATUS = "evolver-managed-hook";
+/** Bind custom-command ownership to that exact command without adding undocumented hook-schema fields. */
+export declare function evolverManagedHookStatus(command: string): string;
+/** Remove only Evolver-owned handlers, retaining user handlers that share the same matcher group. */
+export declare function stripEvolverHookEntries(entries: readonly unknown[], trustManagedStatus?: boolean, managedCommands?: ReadonlySet<string>): {
+    changed: boolean;
+    entries: unknown[];
+};
+/** Runtime configuration scope. Project is the default when omitted. */
+export type InstallScope = 'user' | 'project';
+export interface InstallOptions {
+    /** Runtime config root. Runtime-specific user scopes may resolve their own home-anchored paths. */
+    configRoot: string;
+    /** Claude Code scope. Other runtimes may also use this to select project or user configuration. */
+    scope?: InstallScope;
+    /** The MCP server launch command registered in the runtime configuration. */
+    server: McpServerCmd;
+    /** Command the SessionStart hook runs to inject memory. */
+    hookCommand?: string;
+    /** Command the UserPromptSubmit hook runs. Default is local-only, default-off prompt recall. */
+    promptRecallHookCommand?: string;
+    /** Reinstall even if an Evolver install is already present. */
+    force?: boolean;
+    /** Plan and validate without writing config or backup files. */
+    dryRun?: boolean;
+    /** Cursor only: genes rendered into the managed project rules file. */
+    genes?: readonly CursorGene[];
+    /** Cursor only: cap on genes rendered into the always-on rules body. */
+    maxGenes?: number;
+    /** Antigravity only: override the user home used to resolve ~/.gemini config roots. */
+    homeDir?: string;
+    /** Kiro user scope only: direct replacement for ~/.kiro, matching KIRO_HOME semantics. */
+    kiroHome?: string;
+    /** OpenCode user scope only: explicit XDG_CONFIG_HOME used to resolve the global config. */
+    xdgConfigHome?: string;
+    /** OpenCode user scope only: explicit OPENCODE_CONFIG file override. */
+    opencodeConfig?: string;
+    /** OpenCode user scope only: explicit OPENCODE_CONFIG_DIR override. */
+    opencodeConfigDir?: string;
+    /** OpenCode only: inline config loaded after project/custom-directory config. */
+    opencodeConfigContent?: string;
+    /** OpenCode only: mirrors truthy OPENCODE_DISABLE_PROJECT_CONFIG handling. */
+    opencodeDisableProjectConfig?: boolean;
+    /** OpenCode only: injectable managed-config directory for hermetic tests. */
+    opencodeManagedConfigDir?: string;
+    /** OpenCode only: injectable macOS managed-preference paths for hermetic tests. */
+    opencodeManagedPreferencePaths?: readonly string[];
+    /** OpenCode only: injectable platform used to resolve system managed paths. */
+    opencodePlatform?: NodeJS.Platform;
+    /** OpenCode only: injectable ProgramData used to resolve the Windows managed path. */
+    opencodeProgramData?: string;
+    /** OpenCode only: injectable username used to resolve macOS managed preferences. */
+    opencodeUsername?: string;
+}
+export interface UninstallOptions {
+    configRoot: string;
+    scope?: InstallScope;
+    /** Antigravity only: override the user home used to resolve ~/.gemini config roots. */
+    homeDir?: string;
+    /** Kiro user scope only: direct replacement for ~/.kiro, matching KIRO_HOME semantics. */
+    kiroHome?: string;
+    /** Validate and report the uninstall without changing config or backup files. */
+    dryRun?: boolean;
+    /** OpenCode user scope only: explicit XDG_CONFIG_HOME used to resolve the global config. */
+    xdgConfigHome?: string;
+    /** OpenCode user scope only: explicit OPENCODE_CONFIG file override. */
+    opencodeConfig?: string;
+    /** OpenCode user scope only: explicit OPENCODE_CONFIG_DIR override. */
+    opencodeConfigDir?: string;
+}
+export interface InstallResult {
+    ok: boolean;
+    runtime: RuntimeId;
+    mode: string;
+    /** Absolute paths written (install) or cleaned (uninstall). */
+    files: string[];
+    alreadyInstalled?: boolean;
+    dryRun?: boolean;
+    verified?: boolean;
+    backups?: string[];
+    error?: string;
+}
+export declare class SymlinkRefusedError extends Error {
+    constructor(label: string, path: string);
+}
+export declare class UnparseableConfigError extends Error {
+    constructor(label: string, path: string, owner?: string);
+}
+export declare class EmptySharedConfigError extends Error {
+    constructor(label: string, path: string, owner?: string);
+}
+/** Refuse to read or write through a symlink at an adapter-owned path. */
+export declare function assertNotSymlink(path: string, label: string): void;

package/dist/installerShared.js

@@ -0,0 +1,99 @@
+import { lstatSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+/** Default command used by runtimes that support a SessionStart hook. The flag enables session-id capture. */
+export const DEFAULT_HOOK_COMMAND = 'evolver inject session-start --hook-stdin';
+export const DEFAULT_PROMPT_RECALL_HOOK_COMMAND = 'evolver inject prompt-recall --hook-stdin';
+export const EVOLVER_HOOK_STATUS = 'evolver-managed-hook';
+const LEGACY_EVOLVER_HOOK_STATUS = 'Loading Evolver memory';
+function isObj(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+const LEGACY_NODE_COMMAND = /^"?node(?:\.exe)?"?\s+/i;
+const LEGACY_EVOLVER_SCRIPT_BASENAME = /(?:^|[\\/'"\s])(?:evolver-session-start|evolver-session-end|evolver-signal-detect|evolver-task-recall|evolver-daemon-start)\.js(?=$|[\\/'"\s])/i;
+const LEGACY_V2_CLI_HOOK_COMMAND = /^"?evolver(?:\.cmd|\.exe)?"?\s+inject\s+(?:session-start|prompt-recall)(?:\s|$)/i;
+function isKnownEvolverHookCommand(command) {
+    const trimmed = command.trim();
+    return LEGACY_V2_CLI_HOOK_COMMAND.test(trimmed)
+        || (LEGACY_NODE_COMMAND.test(trimmed) && LEGACY_EVOLVER_SCRIPT_BASENAME.test(trimmed));
+}
+/** Bind custom-command ownership to that exact command without adding undocumented hook-schema fields. */
+export function evolverManagedHookStatus(command) {
+    if (isKnownEvolverHookCommand(command))
+        return EVOLVER_HOOK_STATUS;
+    const commandTag = createHash('sha256').update(command, 'utf8').digest('hex').slice(0, 16);
+    return `${EVOLVER_HOOK_STATUS} [evolver:${commandTag}]`;
+}
+function legacyEvolverManagedHookStatus(command) {
+    const currentStatus = evolverManagedHookStatus(command);
+    return `${LEGACY_EVOLVER_HOOK_STATUS}${currentStatus.slice(EVOLVER_HOOK_STATUS.length)}`;
+}
+const NO_MANAGED_HOOK_COMMANDS = new Set();
+const isEvolverHandler = (handler, trustManagedStatus, managedCommands) => {
+    if (!isObj(handler) || typeof handler['command'] !== 'string')
+        return false;
+    const command = handler['command'];
+    return isKnownEvolverHookCommand(command)
+        || (trustManagedStatus && (managedCommands.has(command)
+            || handler['statusMessage'] === evolverManagedHookStatus(command)
+            || handler['statusMessage'] === legacyEvolverManagedHookStatus(command)));
+};
+/** Remove only Evolver-owned handlers, retaining user handlers that share the same matcher group. */
+export function stripEvolverHookEntries(entries, trustManagedStatus = false, managedCommands = NO_MANAGED_HOOK_COMMANDS) {
+    let changed = false;
+    const keptEntries = [];
+    for (const entry of entries) {
+        if (!isObj(entry)) {
+            keptEntries.push(entry);
+            continue;
+        }
+        const handlers = entry['hooks'];
+        if (!Array.isArray(handlers)) {
+            if (isEvolverHandler(entry, trustManagedStatus, managedCommands))
+                changed = true;
+            else
+                keptEntries.push(entry);
+            continue;
+        }
+        const keptHandlers = handlers.filter((handler) => !isEvolverHandler(handler, trustManagedStatus, managedCommands));
+        if (keptHandlers.length === handlers.length) {
+            keptEntries.push(entry);
+            continue;
+        }
+        changed = true;
+        if (keptHandlers.length > 0)
+            keptEntries.push({ ...entry, hooks: keptHandlers });
+    }
+    return { changed, entries: keptEntries };
+}
+export class SymlinkRefusedError extends Error {
+    constructor(label, path) {
+        super(`[setup-hooks] refusing to operate: ${label} ${path} is a symbolic link — evolver will not follow symlinks for adapter-owned paths (a hostile workspace could redirect writes/unlinks outside the project). Replace it with a real directory/file and rerun.`);
+        this.name = 'SymlinkRefusedError';
+    }
+}
+export class UnparseableConfigError extends Error {
+    constructor(label, path, owner = 'Claude Code') {
+        super(`[setup-hooks] refusing to overwrite ${label} (${path}): the file exists and is non-empty but is not valid JSON. This is ${owner}'s own shared config; merging into it would replace the whole file and could wipe its contents. Fix or remove the corrupt file, then rerun.`);
+        this.name = 'UnparseableConfigError';
+    }
+}
+export class EmptySharedConfigError extends Error {
+    constructor(label, path, owner = 'Claude Code') {
+        super(`[setup-hooks] refusing to overwrite ${label} (${path}): the file exists but is empty or contains only whitespace. ${owner} may be in the middle of a truncating write, and treating it as fresh config could wipe shared config data. Fix the empty file or retry after ${owner} finishes writing it.`);
+        this.name = 'EmptySharedConfigError';
+    }
+}
+/** Refuse to read or write through a symlink at an adapter-owned path. */
+export function assertNotSymlink(path, label) {
+    let stat;
+    try {
+        stat = lstatSync(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    if (stat.isSymbolicLink())
+        throw new SymlinkRefusedError(label, path);
+}

package/dist/jsonMcpInstaller.d.ts

@@ -1,9 +1,11 @@
 import type { InjectionPlan, McpServerCmd, RuntimeId } from './injection.js';
-import { type InstallOptions, type InstallResult, type UninstallOptions } from './installer.js';
+import { type InstallOptions, type InstallResult, type UninstallOptions } from './installerShared.js';
 type BeforeReplaceHook = (path: string) => void;
 export declare function _setJsonMcpBeforeReplaceHookForTest(hook?: BeforeReplaceHook): void;
 export declare function _setJsonMcpAfterReplaceHookForTest(hook?: BeforeReplaceHook): void;
+export declare function _setJsonMcpAfterSharedFileValidateHookForTest(hook?: BeforeReplaceHook): void;
 export declare function _setJsonMcpBeforeBackupRemoveHookForTest(hook?: BeforeReplaceHook): void;
+export declare function _setJsonMcpBeforeSharedFileCommitHookForTest(hook?: BeforeReplaceHook): void;
 export interface JsonMcpRuntimeSpec {
     runtime: 'opencode' | 'kiro';
     configPath(opts: JsonMcpPathOptions): string;
@@ -70,6 +72,8 @@ export declare class McpConfigChangedError extends Error {
 export declare class McpServerValidationError extends Error {
     constructor(message: string);
 }
+declare function retrySharedConfigTransaction<T>(operation: () => T): T;
+export declare const _retrySharedConfigTransactionForTest: typeof retrySharedConfigTransaction;
 export declare function installJsonMcpRuntime(spec: JsonMcpRuntimeSpec, plan: InjectionPlan, opts: InstallOptions): InstallResult;
 export declare function uninstallJsonMcpRuntime(spec: JsonMcpRuntimeSpec, runtime: RuntimeId, opts: UninstallOptions): InstallResult;
 export {};

package/dist/jsonMcpInstaller.js

@@ -1,24 +1,34 @@
-import { chmodSync, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { chmodSync, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { EmptySharedConfigError, SymlinkRefusedError, UnparseableConfigError, } from './installer.js';
+import { EmptySharedConfigError, SymlinkRefusedError, UnparseableConfigError, } from './installerShared.js';
+import { commitSharedFile, SharedFileConflictError } from './sharedFileCommit.js';
 const CONFIG_MODE = 0o600;
 const DIR_MODE = 0o700;
 const BACKUP_VERSION = 1;
 const ENV_FILE_KEY = 'EVOLVER_ENV_FILE';
+const SHARED_CONFIG_WRITE_RETRIES = 5;
 let beforeReplaceHookForTest;
 let afterReplaceHookForTest;
+let afterSharedFileValidateHookForTest;
 let beforeBackupRemoveHookForTest;
+let beforeSharedFileCommitHookForTest;
 export function _setJsonMcpBeforeReplaceHookForTest(hook) {
     beforeReplaceHookForTest = hook;
 }
 export function _setJsonMcpAfterReplaceHookForTest(hook) {
     afterReplaceHookForTest = hook;
 }
+export function _setJsonMcpAfterSharedFileValidateHookForTest(hook) {
+    afterSharedFileValidateHookForTest = hook;
+}
 export function _setJsonMcpBeforeBackupRemoveHookForTest(hook) {
     beforeBackupRemoveHookForTest = hook;
 }
+export function _setJsonMcpBeforeSharedFileCommitHookForTest(hook) {
+    beforeSharedFileCommitHookForTest = hook;
+}
 function removeBackup(path) {
     beforeBackupRemoveHookForTest?.(path);
     rmSync(path);
@@ -361,25 +371,20 @@ function assertConfigTopologyUnchanged(runtime, safeRoot, snapshot) {
             throw new McpConfigChangedError(runtime, candidate.path);
     }
 }
-function atomicWrite(path, raw, mode, beforeRename) {
-    mkdirSync(dirname(path), { recursive: true, mode: DIR_MODE });
-    const tempPath = join(dirname(path), `.${randomUUID()}.tmp`);
-    try {
-        writeFileSync(tempPath, raw, { encoding: 'utf8', mode, flag: 'wx' });
-        chmodSync(tempPath, mode);
-        beforeRename?.();
-        renameSync(tempPath, path);
-    }
-    finally {
-        rmSync(tempPath, { force: true });
-    }
-}
 function guardedAtomicWrite(runtime, safeRoot, path, raw, mode, expectedRaw, additionalGuard) {
-    atomicWrite(path, raw, mode, () => {
-        beforeReplaceHookForTest?.(path);
-        assertSafeParents(runtime, safeRoot, path);
-        assertUnchanged(runtime, path, expectedRaw);
-        additionalGuard?.();
+    beforeReplaceHookForTest?.(path);
+    assertSafeParents(runtime, safeRoot, path);
+    assertUnchanged(runtime, path, expectedRaw);
+    additionalGuard?.();
+    commitSharedFile({
+        path,
+        expectedRaw: expectedRaw ?? undefined,
+        nextRaw: raw,
+        mode,
+        ...(afterSharedFileValidateHookForTest ? { afterValidateForTest: () => afterSharedFileValidateHookForTest?.(path) } : {}),
+        ...(beforeSharedFileCommitHookForTest
+            ? { beforeCommitForTest: () => beforeSharedFileCommitHookForTest?.(path) }
+            : {}),
     });
 }
 function guardedRemove(runtime, safeRoot, path, expectedRaw, additionalGuard) {
@@ -387,7 +392,15 @@ function guardedRemove(runtime, safeRoot, path, expectedRaw, additionalGuard) {
     assertSafeParents(runtime, safeRoot, path);
     assertUnchanged(runtime, path, expectedRaw);
     additionalGuard?.();
-    rmSync(path);
+    commitSharedFile({
+        path,
+        expectedRaw: expectedRaw ?? undefined,
+        nextRaw: undefined,
+        ...(afterSharedFileValidateHookForTest ? { afterValidateForTest: () => afterSharedFileValidateHookForTest?.(path) } : {}),
+        ...(beforeSharedFileCommitHookForTest
+            ? { beforeCommitForTest: () => beforeSharedFileCommitHookForTest?.(path) }
+            : {}),
+    });
 }
 function backupPath(configPath) {
     return `${configPath}.evolver-backup.json`;
@@ -552,7 +565,24 @@ function looksLikeEnvFilePointer(value) {
         || /^[.~$%]/.test(value)
         || /\.(?:env|dotenv)(?:$|[._-])/i.test(value);
 }
+function retrySharedConfigTransaction(operation) {
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            return operation();
+        }
+        catch (error) {
+            if (!(error instanceof SharedFileConflictError)
+                || error.recoveryPath !== undefined
+                || attempt >= SHARED_CONFIG_WRITE_RETRIES)
+                throw error;
+        }
+    }
+}
+export const _retrySharedConfigTransactionForTest = retrySharedConfigTransaction;
 export function installJsonMcpRuntime(spec, plan, opts) {
+    return retrySharedConfigTransaction(() => installJsonMcpRuntimeOnce(spec, plan, opts));
+}
+function installJsonMcpRuntimeOnce(spec, plan, opts) {
     validateServer(opts.server);
     const resolution = resolveInstallRuntimeConfig(spec, opts);
     const { configPath, safeRoot } = resolution;
@@ -707,6 +737,9 @@ function withoutEvolver(data, containerKey) {
     return next;
 }
 export function uninstallJsonMcpRuntime(spec, runtime, opts) {
+    return retrySharedConfigTransaction(() => uninstallJsonMcpRuntimeOnce(spec, runtime, opts));
+}
+function uninstallJsonMcpRuntimeOnce(spec, runtime, opts) {
     const resolution = resolveUninstallRuntimeConfig(spec, opts);
     const { configPath, safeRoot } = resolution;
     assertSafeParents(spec.runtime, safeRoot, configPath);

package/dist/kiroInstaller.d.ts

@@ -1,10 +1,10 @@
-import type { InstallOptions } from './installer.js';
+import type { InstallOptions } from './installerShared.js';
 import { type JsonMcpRuntimeResolution, type JsonMcpRuntimeSpec } from './jsonMcpInstaller.js';
 type KiroPathOptions = Pick<InstallOptions, 'configRoot' | 'scope' | 'homeDir' | 'kiroHome'>;
 /** Resolve only Kiro's base mcp.json contract; custom agent JSON is intentionally out of scope. */
 export declare function resolveKiroConfig(opts: KiroPathOptions): JsonMcpRuntimeResolution;
 export declare const KIRO_SPEC: JsonMcpRuntimeSpec;
 export declare function kiroConfigRoot({ configRoot, scope, homeDir, kiroHome }: Pick<InstallOptions, 'configRoot' | 'scope' | 'homeDir' | 'kiroHome'>): string;
-export declare const installKiro: (plan: import("./injection.js").InjectionPlan, opts: InstallOptions) => import("./installer.js").InstallResult;
-export declare const uninstallKiro: (runtime: import("./injection.js").RuntimeId, opts: import("./installer.js").UninstallOptions) => import("./installer.js").InstallResult;
+export declare const installKiro: (plan: import("./injection.js").InjectionPlan, opts: InstallOptions) => import("./installerShared.js").InstallResult;
+export declare const uninstallKiro: (runtime: import("./injection.js").RuntimeId, opts: import("./installerShared.js").UninstallOptions) => import("./installerShared.js").InstallResult;
 export {};

package/dist/opencodeInstaller.d.ts

@@ -1,4 +1,4 @@
-import type { InstallOptions } from './installer.js';
+import type { InstallOptions } from './installerShared.js';
 import { type JsonMcpRuntimeResolution, type JsonMcpRuntimeSpec } from './jsonMcpInstaller.js';
 type OpenCodePathOptions = Pick<InstallOptions, 'configRoot' | 'scope' | 'homeDir' | 'xdgConfigHome' | 'opencodeConfig' | 'opencodeConfigDir'>;
 type OpenCodeManagedPathOptions = Pick<InstallOptions, 'opencodePlatform' | 'opencodeProgramData' | 'opencodeUsername'>;
@@ -13,6 +13,6 @@ export declare function resolveOpenCodeManagedPreferencePaths(opts?: OpenCodeMan
  */
 export declare function resolveOpenCodeConfig(opts: OpenCodePathOptions): JsonMcpRuntimeResolution;
 export declare const OPENCODE_SPEC: JsonMcpRuntimeSpec;
-export declare const installOpenCode: (plan: import("./injection.js").InjectionPlan, opts: InstallOptions) => import("./installer.js").InstallResult;
-export declare const uninstallOpenCode: (runtime: import("./injection.js").RuntimeId, opts: import("./installer.js").UninstallOptions) => import("./installer.js").InstallResult;
+export declare const installOpenCode: (plan: import("./injection.js").InjectionPlan, opts: InstallOptions) => import("./installerShared.js").InstallResult;
+export declare const uninstallOpenCode: (runtime: import("./injection.js").RuntimeId, opts: import("./installerShared.js").UninstallOptions) => import("./installerShared.js").InstallResult;
 export {};

package/dist/proxyClient.d.ts

@@ -13,6 +13,7 @@ export interface ProxyFetch {
 export interface EvolverProxyClientOptions {
     baseUrl: string;
     token: string;
+    expectedHubMode?: 'public' | 'private';
     fetchFn?: ProxyFetch;
     reloadSettings?: () => EvolverProxyClientOptions | undefined;
 }
@@ -23,13 +24,16 @@ export interface ProxySearchArgs {
     category?: string;
     gene?: string;
     limit?: number;
+    expectedHubMode?: 'public' | 'private';
 }
 export interface ProxyFetchArgs {
     assetId?: string;
     assetIds?: string[];
+    expectedHubMode?: 'public' | 'private';
 }
 export interface ProxyAssetBundle {
     assets: unknown[];
+    expected_hub_mode?: 'public' | 'private';
 }
 export interface ProxyReuseResultArgs {
     assetId: string;
@@ -40,6 +44,7 @@ export interface ProxyReuseResultArgs {
     tokensSaved?: number;
     timeSavedSeconds?: number;
     reason?: string;
+    expectedHubMode?: 'public' | 'private';
 }
 export interface ProxyAgentSearchArgs {
     query?: string;
@@ -59,6 +64,7 @@ export declare class EvolverProxyClient {
     private baseUrl;
     private token;
     private readonly fetchFn;
+    private readonly expectedHubMode?;
     private readonly reloadSettings;
     constructor(opts: EvolverProxyClientOptions);
     status(opts?: {
@@ -70,15 +76,21 @@ export declare class EvolverProxyClient {
     getAgentProfile(agentId: string, timeoutMs?: number): Promise<unknown>;
     discoverAgentsForTask(args: ProxyAgentDiscoverArgs): Promise<unknown>;
     submitAsset(asset: unknown): Promise<unknown>;
+    submitAssetBundle(bundle: ProxyAssetBundle): Promise<unknown>;
     /** Pre-publish dry-run: the hub runs its quality + content-safety gate but stores nothing and charges no credits. */
     validateAsset(asset: unknown): Promise<unknown>;
     validateAssetBundle(bundle: ProxyAssetBundle): Promise<unknown>;
     distillConversation(input: unknown): Promise<unknown>;
     recordReuseResult(args: ProxyReuseResultArgs): Promise<unknown>;
+    private modeBoundBody;
     call(method: string, path: string, body?: unknown, opts?: {
         signal?: AbortSignal;
     }): Promise<unknown>;
+    private verifyExpectedHubMode;
+    private verifyReloadedHubMode;
+    private acceptResult;
     private callOnce;
+    private connectionSnapshot;
     private reloadFromSettings;
     private proxyError;
 }