@syrin/cli 1.3.1 → 1.4.0

package/dist/config/loader.js

@@ -4,10 +4,12 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { load } from 'js-yaml';
+import { load, dump } from 'js-yaml';
 import { validateConfig } from './schema.js';
 import { ConfigurationError } from '../utils/errors.js';
 import { Paths, Messages, ToolCommands } from '../constants/index.js';
+import { loadGlobalConfig } from './global-loader.js';
+import { mergeConfigs, createConfigFromGlobal, } from './merger.js';
 /**
  * Load configuration from syrin.yaml file.
  * @param projectRoot - Root directory of the project (defaults to current working directory)
@@ -15,13 +17,37 @@ import { Paths, Messages, ToolCommands } from '../constants/index.js';
  * @throws {ConfigurationError} If config file is missing or invalid
  */
 export function loadConfig(projectRoot = process.cwd()) {
-    const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
-    // Check if config file exists
-    if (!fs.existsSync(configPath)) {
+    const config = loadConfigOptional(projectRoot);
+    if (config === null) {
+        const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
         throw new ConfigurationError(Messages.ERROR_CONFIG_NOT_FOUND(ToolCommands.INIT), {
             context: { projectRoot, configPath },
         });
     }
+    return config;
+}
+/**
+ * Check if a configuration file exists.
+ * @param projectRoot - Root directory of the project
+ * @returns true if config file exists
+ */
+export function configExists(projectRoot = process.cwd()) {
+    const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
+    return fs.existsSync(configPath);
+}
+/**
+ * Load configuration from syrin.yaml file (optional).
+ * Returns null if file doesn't exist instead of throwing.
+ * @param projectRoot - Root directory of the project (defaults to current working directory)
+ * @returns Loaded and validated configuration, or null if file doesn't exist
+ * @throws {ConfigurationError} If config file exists but is invalid
+ */
+export function loadConfigOptional(projectRoot = process.cwd()) {
+    const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
+    // Check if config file exists
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
     try {
         // Read and parse YAML file
         const configContent = fs.readFileSync(configPath, 'utf-8');
@@ -46,12 +72,72 @@ export function loadConfig(projectRoot = process.cwd()) {
     }
 }
 /**
- * Check if a configuration file exists.
- * @param projectRoot - Root directory of the project
- * @returns true if config file exists
+ * Load configuration with global fallback.
+ * Tries local config first, then global config, then throws error.
+ * @param projectRoot - Root directory of the project (defaults to current working directory)
+ * @param flags - CLI flags that can override config values
+ * @returns Loaded and merged configuration
+ * @throws {Error} If neither local nor global config exists
  */
-export function configExists(projectRoot = process.cwd()) {
+export function loadConfigWithGlobal(projectRoot = process.cwd(), flags = {}) {
+    const localConfig = loadConfigOptional(projectRoot);
+    const globalConfig = loadGlobalConfig();
+    if (localConfig) {
+        return { config: mergeConfigs(localConfig, globalConfig), source: 'local' };
+    }
+    if (globalConfig) {
+        const adaptedConfig = createConfigFromGlobal(globalConfig, flags);
+        return { config: adaptedConfig, source: 'global' };
+    }
+    throw new ConfigurationError(Messages.ERROR_CONFIG_NOT_FOUND(ToolCommands.INIT), {
+        context: { projectRoot },
+    });
+}
+/**
+ * Save local configuration to syrin.yaml file.
+ * @param config - Configuration to save
+ * @param projectRoot - Root directory of the project (defaults to current working directory)
+ * @throws {ConfigurationError} If saving fails
+ */
+export function saveLocalConfig(config, projectRoot = process.cwd()) {
     const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
-    return fs.existsSync(configPath);
+    try {
+        // Convert config to plain object for YAML serialization
+        const configObject = {
+            version: config.version,
+            project_name: config.project_name,
+            agent_name: config.agent_name,
+            transport: config.transport,
+            ...(config.mcp_url ? { mcp_url: config.mcp_url } : {}),
+            ...(config.script ? { script: config.script } : {}),
+            llm: Object.fromEntries(Object.entries(config.llm).map(([key, provider]) => [
+                key,
+                {
+                    ...(provider.API_KEY !== undefined
+                        ? { API_KEY: provider.API_KEY }
+                        : {}),
+                    ...(provider.MODEL_NAME !== undefined
+                        ? { MODEL_NAME: provider.MODEL_NAME }
+                        : {}),
+                    default: provider.default,
+                },
+            ])),
+            ...(config.check ? { check: config.check } : {}),
+        };
+        // Serialize to YAML
+        const yamlContent = dump(configObject, {
+            indent: 2,
+            lineWidth: 100,
+            quotingType: '"',
+        });
+        // Write to file
+        fs.writeFileSync(configPath, yamlContent, 'utf-8');
+    }
+    catch (error) {
+        throw new ConfigurationError(`Failed to save local configuration: ${error instanceof Error ? error.message : String(error)}`, {
+            cause: error instanceof Error ? error : new Error(String(error)),
+            context: { configPath },
+        });
+    }
 }
 //# sourceMappingURL=loader.js.map

package/dist/config/merger.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Configuration merger.
+ * Merges local and global configurations with proper precedence.
+ */
+import type { SyrinConfig, GlobalSyrinConfig } from './types.js';
+/**
+ * CLI flags that can override config values.
+ */
+export interface CLIConfigFlags {
+    /** Transport type override */
+    transport?: 'stdio' | 'http';
+    /** MCP URL override (for http transport) */
+    mcp_url?: string;
+    /** Script command override (for stdio transport) */
+    script?: string;
+    /** LLM provider override */
+    llm?: string;
+}
+/**
+ * Merge local and global configurations.
+ * Local LLM providers override global, but other global providers are kept.
+ * @param local - Local configuration (from ./syrin.yaml) or null
+ * @param global - Global configuration (from ~/.syrin/syrin.yaml) or null
+ * @param flags - CLI flags that override config values
+ * @returns Merged configuration
+ * @throws {Error} If neither local nor global config exists
+ */
+export declare function mergeConfigs(local: SyrinConfig | null, global: GlobalSyrinConfig | null, flags?: CLIConfigFlags): SyrinConfig;
+/**
+ * Create a full SyrinConfig from global config and CLI flags.
+ * @param global - Global configuration
+ * @param flags - CLI flags that provide required fields
+ * @returns Full configuration
+ * @throws {Error} If required fields are missing
+ */
+export declare function createConfigFromGlobal(global: GlobalSyrinConfig, flags?: CLIConfigFlags): SyrinConfig;
+//# sourceMappingURL=merger.d.ts.map

package/dist/config/merger.js

@@ -0,0 +1,68 @@
+/**
+ * Configuration merger.
+ * Merges local and global configurations with proper precedence.
+ */
+import { makeProjectName, makeMCPURL, makeScriptCommand, } from '../types/factories.js';
+/**
+ * Merge local and global configurations.
+ * Local LLM providers override global, but other global providers are kept.
+ * @param local - Local configuration (from ./syrin.yaml) or null
+ * @param global - Global configuration (from ~/.syrin/syrin.yaml) or null
+ * @param flags - CLI flags that override config values
+ * @returns Merged configuration
+ * @throws {Error} If neither local nor global config exists
+ */
+export function mergeConfigs(local, global, flags = {}) {
+    // If local config exists, use it as base and merge LLM providers
+    if (local) {
+        const mergedLLM = {
+            ...(global?.llm || {}), // Start with global LLM providers
+            ...local.llm, // Override with local LLM providers
+        };
+        // Apply CLI flag overrides
+        const finalConfig = {
+            ...local,
+            llm: mergedLLM,
+            transport: flags.transport || local.transport,
+            mcp_url: flags.mcp_url ? makeMCPURL(flags.mcp_url) : local.mcp_url,
+            script: flags.script ? makeScriptCommand(flags.script) : local.script,
+        };
+        return finalConfig;
+    }
+    // No local config - create from global with defaults
+    if (!global) {
+        throw new Error('No configuration found. Create a local config with `syrin init` or set up global config with `syrin init --global`.');
+    }
+    // Create config from global
+    return createConfigFromGlobal(global, flags);
+}
+/**
+ * Create a full SyrinConfig from global config and CLI flags.
+ * @param global - Global configuration
+ * @param flags - CLI flags that provide required fields
+ * @returns Full configuration
+ * @throws {Error} If required fields are missing
+ */
+export function createConfigFromGlobal(global, flags = {}) {
+    // Transport is required - must come from flags
+    if (!flags.transport) {
+        throw new Error('Transport type is required when using global config. Use --transport <stdio|http> flag.');
+    }
+    // Validate transport-specific requirements
+    if (flags.transport === 'http' && !flags.mcp_url) {
+        throw new Error('MCP URL is required for HTTP transport. Use --mcp-url <url> flag.');
+    }
+    if (flags.transport === 'stdio' && !flags.script) {
+        throw new Error('Script command is required for stdio transport. Use --script <command> flag.');
+    }
+    return {
+        version: global.version,
+        project_name: makeProjectName('GlobalSyrin'),
+        agent_name: global.agent_name,
+        transport: flags.transport,
+        mcp_url: flags.mcp_url ? makeMCPURL(flags.mcp_url) : undefined,
+        script: flags.script ? makeScriptCommand(flags.script) : undefined,
+        llm: global.llm,
+    };
+}
+//# sourceMappingURL=merger.js.map

package/dist/config/schema.d.ts

@@ -3,7 +3,7 @@
  * Provides runtime validation for the Syrin configuration file.
  */
 import { z } from 'zod';
-import type { SyrinConfig } from '../config/types.js';
+import type { SyrinConfig, GlobalSyrinConfig } from '../config/types.js';
 /**
  * Main configuration schema.
  */
@@ -38,5 +38,30 @@ export declare const ConfigSchema: z.ZodObject<{
  * Type inference from schema.
  */
 export type ConfigSchemaType = z.infer<typeof ConfigSchema>;
+/**
+ * Global configuration schema (LLM settings only).
+ * No transport, mcp_url, or script fields.
+ */
+export declare const GlobalConfigSchema: z.ZodObject<{
+    version: z.ZodString;
+    project_name: z.ZodLiteral<"GlobalSyrin">;
+    agent_name: z.ZodString;
+    llm: z.ZodRecord<z.ZodString, z.ZodObject<{
+        API_KEY: z.ZodOptional<z.ZodString>;
+        MODEL_NAME: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Type inference from global schema.
+ */
+export type GlobalConfigSchemaType = z.infer<typeof GlobalConfigSchema>;
 export declare function validateConfig(config: unknown): SyrinConfig;
+/**
+ * Validate a global configuration object against the schema.
+ * @param config - Global configuration object to validate
+ * @returns Validated global configuration with opaque types
+ * @throws {ConfigurationError} If validation fails
+ */
+export declare function validateGlobalConfig(config: unknown): GlobalSyrinConfig;
 //# sourceMappingURL=schema.d.ts.map

package/dist/config/schema.js

@@ -5,6 +5,20 @@
 import { z } from 'zod';
 import { ConfigurationError } from '../utils/errors.js';
 import { makeProjectName, makeAgentName, makeMCPURL, makeAPIKey, makeModelName, makeScriptCommand, makeSyrinVersion, } from '../types/factories.js';
+/**
+ * Helper function to check if at least one LLM provider is set as default.
+ * @param llm - Record of LLM provider configurations
+ * @returns true if at least one provider has default === true
+ */
+function hasDefaultLLMProvider(llm) {
+    const providers = Object.values(llm);
+    return providers.some(provider => {
+        return (provider &&
+            typeof provider === 'object' &&
+            'default' in provider &&
+            provider.default === true);
+    });
+}
 /**
  * Schema for LLM provider configuration.
  */
@@ -86,14 +100,26 @@ export const ConfigSchema = z
     message: 'script is required when transport is "stdio"',
     path: ['script'],
 })
-    .refine(data => {
-    // At least one LLM provider should be set as default
-    const providers = Object.values(data.llm);
-    const hasDefault = providers.some(provider => {
-        return (provider && typeof provider === 'object' && provider.default === true);
-    });
-    return hasDefault;
-}, {
+    .refine(data => hasDefaultLLMProvider(data.llm), {
+    message: 'At least one LLM provider must be set as default',
+    path: ['llm'],
+});
+/**
+ * Global configuration schema (LLM settings only).
+ * No transport, mcp_url, or script fields.
+ */
+export const GlobalConfigSchema = z
+    .object({
+    version: z.string().min(1, 'Version is required'),
+    project_name: z.literal('GlobalSyrin'),
+    agent_name: z.string().min(1, 'Agent name is required'),
+    llm: z
+        .record(z.string(), LLMProviderSchema)
+        .refine(obj => Object.keys(obj).length > 0, {
+        message: 'At least one LLM provider is required',
+    }),
+})
+    .refine(data => hasDefaultLLMProvider(data.llm), {
     message: 'At least one LLM provider must be set as default',
     path: ['llm'],
 });
@@ -178,4 +204,43 @@ export function validateConfig(config) {
         throw error;
     }
 }
+/**
+ * Validate a global configuration object against the schema.
+ * @param config - Global configuration object to validate
+ * @returns Validated global configuration with opaque types
+ * @throws {ConfigurationError} If validation fails
+ */
+export function validateGlobalConfig(config) {
+    try {
+        const parsed = GlobalConfigSchema.parse(config);
+        // Transform to opaque types
+        // Note: project_name must be literal 'GlobalSyrin' for global config
+        const validated = {
+            version: makeSyrinVersion(parsed.version),
+            project_name: 'GlobalSyrin',
+            agent_name: makeAgentName(parsed.agent_name),
+            llm: Object.fromEntries(Object.entries(parsed.llm).map(([key, provider]) => [
+                key,
+                {
+                    API_KEY: provider.API_KEY
+                        ? makeAPIKey(provider.API_KEY)
+                        : undefined,
+                    MODEL_NAME: provider.MODEL_NAME
+                        ? makeModelName(provider.MODEL_NAME)
+                        : undefined,
+                    default: provider.default,
+                },
+            ])),
+        };
+        return validated;
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new ConfigurationError(formatValidationError(error), {
+                context: { errors: error.issues },
+            });
+        }
+        throw error;
+    }
+}
 //# sourceMappingURL=schema.js.map

package/dist/config/types.d.ts

@@ -50,6 +50,25 @@ export interface SyrinConfig {
     /** Tool testing configuration (v1.3.0) */
     check?: CheckConfig;
 }
+/**
+ * Global Syrin configuration (LLM settings only).
+ * Stored at ~/.syrin/syrin.yaml
+ */
+export interface GlobalSyrinConfig {
+    /** Configuration version */
+    version: SyrinVersion;
+    /** Project name (always "GlobalSyrin") */
+    project_name: 'GlobalSyrin';
+    /** Agent name (defaults to system username, can be customized) */
+    agent_name: AgentName;
+    /** LLM provider configurations */
+    llm: Record<string, LLMProviderConfig>;
+}
+/**
+ * Get default agent name from system.
+ * Tries: process.env.USER -> process.env.USERNAME -> os.userInfo().username -> 'Syrin'
+ */
+export declare function getDefaultAgentName(): string;
 /**
  * Options for initializing a new Syrin project.
  */

package/dist/config/types.js

@@ -2,5 +2,30 @@
  * Configuration type definitions for Syrin.
  * These types represent the structure of the syrin.yaml file.
  */
-export {};
+import * as os from 'os';
+/**
+ * Get default agent name from system.
+ * Tries: process.env.USER -> process.env.USERNAME -> os.userInfo().username -> 'Syrin'
+ */
+export function getDefaultAgentName() {
+    // Try process.env first (safest)
+    if (process.env.USER) {
+        return process.env.USER;
+    }
+    if (process.env.USERNAME) {
+        return process.env.USERNAME;
+    }
+    // Try os.userInfo() with error handling (can throw on some platforms)
+    try {
+        const username = os.userInfo().username;
+        if (username) {
+            return username;
+        }
+    }
+    catch {
+        // Swallow any exceptions from os.userInfo()
+    }
+    // Fallback to default
+    return 'Syrin';
+}
 //# sourceMappingURL=types.js.map

package/dist/constants/messages.d.ts

@@ -17,6 +17,13 @@ export declare const Messages: {
     readonly INIT_SETUP_ENV_VARS: "Set up your environment variables (API keys, etc.)";
     readonly INIT_RUN_DOCTOR: (doctorCommand: string) => string;
     readonly INIT_RUN_DEV: (devCommand: string) => string;
+    readonly GLOBAL_INIT_ALREADY_INITIALIZED: "Global Syrin configuration already exists!";
+    readonly GLOBAL_INIT_CONFIG_FILE: (configPath: string) => string;
+    readonly GLOBAL_INIT_SUCCESS: "Global Syrin configuration created successfully!";
+    readonly GLOBAL_INIT_EDIT_CONFIG: "Run `syrin config edit --global` to edit the configuration";
+    readonly GLOBAL_INIT_EDIT_ENV: "Run `syrin config edit-env --global` to set API keys";
+    readonly GLOBAL_INIT_REINITIALIZE_TIP: "Want to re-initialize?";
+    readonly GLOBAL_INIT_REINITIALIZE_INSTRUCTION: "Delete ~/.syrin/syrin.yaml and run `syrin init --global` again.";
     readonly ERROR_UNEXPECTED: "An unexpected error occurred";
     readonly ERROR_LOADING_CONFIG: "Failed to load configuration file";
     readonly ERROR_VALIDATION_FAILED: "Configuration validation failed";

package/dist/constants/messages.js

@@ -19,6 +19,14 @@ export const Messages = {
     INIT_SETUP_ENV_VARS: 'Set up your environment variables (API keys, etc.)',
     INIT_RUN_DOCTOR: (doctorCommand) => `Run \`${doctorCommand}\` to verify your Syrin setup`,
     INIT_RUN_DEV: (devCommand) => `Run \`${devCommand}\` to start development mode`,
+    // Global Init Command Messages
+    GLOBAL_INIT_ALREADY_INITIALIZED: 'Global Syrin configuration already exists!',
+    GLOBAL_INIT_CONFIG_FILE: (configPath) => `Configuration file: ${configPath}`,
+    GLOBAL_INIT_SUCCESS: 'Global Syrin configuration created successfully!',
+    GLOBAL_INIT_EDIT_CONFIG: 'Run `syrin config edit --global` to edit the configuration',
+    GLOBAL_INIT_EDIT_ENV: 'Run `syrin config edit-env --global` to set API keys',
+    GLOBAL_INIT_REINITIALIZE_TIP: 'Want to re-initialize?',
+    GLOBAL_INIT_REINITIALIZE_INSTRUCTION: 'Delete ~/.syrin/syrin.yaml and run `syrin init --global` again.',
     // Error Messages
     ERROR_UNEXPECTED: 'An unexpected error occurred',
     ERROR_LOADING_CONFIG: 'Failed to load configuration file',

package/dist/constants/paths.d.ts

@@ -19,6 +19,12 @@ export declare const Paths: {
     readonly DEV_HISTORY_FILE: ".syrin/.dev-history";
     /** Data directory for JSON exports (relative to project root) */
     readonly DATA_DIR: ".syrin/data";
+    /** Global Syrin configuration directory (absolute path) */
+    readonly GLOBAL_SYRIN_DIR: string;
+    /** Global configuration file (absolute path) - derived from GLOBAL_SYRIN_DIR */
+    readonly GLOBAL_CONFIG_FILE: string;
+    /** Global environment file (absolute path) - derived from GLOBAL_SYRIN_DIR */
+    readonly GLOBAL_ENV_FILE: string;
 };
 /**
  * File extension constants.

package/dist/constants/paths.js

@@ -2,6 +2,10 @@
  * File and directory path constants.
  * Centralized paths used throughout the application.
  */
+import * as os from 'os';
+import * as path from 'path';
+// Compute global directory once
+const GLOBAL_SYRIN_DIR = path.join(os.homedir(), '.syrin');
 export const Paths = {
     /** Syrin configuration directory name */
     SYRIN_DIR: '.syrin',
@@ -19,6 +23,12 @@ export const Paths = {
     DEV_HISTORY_FILE: '.syrin/.dev-history',
     /** Data directory for JSON exports (relative to project root) */
     DATA_DIR: '.syrin/data',
+    /** Global Syrin configuration directory (absolute path) */
+    GLOBAL_SYRIN_DIR,
+    /** Global configuration file (absolute path) - derived from GLOBAL_SYRIN_DIR */
+    GLOBAL_CONFIG_FILE: path.join(GLOBAL_SYRIN_DIR, 'syrin.yaml'),
+    /** Global environment file (absolute path) - derived from GLOBAL_SYRIN_DIR */
+    GLOBAL_ENV_FILE: path.join(GLOBAL_SYRIN_DIR, '.env'),
 };
 /**
  * File extension constants.

package/dist/events/emitter.js

@@ -1,5 +1,5 @@
 import { makeEventID, makeTimestamp } from '../types/factories.js';
-import { logger } from '../utils/logger.js';
+import { log } from '../utils/logger.js';
 import { EventStoreError } from '../utils/errors.js';
 /**
  * Runtime event emitter implementation.
@@ -37,7 +37,7 @@ export class RuntimeEventEmitter {
             if (appendResult instanceof Promise) {
                 return appendResult
                     .then(() => {
-                    logger.debug(`Event emitted: ${eventType}`, {
+                    log.debug(`Event emitted: ${eventType}`, {
                         event_id: event.event_id,
                         sequence: event.sequence,
                     });
@@ -47,7 +47,7 @@ export class RuntimeEventEmitter {
                 })
                     .catch((error) => {
                     const err = error instanceof Error ? error : new Error(String(error));
-                    logger.error('Failed to persist event', err, {
+                    log.error(`Error: ${err.message}`, err, {
                         event_id: event.event_id,
                         event_type: eventType,
                     });
@@ -59,7 +59,7 @@ export class RuntimeEventEmitter {
                 });
             }
             // Sync store
-            logger.debug(`Event emitted: ${eventType}`, {
+            log.debug(`Event emitted: ${eventType}`, {
                 event_id: event.event_id,
                 sequence: event.sequence,
             });
@@ -69,7 +69,7 @@ export class RuntimeEventEmitter {
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
-            logger.error('Failed to emit event', err, {
+            log.error(`Error: ${err.message}`, err, {
                 event_id: event.event_id,
                 event_type: eventType,
             });
@@ -119,7 +119,7 @@ export class RuntimeEventEmitter {
                 if (result instanceof Promise) {
                     result.catch((error) => {
                         const err = error instanceof Error ? error : new Error(String(error));
-                        logger.error('Error in event subscriber', err, {
+                        log.error(`Error: ${err.message}`, err, {
                             event_id: event.event_id,
                             event_type: event.event_type,
                         });
@@ -128,7 +128,7 @@ export class RuntimeEventEmitter {
             }
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));
-                logger.error('Error in event subscriber', err, {
+                log.error(`Error: ${err.message}`, err, {
                     event_id: event.event_id,
                     event_type: event.event_type,
                 });

package/dist/presentation/config-ui.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Presentation layer for config command UI.
+ * Separates display logic from business logic.
+ */
+import type { SyrinConfig, GlobalSyrinConfig } from '../config/types.js';
+/**
+ * Display configuration list/show output.
+ */
+export declare function displayConfigList(config: SyrinConfig | GlobalSyrinConfig, context: 'local' | 'global', configPath: string): void;
+/**
+ * Display success message for config update.
+ */
+export declare function displayConfigUpdated(key: string, value: string, context: 'local' | 'global', configPath: string): void;
+/**
+ * Display message for opening editor.
+ */
+export declare function displayEditorOpening(context: 'local' | 'global', filePath: string, editorName: string): void;
+/**
+ * Display message after editor closes.
+ */
+export declare function displayEditorClosed(fileType: 'config' | 'env'): void;
+/**
+ * Display setup completion message.
+ */
+export declare function displaySetupComplete(isGlobal: boolean): void;
+/**
+ * Display default provider set message.
+ */
+export declare function displayDefaultProviderSet(provider: string, context: 'local' | 'global'): void;
+/**
+ * Display provider removed message.
+ */
+export declare function displayProviderRemoved(provider: string, context: 'local' | 'global'): void;
+//# sourceMappingURL=config-ui.d.ts.map