Soul-driven AI agent with permission-hardened tools, token budgets, and multi-channel access. Runs 24/7 from CLI, Telegram or More.
import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, closeSync, openSync, renameSync, unlinkSync } from 'node:fs';
import { join, resolve } from 'node:path';
import { homedir } from 'node:os';
import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
import { config as loadDotenv } from 'dotenv';
import { logger } from './logger.js';
import type { SignalAccessUser, SignalPendingRequest, DiscordAccessUser, DiscordPendingRequest, SlackAccessUser, SlackPendingRequest } from '../types/channel.js';
import type { McpConfig } from '../capabilities/mcp/types.js';
import {
LEGACY_SEED_API_URL,
LEGACY_SEED_WS_URL,
MERCURY_CLOUD_API_URL,
MERCURY_CLOUD_WS_URL,
} from '../cloud/endpoints.js';
const MERCURY_HOME = join(homedir(), '.mercury');
loadDotenv();
const mercuryEnvPath = join(MERCURY_HOME, '.env');
if (existsSync(mercuryEnvPath)) {
loadDotenv({ path: mercuryEnvPath });
}
export function getMercuryHome(): string {
return process.env.MERCURY_HOME || MERCURY_HOME;
}
export function getMemoryDir(): string {
return join(getMercuryHome(), 'memory');
}
export interface ProviderConfig {
name: string;
apiKey: string;
baseUrl: string;
model: string;
enabled: boolean;
/** Optional per-provider cap on output tokens per request. */
maxOutputTokens?: number;
/**
* The owner says this endpoint's model reads images. `modelSeesImages` otherwise
* guesses from the model name, which cannot know about a self-hosted model — a
* local Qwen-VL called `qwen3.8-flash-next` was refused for that reason.
*/
vision?: boolean;
/**
* HTTP Basic credentials for a server behind a reverse proxy. When `username`
* is set, Mercury sends `Authorization: Basic ...` instead of the Bearer key.
*/
username?: string;
password?: string;
}
export interface TelegramAccessUser {
userId: number;
chatId: number;
username?: string;
firstName?: string;
requestedAt?: string;
approvedAt: string;
}
export interface TelegramPendingRequest {
userId: number;
chatId: number;
username?: string;
firstName?: string;
requestedAt: string;
pairingCode?: string;
}
export type ProviderName =
| 'mercuryCloud'
| 'aimlapi'
| 'openai'
| 'anthropic'
| 'deepseek'
| 'grok'
| 'atlascloud'
| 'runcrate'
| 'cloudgpu'
| 'ollamaCloud'
| 'ollamaLocal'
| 'atomicChat'
| 'openaiCompat'
| 'mimo'
| 'mimoTokenPlan'
| 'lmStudio'
| 'chatgptWeb'
| 'githubCopilot'
| 'litellm';
export interface CloudConfig {
enabled: boolean;
apiUrl: string;
wsUrl: string;
jwt: string;
refreshToken: string;
agentId: string;
tier: string;
agentApiKey: string;
accessKey?: string;
}
export interface MercuryConfig {
identity: {
name: string;
owner: string;
creator?: string;
/**
* Background Mercury should always know and can talk about: who made it,
* the team, what it's for. Included in every chat and call.
*/
about?: string;
};
cloud: CloudConfig;
providers: {
default: ProviderName;
aimlapi: ProviderConfig;
mercuryCloud: ProviderConfig;
openai: ProviderConfig;
anthropic: ProviderConfig;
deepseek: ProviderConfig;
grok: ProviderConfig;
atlascloud: ProviderConfig;
runcrate: ProviderConfig;
cloudgpu: ProviderConfig;
ollamaCloud: ProviderConfig;
ollamaLocal: ProviderConfig;
atomicChat: ProviderConfig;
openaiCompat: ProviderConfig;
mimo: ProviderConfig;
mimoTokenPlan: ProviderConfig;
lmStudio: ProviderConfig;
chatgptWeb: ProviderConfig;
githubCopilot: ProviderConfig;
litellm: ProviderConfig;
};
channels: {
telegram: {
enabled: boolean;
botToken: string;
webhookUrl?: string;
allowedChatIds?: number[];
streaming?: boolean;
admins: TelegramAccessUser[];
members: TelegramAccessUser[];
pending: TelegramPendingRequest[];
pairedUserId?: number;
pairedChatId?: number;
pairedUsername?: string;
};
signal: {
enabled: boolean;
phoneNumber: string;
mode: string;
groupId?: string;
groupName?: string;
admins: SignalAccessUser[];
members: SignalAccessUser[];
pending: SignalPendingRequest[];
};
discord: {
enabled: boolean;
botToken: string;
guildId?: string;
channelId?: string;
adminRoleName?: string;
streaming?: boolean;
admins: DiscordAccessUser[];
members: DiscordAccessUser[];
pending: DiscordPendingRequest[];
};
slack: {
enabled: boolean;
botToken: string;
appToken: string;
channelId?: string;
teamId?: string;
streaming?: boolean;
admins: SlackAccessUser[];
members: SlackAccessUser[];
pending: SlackPendingRequest[];
};
};
github: {
username: string;
email: string;
defaultOwner: string;
defaultRepo: string;
};
memory: {
shortTermMaxMessages: number;
secondBrain: {
enabled: boolean;
};
collaborativeKnowledge?: {
/** When true, new memories extracted via remember() are marked shareable. */
shareLearning?: boolean;
/** When true, the agent queries the cloud shared pool for additional
* context after retrieving from its local second brain. Defaults to
* true when the agent is paired with Mercury Cloud. */
poolSearch?: boolean;
};
/** The Owner Model's learning calls (ADR-026): per-turn extraction and the reflection pass. */
learning?: {
/**
* Provider to run extraction and reflection on, by name from `providers`.
* Unset (or not usable) → the default chat provider. These are strict
* JSON tasks, so a capable mid-tier model (e.g. anthropic with a Haiku
* model) learns far better than a free tier.
*/
provider?: string;
};
};
heartbeat: {
intervalMinutes: number;
};
tokens: {
dailyBudget: number;
/** When true, Token Saver Mode is manually enabled. Persisted. */
saverMode?: boolean;
/** Percentage of daily budget at which saver auto-engages (0 disables). */
saverAutoThreshold?: number;
/** Master switch for automatic engagement (defaults to true). */
saverAutoEnabled?: boolean;
/** Lifetime estimated tokens saved by saver mode (informational). */
saverTokensSavedLifetime?: number;
/**
* How much one cache-hit input token counts toward `dailyBudget`, 0–1.
* Default 1: every token counts. 0.1 roughly tracks cost, since providers
* bill cache hits at a fraction of the input price. Out-of-range values
* are clamped; anything non-numeric counts as 1.
*/
cachedWeight?: number;
};
subagents: {
enabled: boolean;
maxConcurrent: number;
mode: 'auto' | 'manual';
};
bots: {
enabled: boolean;
/** 0 = auto (clamp(2, cpus-1)). Fleet-wide cap on concurrent bot turns. */
maxConcurrent: number;
/** Shared secret for POST /api/bots/:id/hooks/* (unset = session auth only). */
webhookSecret?: string;
/** Auto-skill synthesis: draft SKILL.md from completed multi-step bot runs. */
autoSkill?: {
enabled?: boolean;
};
/** Fleet hierarchies: lead bots managing a crew of sub-bots. */
fleets?: {
/** Hard cap on crew size per lead (CrewAI guidance: 3-6 for delegation accuracy). */
maxCrew?: number;
/** Lead bots may create/remove their own crew via bot_spawn/bot_retire. */
allowLeadSpawn?: boolean;
/** Provider crew bots use when their manifest sets none (a cheaper lane for stage work). ADR-021. */
crewProvider?: string;
};
/** Per-bot daily token cap applied when a bot sets none (0 = unlimited). ADR-020. */
suggestedDailyTokenBudget?: number;
/** Fleet-wide daily token cap across all bots (0 = unlimited). ADR-020. */
fleetDailyTokenBudget?: number;
/** Fewest minutes between two runs of any bot routine (default 15). */
routineMinGapMinutes?: number;
/** How long a bot waits for the owner to answer its question before it's a no (default 10, max 60). */
approvalWaitMinutes?: number;
/** Owner-visible folder for finished results (default: ~/Documents/Mercury). */
deliverablesDir?: string;
retention: {
transcriptRuns: number;
journalRotateBytes: number;
journalKeepRotations: number;
mailboxTtlHours: number;
dlqCap: number;
artifactQuotaBytes: number;
/** Retention janitor for the fleet-shared folder (disabled = never sweep). */
sandboxJanitor: {
enabled: boolean;
/** Days a file stays in the working surface. */
hotDays: number;
/** Days an archived file survives before deletion. */
archiveDays: number;
};
};
};
spotify: {
enabled: boolean;
clientId: string;
clientSecret: string;
redirectUri: string;
accessToken: string;
refreshToken: string;
expiresAt: string;
scopes: string[];
deviceId: string;
accountName: string;
accountId: string;
product: string;
};
web: {
enabled: boolean;
port: number;
/**
* Extra browser origins allowed to call /api/* with a Bearer token
* (CORS). Mercury Desktop's own origins are always allowed; list a
* self-hosted web build or a dev server here. Never '*'.
*/
corsOrigins?: string[];
/**
* Host names this server may be reached by directly, besides localhost —
* only for a proxy of your own that rewrites Host and adds no forwarding
* headers. Anything else is refused (DNS rebinding).
*/
allowedHosts?: string[];
};
mcp?: McpConfig;
/** Opt-in: discover plugin and MCP schemas on demand in the main agent's tool loop. */
toolDiscovery?: { enabled?: boolean };
/**
* Chat turns running at once (ADR-037). One turn per chat at a time; this
* caps how many chats are worked on together. 0 = automatic (from heap
* size, RAM and platform; 2 on Termux). The turn governor admits fewer
* while memory is tight.
*/
concurrency?: { maxTurns?: number };
/** Where the files Mercury makes go (default ~/mercury-artifacts): Research/ and one folder per chat. */
artifacts?: {
outputDir?: string;
};
}
function getEnv(key: string, fallback: string = ''): string {
return process.env[key] || fallback;
}
function getEnvNum(key: string, fallback: number): number {
const val = process.env[key];
return val ? parseInt(val, 10) : fallback;
}
function getEnvBool(key: string, fallback: boolean): boolean {
const val = process.env[key]?.toLowerCase();
if (val === 'true') return true;
if (val === 'false') return false;
return fallback;
}
/**
* A capability the owner declares, where "not set" is a third state.
*
* `getEnvBool(key, false)` would answer `false` for a variable nobody set, and a `false` is a
* declaration: it switches images off for a model whose name the guesser would have accepted
* (`gpt-4o` behind a gateway). Undefined means "nothing declared", so the name-based guess in
* `modelSeesImages` still applies.
*/
function getEnvOptionalBool(key: string): boolean | undefined {
const val = process.env[key]?.toLowerCase();
if (val === 'true') return true;
if (val === 'false') return false;
return undefined;
}
export function getDefaultConfig(): MercuryConfig {
const home = getMercuryHome();
const cloudApiUrl = getEnv('MERCURY_CLOUD_API_URL', MERCURY_CLOUD_API_URL);
const cloudWsUrl = getEnv('MERCURY_CLOUD_WS_URL', MERCURY_CLOUD_WS_URL);
return {
identity: {
name: getEnv('MERCURY_NAME', 'Mercury'),
owner: getEnv('MERCURY_OWNER', ''),
creator: getEnv('MERCURY_CREATOR', ''),
about: getEnv('MERCURY_ABOUT', ''),
},
cloud: {
enabled: getEnvBool('MERCURY_CLOUD_ENABLED', false),
apiUrl: cloudApiUrl,
wsUrl: cloudWsUrl,
jwt: getEnv('MERCURY_CLOUD_JWT', ''),
refreshToken: getEnv('MERCURY_CLOUD_REFRESH_TOKEN', ''),
agentId: getEnv('MERCURY_CLOUD_AGENT_ID', ''),
tier: getEnv('MERCURY_CLOUD_TIER', 'free'),
agentApiKey: getEnv('MERCURY_CLOUD_AGENT_API_KEY', ''),
accessKey: getEnv('MERCURY_CLOUD_ACCESS_KEY', ''),
},
providers: {
default: getEnv('DEFAULT_PROVIDER', 'deepseek') as ProviderName,
aimlapi: {
name: 'aimlapi',
apiKey: getEnv('AIMLAPI_API_KEY', ''),
baseUrl: getEnv('AIMLAPI_BASE_URL', 'https://api.aimlapi.com/v1'),
model: getEnv('AIMLAPI_MODEL', 'anthropic/claude-sonnet-4.6'),
enabled: getEnvBool('AIMLAPI_ENABLED', true),
},
mercuryCloud: {
name: 'mercuryCloud',
apiKey: '',
baseUrl: cloudApiUrl,
model: getEnv('MERCURY_CLOUD_MODEL', 'mercury-mini'),
enabled: getEnvBool('MERCURY_CLOUD_ENABLED', false),
},
openai: {
name: 'openai',
apiKey: getEnv('OPENAI_API_KEY', ''),
baseUrl: getEnv('OPENAI_BASE_URL', 'https://api.openai.com/v1'),
model: getEnv('OPENAI_MODEL', 'gpt-4o-mini'),
enabled: getEnvBool('OPENAI_ENABLED', true),
},
anthropic: {
name: 'anthropic',
apiKey: getEnv('ANTHROPIC_API_KEY', ''),
baseUrl: getEnv('ANTHROPIC_BASE_URL', 'https://api.anthropic.com'),
model: getEnv('ANTHROPIC_MODEL', 'claude-sonnet-4-20250514'),
enabled: getEnvBool('ANTHROPIC_ENABLED', true),
},
deepseek: {
name: 'deepseek',
apiKey: getEnv('DEEPSEEK_API_KEY', ''),
baseUrl: getEnv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com/v1'),
model: getEnv('DEEPSEEK_MODEL', 'deepseek-chat'),
enabled: getEnvBool('DEEPSEEK_ENABLED', true),
...(getEnv('DEEPSEEK_MAX_OUTPUT_TOKENS', '') ? { maxOutputTokens: Number(getEnv('DEEPSEEK_MAX_OUTPUT_TOKENS', '')) } : {}),
},
grok: {
name: 'grok',
apiKey: getEnv('GROK_API_KEY', ''),
baseUrl: getEnv('GROK_BASE_URL', 'https://api.x.ai/v1'),
model: getEnv('GROK_MODEL', 'grok-4'),
enabled: getEnvBool('GROK_ENABLED', true),
},
atlascloud: {
name: 'atlascloud',
apiKey: getEnv('ATLASCLOUD_API_KEY', ''),
baseUrl: getEnv('ATLASCLOUD_BASE_URL', 'https://api.atlascloud.ai/v1'),
model: getEnv('ATLASCLOUD_MODEL', 'qwen/qwen3.5-flash'),
enabled: getEnvBool('ATLASCLOUD_ENABLED', true),
},
runcrate: {
name: 'runcrate',
apiKey: getEnv('RUNCRATE_API_KEY', ''),
baseUrl: getEnv('RUNCRATE_BASE_URL', 'https://api.runcrate.ai/v1'),
model: getEnv('RUNCRATE_MODEL', 'deepseek-ai/DeepSeek-V4.1-Flash'),
enabled: getEnvBool('RUNCRATE_ENABLED', true),
},
cloudgpu: {
name: 'cloudgpu',
apiKey: getEnv('CLOUDGPU_API_KEY', ''),
baseUrl: getEnv('CLOUDGPU_BASE_URL', 'https://cloudgpu.app/v1'),
model: getEnv('CLOUDGPU_MODEL', 'deepseek-v4.1-flash'),
enabled: getEnvBool('CLOUDGPU_ENABLED', true),
},
ollamaCloud: {
name: 'ollamaCloud',
apiKey: getEnv('OLLAMA_CLOUD_API_KEY', ''),
baseUrl: getEnv('OLLAMA_CLOUD_BASE_URL', 'https://ollama.com/v1'),
model: getEnv('OLLAMA_CLOUD_MODEL', 'gpt-oss:120b'),
enabled: getEnvBool('OLLAMA_CLOUD_ENABLED', true),
},
ollamaLocal: {
name: 'ollamaLocal',
apiKey: '',
baseUrl: getEnv('OLLAMA_LOCAL_BASE_URL', 'http://127.0.0.1:11434/v1'),
model: getEnv('OLLAMA_LOCAL_MODEL', ''),
enabled: getEnvBool('OLLAMA_LOCAL_ENABLED', false),
},
atomicChat: {
name: 'atomicChat',
apiKey: '',
baseUrl: getEnv('ATOMIC_CHAT_BASE_URL', 'http://127.0.0.1:1337/v1'),
model: getEnv('ATOMIC_CHAT_MODEL', ''),
enabled: getEnvBool('ATOMIC_CHAT_ENABLED', false),
},
openaiCompat: {
name: 'openaiCompat',
apiKey: getEnv('OPENAI_COMPAT_API_KEY', ''),
baseUrl: getEnv('OPENAI_COMPAT_BASE_URL', ''),
model: getEnv('OPENAI_COMPAT_MODEL', ''),
enabled: getEnvBool('OPENAI_COMPAT_ENABLED', false),
vision: getEnvOptionalBool('OPENAI_COMPAT_VISION'),
},
mimo: {
name: 'mimo',
apiKey: getEnv('MIMO_API_KEY', ''),
baseUrl: getEnv('MIMO_BASE_URL', 'https://api.xiaomimimo.com/v1'),
model: getEnv('MIMO_MODEL', 'mimo-v2.5-pro'),
enabled: getEnvBool('MIMO_ENABLED', true),
},
mimoTokenPlan: {
name: 'mimoTokenPlan',
apiKey: getEnv('MIMO_TOKEN_PLAN_API_KEY', ''),
baseUrl: getEnv('MIMO_TOKEN_PLAN_BASE_URL', 'https://token-plan-cn.xiaomimimo.com/v1'),
model: getEnv('MIMO_TOKEN_PLAN_MODEL', 'mimo-v2.5-pro'),
enabled: getEnvBool('MIMO_TOKEN_PLAN_ENABLED', false),
},
lmStudio: {
name: 'lmStudio',
apiKey: getEnv('LM_STUDIO_API_KEY', ''),
vision: getEnvOptionalBool('LM_STUDIO_VISION'),
baseUrl: getEnv('LM_STUDIO_BASE_URL', 'http://127.0.0.1:1234/v1'),
model: getEnv('LM_STUDIO_MODEL', ''),
enabled: getEnvBool('LM_STUDIO_ENABLED', false),
},
chatgptWeb: {
name: 'chatgptWeb',
apiKey: '', // not used — auth is via OAuth
baseUrl: 'https://chatgpt.com/backend-api',
model: getEnv('CHATGPT_WEB_MODEL', 'gpt-5.4-mini'),
enabled: getEnvBool('CHATGPT_WEB_ENABLED', false),
},
githubCopilot: {
name: 'githubCopilot',
apiKey: '', // not used — auth is via GitHub OAuth
baseUrl: '', // dynamic — resolved from Copilot token exchange
model: getEnv('GITHUB_COPILOT_MODEL', 'gpt-4o'),
enabled: getEnvBool('GITHUB_COPILOT_ENABLED', false),
},
litellm: {
name: 'litellm',
apiKey: getEnv('LITELLM_API_KEY', ''),
baseUrl: getEnv('LITELLM_BASE_URL', 'http://localhost:4000/v1'),
model: getEnv('LITELLM_MODEL', 'gpt-4o-mini'),
enabled: getEnvBool('LITELLM_ENABLED', false),
vision: getEnvOptionalBool('LITELLM_VISION'),
},
},
channels: {
telegram: {
enabled: getEnvBool('TELEGRAM_ENABLED', false),
botToken: getEnv('TELEGRAM_BOT_TOKEN', ''),
webhookUrl: getEnv('TELEGRAM_WEBHOOK_URL', ''),
allowedChatIds: getEnv('TELEGRAM_ALLOWED_CHAT_IDS', '')
.split(',')
.filter(Boolean)
.map(Number),
streaming: getEnvBool('TELEGRAM_STREAMING', true),
admins: [],
members: [],
pending: [],
},
signal: {
enabled: getEnvBool('SIGNAL_ENABLED', false),
phoneNumber: getEnv('SIGNAL_PHONE_NUMBER', ''),
mode: getEnv('SIGNAL_MODE', 'group'),
groupId: getEnv('SIGNAL_GROUP_ID', ''),
groupName: getEnv('SIGNAL_GROUP_NAME', 'Mercury'),
admins: [],
members: [],
pending: [],
},
discord: {
enabled: getEnvBool('DISCORD_ENABLED', false),
botToken: getEnv('DISCORD_BOT_TOKEN', ''),
guildId: getEnv('DISCORD_GUILD_ID', ''),
channelId: getEnv('DISCORD_CHANNEL_ID', ''),
adminRoleName: getEnv('DISCORD_ADMIN_ROLE_NAME', 'Mercury Admin'),
streaming: getEnvBool('DISCORD_STREAMING', true),
admins: [],
members: [],
pending: [],
},
slack: {
enabled: getEnvBool('SLACK_ENABLED', false),
botToken: getEnv('SLACK_BOT_TOKEN', ''),
appToken: getEnv('SLACK_APP_TOKEN', ''),
channelId: getEnv('SLACK_CHANNEL_ID', ''),
teamId: getEnv('SLACK_TEAM_ID', ''),
streaming: getEnvBool('SLACK_STREAMING', true),
admins: [],
members: [],
pending: [],
},
},
github: {
username: getEnv('GITHUB_USERNAME', ''),
email: getEnv('GITHUB_EMAIL', '[email protected]'),
defaultOwner: getEnv('GITHUB_DEFAULT_OWNER', ''),
defaultRepo: getEnv('GITHUB_DEFAULT_REPO', ''),
},
memory: {
shortTermMaxMessages: getEnvNum('SHORT_TERM_MAX_MESSAGES', 20),
secondBrain: {
enabled: getEnvBool('SECOND_BRAIN_ENABLED', true),
},
collaborativeKnowledge: {
shareLearning: getEnvBool('SHARE_LEARNING', false),
poolSearch: getEnvBool('POOL_SEARCH', true),
},
learning: {
...(process.env.LEARNING_PROVIDER ? { provider: process.env.LEARNING_PROVIDER } : {}),
},
},
heartbeat: {
intervalMinutes: getEnvNum('HEARTBEAT_INTERVAL_MINUTES', 60),
},
tokens: {
dailyBudget: getEnvNum('DAILY_TOKEN_BUDGET', 1_000_000),
},
subagents: {
enabled: getEnvBool('SUBAGENTS_ENABLED', true),
maxConcurrent: getEnvNum('SUBAGENTS_MAX_CONCURRENT', 0),
mode: (process.env.SUBAGENTS_MODE as 'auto' | 'manual') || 'auto',
},
bots: {
enabled: getEnvBool('BOTS_ENABLED', true),
maxConcurrent: getEnvNum('BOTS_MAX_CONCURRENT', 0),
webhookSecret: getEnv('BOTS_WEBHOOK_SECRET') || undefined,
autoSkill: {
enabled: getEnvBool('BOTS_AUTO_SKILL', false),
},
fleets: {
maxCrew: getEnvNum('BOTS_FLEET_MAX_CREW', 6),
allowLeadSpawn: getEnvBool('BOTS_FLEET_LEAD_SPAWN', true),
crewProvider: getEnv('BOTS_FLEET_CREW_PROVIDER') || undefined,
},
suggestedDailyTokenBudget: getEnvNum('BOTS_SUGGESTED_DAILY_TOKEN_BUDGET', 5_000_000),
fleetDailyTokenBudget: getEnvNum('BOTS_FLEET_DAILY_TOKEN_BUDGET', 20_000_000),
deliverablesDir: getEnv('BOTS_DELIVERABLES_DIR') || undefined,
retention: {
transcriptRuns: getEnvNum('BOTS_RETENTION_TRANSCRIPT_RUNS', 50),
journalRotateBytes: getEnvNum('BOTS_JOURNAL_ROTATE_BYTES', 5 * 1024 * 1024),
journalKeepRotations: getEnvNum('BOTS_JOURNAL_KEEP_ROTATIONS', 3),
mailboxTtlHours: getEnvNum('BOTS_MAILBOX_TTL_HOURS', 72),
dlqCap: getEnvNum('BOTS_DLQ_CAP', 100),
artifactQuotaBytes: getEnvNum('BOTS_ARTIFACT_QUOTA_BYTES', 500 * 1024 * 1024),
sandboxJanitor: {
enabled: getEnvBool('BOTS_SANDBOX_JANITOR', true),
hotDays: getEnvNum('BOTS_SANDBOX_HOT_DAYS', 7),
archiveDays: getEnvNum('BOTS_SANDBOX_ARCHIVE_DAYS', 30),
},
},
},
spotify: {
enabled: getEnvBool('SPOTIFY_ENABLED', false),
clientId: getEnv('SPOTIFY_CLIENT_ID'),
clientSecret: getEnv('SPOTIFY_CLIENT_SECRET'),
redirectUri: getEnv('SPOTIFY_REDIRECT_URI', 'http://127.0.0.1:8888/callback'),
accessToken: '',
refreshToken: '',
expiresAt: '',
scopes: [],
deviceId: '',
accountName: '',
accountId: '',
product: '',
},
toolDiscovery: { enabled: getEnvBool('MERCURY_TOOL_DISCOVERY', false) },
concurrency: { maxTurns: getEnvNum('MERCURY_MAX_CONCURRENT_TURNS', 0) },
web: {
enabled: getEnvBool('MERCURY_WEB_ENABLED', false),
port: getEnvNum('MERCURY_PORT', 6174),
},
};
}
const CONFIG_PATH = join(getMercuryHome(), 'mercury.yaml');
const CONFIG_LOCK_PATH = `${CONFIG_PATH}.lock`;
export function loadConfig(): MercuryConfig {
if (existsSync(CONFIG_PATH)) {
// Tighten permissions on an existing config file that contains live
// tokens but was written before the 0600 default.
try { chmodSync(CONFIG_PATH, 0o600); } catch {}
const raw = readFileSync(CONFIG_PATH, 'utf-8');
const fileConfig = parseYaml(raw) as Partial<MercuryConfig>;
const defaults = getDefaultConfig();
return normalizeCloudConfig(migrateLegacyChatGPTModel(
migrateLegacyDiscordAccess(
migrateLegacyOllamaLocalBaseUrl(
migrateLegacyOllamaCloudBaseUrl(
migrateLegacySignalAccess(
migrateLegacyTelegramAccess(deepMerge(defaults, fileConfig)),
),
),
),
),
));
}
return normalizeCloudConfig(migrateLegacyChatGPTModel(
migrateLegacyDiscordAccess(
migrateLegacyTelegramAccess(getDefaultConfig()),
),
));
}
/**
* 2026-09: OpenAI's Codex-for-ChatGPT backend now validates the model slug
* against the account's LIVE entitlements and rejects everything else with
* HTTP 400 "The 'X' model is not supported when using Codex with a ChatGPT
* account." The old catalog fetched the ChatGPT web-app list
* (/backend-api/models), whose hyphenated slugs (e.g. `gpt-5-6-thinking`) are
* ALL rejected — authenticated users could not chat. Migrate any
* non-entitled chatgptWeb model to the current recommended Codex slug.
*/
const CHATGPT_CODEX_MODEL_SLUGS = [
'gpt-5.6-sol',
'gpt-5.6-terra',
'gpt-5.6-luna',
'gpt-5.5',
'gpt-6-astra',
'gpt-reserve',
] as const;
const DEFAULT_CHATGPT_CODEX_MODEL = 'gpt-5.6-sol';
export function migrateLegacyChatGPTModel(config: MercuryConfig): MercuryConfig {
const chatgpt = config.providers?.chatgptWeb;
if (chatgpt?.enabled && !((CHATGPT_CODEX_MODEL_SLUGS as readonly string[]).includes(chatgpt.model))) {
logger.warn({ staleModel: chatgpt.model, replacement: DEFAULT_CHATGPT_CODEX_MODEL }, 'chatgptWeb model not entitled on the Codex backend — migrating');
chatgpt.model = DEFAULT_CHATGPT_CODEX_MODEL;
}
return config;
}
export function normalizeCloudConfig(config: MercuryConfig): MercuryConfig {
// Single source of truth: cloud.apiUrl/wsUrl define the Mercury Cloud backend.
// providers.mercuryCloud.baseUrl is derived for the OpenAI-compatible client.
if (!config.cloud.apiUrl || config.cloud.apiUrl === LEGACY_SEED_API_URL) {
config.cloud.apiUrl = MERCURY_CLOUD_API_URL;
}
if (config.cloud.wsUrl === LEGACY_SEED_WS_URL) {
config.cloud.wsUrl = MERCURY_CLOUD_WS_URL;
}
if (!config.cloud.wsUrl) config.cloud.wsUrl = deriveCloudWsUrl(config.cloud.apiUrl);
config.providers.mercuryCloud.baseUrl = config.cloud.apiUrl;
if (config.cloud.accessKey) {
config.providers.mercuryCloud.apiKey = config.cloud.accessKey;
} else if (config.cloud.jwt && !config.providers.mercuryCloud.apiKey) {
config.providers.mercuryCloud.apiKey = config.cloud.jwt;
}
return config;
}
function deriveCloudWsUrl(apiUrl: string): string {
try {
const url = new URL(apiUrl);
url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
url.pathname = `${url.pathname.replace(/\/$/, '')}/ws`;
url.search = '';
url.hash = '';
return url.toString();
} catch {
return MERCURY_CLOUD_WS_URL;
}
}
export function saveConfig(config: MercuryConfig): void {
const lockFd = acquireConfigLock();
try {
saveConfigUnlocked(config);
} finally {
releaseConfigLock(lockFd);
}
}
export function updateConfig(mutator: (config: MercuryConfig) => void): MercuryConfig {
const lockFd = acquireConfigLock();
try {
const config = loadConfig();
mutator(config);
saveConfigUnlocked(config);
return config;
} finally {
releaseConfigLock(lockFd);
}
}
function saveConfigUnlocked(config: MercuryConfig): void {
config = normalizeCloudConfig(config);
const dir = getMercuryHome();
if (!existsSync(dir)) {
mkdirSync(dir, { recursive: true });
}
const tempPath = `${CONFIG_PATH}.${process.pid}.${Date.now()}.tmp`;
try {
writeFileSync(tempPath, stringifyYaml(config), { encoding: 'utf-8', mode: 0o600 });
renameSync(tempPath, CONFIG_PATH);
} finally {
try { unlinkSync(tempPath); } catch {}
}
// The config file contains live JWTs and refresh tokens. Restrict to the
// owner so other users on shared servers cannot read or rotate them.
try { chmodSync(CONFIG_PATH, 0o600); } catch {}
}
function acquireConfigLock(): number {
const dir = getMercuryHome();
if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
const deadline = Date.now() + 2_000;
const waitBuffer = new Int32Array(new SharedArrayBuffer(4));
while (true) {
try {
const fd = openSync(CONFIG_LOCK_PATH, 'wx', 0o600);
writeFileSync(fd, String(process.pid), 'utf-8');
return fd;
} catch (error: any) {
if (error?.code !== 'EEXIST') throw error;
let ownerPid = 0;
try { ownerPid = parseInt(readFileSync(CONFIG_LOCK_PATH, 'utf-8'), 10); } catch {}
let ownerAlive = false;
if (ownerPid > 0) {
try { process.kill(ownerPid, 0); ownerAlive = true; } catch {}
}
if (ownerAlive) {
if (Date.now() >= deadline) {
throw new Error(`Mercury configuration is still being updated by process ${ownerPid}; retry the command`);
}
Atomics.wait(waitBuffer, 0, 0, 25);
continue;
}
try { unlinkSync(CONFIG_LOCK_PATH); } catch {}
}
}
}
function releaseConfigLock(fd: number): void {
try { closeSync(fd); } catch {}
try { unlinkSync(CONFIG_LOCK_PATH); } catch {}
}
export function isSetupComplete(): boolean {
if (!existsSync(CONFIG_PATH)) return false;
const config = loadConfig();
return config.identity.owner.length > 0;
}
export function ensureCreatorField(config: MercuryConfig): MercuryConfig {
if (!config.identity.creator && config.identity.owner) {
config.identity.creator = 'Cosmic Stack';
saveConfig(config);
}
return config;
}
function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T {
const result = { ...target };
for (const key in source) {
if (source[key] !== undefined && source[key] !== null) {
if (
typeof source[key] === 'object' &&
!Array.isArray(source[key]) &&
typeof target[key] === 'object' &&
!Array.isArray(target[key])
) {
result[key] = deepMerge(
target[key] as Record<string, any>,
source[key] as Record<string, any>
) as T[Extract<keyof T, string>];
} else {
result[key] = source[key] as T[Extract<keyof T, string>];
}
}
}
return result;
}
export function getActiveProviders(config: MercuryConfig): ProviderConfig[] {
return Object.values(config.providers)
.filter((p): p is ProviderConfig => typeof p === 'object' && isProviderConfigured(p));
}
export function isProviderConfigured(provider: ProviderConfig): boolean {
if (!provider.enabled) return false;
if (provider.name === 'mercuryCloud') {
return provider.model.length > 0;
}
if (provider.name === 'ollamaLocal' || provider.name === 'atomicChat') {
return provider.baseUrl.length > 0 && provider.model.length > 0;
}
if (provider.name === 'ollamaCloud') {
return provider.apiKey.length > 0 && provider.baseUrl.length > 0;
}
if (provider.name === 'atlascloud' || provider.name === 'runcrate' || provider.name === 'cloudgpu') {
return provider.apiKey.length > 0 && provider.baseUrl.length > 0 && provider.model.length > 0;
}
if (provider.name === 'openaiCompat' || provider.name === 'litellm') {
return provider.baseUrl.length > 0 && provider.model.length > 0;
}
if (provider.name === 'lmStudio') {
return provider.baseUrl.length > 0 && provider.model.length > 0;
}
if (provider.name === 'chatgptWeb') {
// ChatGPT Web uses browser session auth, not API keys.
// Considered "configured" if enabled with a model selected.
// Actual session validity is checked at runtime via isAvailable().
return provider.model.length > 0;
}
if (provider.name === 'githubCopilot') {
// GitHub Copilot uses GitHub OAuth, not API keys.
// Considered "configured" if enabled with a model selected.
return provider.model.length > 0;
}
return provider.apiKey.length > 0;
}
export function getTelegramApprovedUsers(config: MercuryConfig): TelegramAccessUser[] {
return [
...config.channels.telegram.admins,
...config.channels.telegram.members,
];
}
export function getTelegramApprovedChatIds(config: MercuryConfig): number[] {
return [...new Set(getTelegramApprovedUsers(config).map((user) => user.chatId))];
}
export function getTelegramAdmins(config: MercuryConfig): TelegramAccessUser[] {
return config.channels.telegram.admins;
}
export function getTelegramPendingRequests(config: MercuryConfig): TelegramPendingRequest[] {
return config.channels.telegram.pending;
}
export function findTelegramApprovedUser(config: MercuryConfig, userId: number): TelegramAccessUser | undefined {
return getTelegramApprovedUsers(config).find((user) => user.userId === userId);
}
export function findTelegramAdmin(config: MercuryConfig, userId: number): TelegramAccessUser | undefined {
return config.channels.telegram.admins.find((user) => user.userId === userId);
}
export function findTelegramPendingRequest(config: MercuryConfig, userId: number): TelegramPendingRequest | undefined {
return config.channels.telegram.pending.find((request) => request.userId === userId);
}
export function findTelegramPendingRequestByPairingCode(
config: MercuryConfig,
pairingCode: string,
): TelegramPendingRequest | undefined {
return config.channels.telegram.pending.find((request) => request.pairingCode === pairingCode);
}
export function hasTelegramAdmins(config: MercuryConfig): boolean {
return config.channels.telegram.admins.length > 0;
}
export function getTelegramAccessSummary(config: MercuryConfig): string {
return `${config.channels.telegram.admins.length} admin${config.channels.telegram.admins.length === 1 ? '' : 's'}, `
+ `${config.channels.telegram.members.length} member${config.channels.telegram.members.length === 1 ? '' : 's'}, `
+ `${config.channels.telegram.pending.length} pending`;
}
export function addTelegramPendingRequest(
config: MercuryConfig,
request: Omit<TelegramPendingRequest, 'requestedAt'> & { requestedAt?: string },
): TelegramPendingRequest {
const existing = findTelegramPendingRequest(config, request.userId);
if (existing) {
existing.chatId = request.chatId;
existing.username = request.username || existing.username;
existing.firstName = request.firstName || existing.firstName;
existing.pairingCode = request.pairingCode || existing.pairingCode;
return existing;
}
const created: TelegramPendingRequest = {
...request,
requestedAt: request.requestedAt || new Date().toISOString(),
};
config.channels.telegram.pending.push(created);
return created;
}
export function approveTelegramPendingRequest(
config: MercuryConfig,
userId: number,
role: 'admin' | 'member' = 'member',
): TelegramAccessUser | null {
const request = findTelegramPendingRequest(config, userId);
if (!request) return null;
const approvedUser: TelegramAccessUser = {
userId: request.userId,
chatId: request.chatId,
username: request.username,
firstName: request.firstName,
requestedAt: request.requestedAt,
approvedAt: new Date().toISOString(),
};
config.channels.telegram.pending = config.channels.telegram.pending
.filter((entry) => entry.userId !== userId);
config.channels.telegram.admins = config.channels.telegram.admins
.filter((entry) => entry.userId !== userId);
config.channels.telegram.members = config.channels.telegram.members
.filter((entry) => entry.userId !== userId);
if (role === 'admin') {
config.channels.telegram.admins.push(approvedUser);
} else {
config.channels.telegram.members.push(approvedUser);
}
return approvedUser;
}
export function approveTelegramPendingRequestByPairingCode(
config: MercuryConfig,
pairingCode: string,
): TelegramAccessUser | null {
const request = findTelegramPendingRequestByPairingCode(config, pairingCode);
if (!request) return null;
const role = hasTelegramAdmins(config) ? 'member' : 'admin';
return approveTelegramPendingRequest(config, request.userId, role);
}
export function rejectTelegramPendingRequest(config: MercuryConfig, userId: number): TelegramPendingRequest | null {
const request = findTelegramPendingRequest(config, userId);
if (!request) return null;
config.channels.telegram.pending = config.channels.telegram.pending
.filter((entry) => entry.userId !== userId);
return request;
}
export function removeTelegramUser(config: MercuryConfig, userId: number): TelegramAccessUser | null {
const admin = config.channels.telegram.admins.find((entry) => entry.userId === userId);
if (admin) {
config.channels.telegram.admins = config.channels.telegram.admins
.filter((entry) => entry.userId !== userId);
return admin;
}
const member = config.channels.telegram.members.find((entry) => entry.userId === userId);
if (member) {
config.channels.telegram.members = config.channels.telegram.members
.filter((entry) => entry.userId !== userId);
return member;
}
return null;
}
export function promoteTelegramUserToAdmin(config: MercuryConfig, userId: number): TelegramAccessUser | null {
const member = config.channels.telegram.members.find((entry) => entry.userId === userId);
if (!member) return null;
config.channels.telegram.members = config.channels.telegram.members
.filter((entry) => entry.userId !== userId);
config.channels.telegram.admins.push(member);
return member;
}
export function demoteTelegramAdmin(config: MercuryConfig, userId: number): TelegramAccessUser | null {
if (config.channels.telegram.admins.length <= 1) {
return null;
}
const admin = config.channels.telegram.admins.find((entry) => entry.userId === userId);
if (!admin) return null;
config.channels.telegram.admins = config.channels.telegram.admins
.filter((entry) => entry.userId !== userId);
config.channels.telegram.members.push(admin);
return admin;
}
export function clearTelegramAccess(config: MercuryConfig): MercuryConfig {
config.channels.telegram.admins = [];
config.channels.telegram.members = [];
config.channels.telegram.pending = [];
delete config.channels.telegram.pairedUserId;
delete config.channels.telegram.pairedChatId;
delete config.channels.telegram.pairedUsername;
return config;
}
export function clearTelegramPairing(config: MercuryConfig): MercuryConfig {
return clearTelegramAccess(config);
}
export function migrateLegacyTelegramAccess(config: MercuryConfig): MercuryConfig {
const telegram = config.channels.telegram;
telegram.admins = telegram.admins || [];
telegram.members = telegram.members || [];
telegram.pending = telegram.pending || [];
if (
telegram.admins.length === 0
&& telegram.members.length === 0
&& typeof telegram.pairedUserId === 'number'
&& typeof telegram.pairedChatId === 'number'
) {
telegram.admins.push({
userId: telegram.pairedUserId,
chatId: telegram.pairedChatId,
username: telegram.pairedUsername,
approvedAt: new Date().toISOString(),
});
}
delete telegram.pairedUserId;
delete telegram.pairedChatId;
delete telegram.pairedUsername;
return config;
}
export function migrateLegacyOllamaCloudBaseUrl(config: MercuryConfig): MercuryConfig {
if (config.providers.ollamaCloud.baseUrl === 'https://ollama.com/api') {
config.providers.ollamaCloud.baseUrl = 'https://ollama.com/v1';
saveConfig(config);
}
return config;
}
/**
* Migrate local Ollama base URL from the legacy /api endpoint to /v1.
* Ollama has supported /v1 (OpenAI-compatible) since v0.1.14, and the
* /api endpoint is incompatible with AI SDK v6+ when used through
* ollama-ai-provider (which declares spec version v1).
*/
export function migrateLegacyOllamaLocalBaseUrl(config: MercuryConfig): MercuryConfig {
const local = config.providers.ollamaLocal.baseUrl;
if (local === 'http://127.0.0.1:11434/api' || local === 'http://localhost:11434/api') {
config.providers.ollamaLocal.baseUrl = local.replace('/api', '/v1');
saveConfig(config);
}
return config;
}
// ── Signal access helpers ────────────────────────────────────────
export function getSignalApprovedUsers(config: MercuryConfig): SignalAccessUser[] {
return [...config.channels.signal.admins, ...config.channels.signal.members];
}
export function findSignalAdmin(config: MercuryConfig, phoneNumber: string): SignalAccessUser | undefined {
return config.channels.signal.admins.find((u) => u.phoneNumber === phoneNumber);
}
export function findSignalApprovedUser(config: MercuryConfig, phoneNumber: string): SignalAccessUser | undefined {
return getSignalApprovedUsers(config).find((u) => u.phoneNumber === phoneNumber);
}
export function findSignalPendingRequest(config: MercuryConfig, phoneNumber: string): SignalPendingRequest | undefined {
return config.channels.signal.pending.find((r) => r.phoneNumber === phoneNumber);
}
export function findSignalPendingRequestByPairingCode(config: MercuryConfig, pairingCode: string): SignalPendingRequest | undefined {
return config.channels.signal.pending.find((r) => r.pairingCode === pairingCode);
}
export function hasSignalAdmins(config: MercuryConfig): boolean {
return config.channels.signal.admins.length > 0;
}
export function getSignalAccessSummary(config: MercuryConfig): string {
return `${config.channels.signal.admins.length} admin${config.channels.signal.admins.length === 1 ? '' : 's'}, `
+ `${config.channels.signal.members.length} member${config.channels.signal.members.length === 1 ? '' : 's'}, `
+ `${config.channels.signal.pending.length} pending`;
}
export function addSignalPendingRequest(
config: MercuryConfig,
request: Omit<SignalPendingRequest, 'requestedAt'> & { requestedAt?: string },
): SignalPendingRequest {
const existing = findSignalPendingRequest(config, request.phoneNumber);
if (existing) {
existing.pairingCode = request.pairingCode || existing.pairingCode;
if (request.uuid) existing.uuid = request.uuid;
if (request.name) existing.name = request.name;
return existing;
}
const created: SignalPendingRequest = {
...request,
requestedAt: request.requestedAt || new Date().toISOString(),
};
config.channels.signal.pending.push(created);
return created;
}
export function approveSignalPendingRequest(
config: MercuryConfig,
phoneNumber: string,
role: 'admin' | 'member' = 'member',
): SignalAccessUser | null {
const request = findSignalPendingRequest(config, phoneNumber);
if (!request) return null;
const approvedUser: SignalAccessUser = {
phoneNumber: request.phoneNumber,
role,
pairedAt: new Date().toISOString(),
};
config.channels.signal.pending = config.channels.signal.pending
.filter((r) => r.phoneNumber !== phoneNumber);
config.channels.signal.admins = config.channels.signal.admins
.filter((u) => u.phoneNumber !== phoneNumber);
config.channels.signal.members = config.channels.signal.members
.filter((u) => u.phoneNumber !== phoneNumber);
if (role === 'admin') {
config.channels.signal.admins.push(approvedUser);
} else {
config.channels.signal.members.push(approvedUser);
}
return approvedUser;
}
export function approveSignalPendingRequestByPairingCode(
config: MercuryConfig,
pairingCode: string,
): SignalAccessUser | null {
const request = findSignalPendingRequestByPairingCode(config, pairingCode);
if (!request) return null;
const role = hasSignalAdmins(config) ? 'member' : 'admin';
return approveSignalPendingRequest(config, request.phoneNumber, role);
}
export function rejectSignalPendingRequest(config: MercuryConfig, phoneNumber: string): SignalPendingRequest | null {
const request = findSignalPendingRequest(config, phoneNumber);
if (!request) return null;
config.channels.signal.pending = config.channels.signal.pending
.filter((r) => r.phoneNumber !== phoneNumber);
return request;
}
export function clearSignalAccess(config: MercuryConfig): MercuryConfig {
config.channels.signal.admins = [];
config.channels.signal.members = [];
config.channels.signal.pending = [];
delete config.channels.signal.groupId;
delete config.channels.signal.groupName;
return config;
}
export function migrateLegacySignalAccess(config: MercuryConfig): MercuryConfig {
const signal = config.channels.signal;
if (!signal) return config;
signal.admins = signal.admins || [];
signal.members = signal.members || [];
signal.pending = signal.pending || [];
return config;
}
// ── Discord access helpers ────────────────────────────────────────
export function getDiscordApprovedUsers(config: MercuryConfig): DiscordAccessUser[] {
return [...config.channels.discord.admins, ...config.channels.discord.members];
}
export function getDiscordAdmins(config: MercuryConfig): DiscordAccessUser[] {
return config.channels.discord.admins;
}
export function getDiscordPendingRequests(config: MercuryConfig): DiscordPendingRequest[] {
return config.channels.discord.pending;
}
export function findDiscordApprovedUser(config: MercuryConfig, userId: string): DiscordAccessUser | undefined {
return getDiscordApprovedUsers(config).find((u) => u.userId === userId);
}
export function findDiscordAdmin(config: MercuryConfig, userId: string): DiscordAccessUser | undefined {
return config.channels.discord.admins.find((u) => u.userId === userId);
}
export function findDiscordPendingRequest(config: MercuryConfig, userId: string): DiscordPendingRequest | undefined {
return config.channels.discord.pending.find((r) => r.userId === userId);
}
export function findDiscordPendingRequestByPairingCode(config: MercuryConfig, pairingCode: string): DiscordPendingRequest | undefined {
return config.channels.discord.pending.find((r) => r.pairingCode === pairingCode);
}
export function hasDiscordAdmins(config: MercuryConfig): boolean {
return config.channels.discord.admins.length > 0;
}
export function getDiscordAccessSummary(config: MercuryConfig): string {
return `${config.channels.discord.admins.length} admin${config.channels.discord.admins.length === 1 ? '' : 's'}, `
+ `${config.channels.discord.members.length} member${config.channels.discord.members.length === 1 ? '' : 's'}, `
+ `${config.channels.discord.pending.length} pending`;
}
export function addDiscordPendingRequest(
config: MercuryConfig,
request: Omit<DiscordPendingRequest, 'requestedAt'> & { requestedAt?: string },
): DiscordPendingRequest {
const existing = findDiscordPendingRequest(config, request.userId);
if (existing) {
existing.username = request.username || existing.username;
existing.displayName = request.displayName || existing.displayName;
existing.pairingCode = request.pairingCode || existing.pairingCode;
return existing;
}
const created: DiscordPendingRequest = {
...request,
requestedAt: request.requestedAt || new Date().toISOString(),
};
config.channels.discord.pending.push(created);
return created;
}
export function approveDiscordPendingRequest(
config: MercuryConfig,
userId: string,
role: 'admin' | 'member' = 'member',
): DiscordAccessUser | null {
const request = findDiscordPendingRequest(config, userId);
if (!request) return null;
const approvedUser: DiscordAccessUser = {
userId: request.userId,
username: request.username,
displayName: request.displayName,
role,
approvedAt: new Date().toISOString(),
};
config.channels.discord.pending = config.channels.discord.pending
.filter((r) => r.userId !== userId);
config.channels.discord.admins = config.channels.discord.admins
.filter((u) => u.userId !== userId);
config.channels.discord.members = config.channels.discord.members
.filter((u) => u.userId !== userId);
if (role === 'admin') {
config.channels.discord.admins.push(approvedUser);
} else {
config.channels.discord.members.push(approvedUser);
}
return approvedUser;
}
export function approveDiscordPendingRequestByPairingCode(
config: MercuryConfig,
pairingCode: string,
): DiscordAccessUser | null {
const request = findDiscordPendingRequestByPairingCode(config, pairingCode);
if (!request) return null;
const role = hasDiscordAdmins(config) ? 'member' : 'admin';
return approveDiscordPendingRequest(config, request.userId, role);
}
export function rejectDiscordPendingRequest(config: MercuryConfig, userId: string): DiscordPendingRequest | null {
const request = findDiscordPendingRequest(config, userId);
if (!request) return null;
config.channels.discord.pending = config.channels.discord.pending
.filter((r) => r.userId !== userId);
return request;
}
export function removeDiscordUser(config: MercuryConfig, userId: string): DiscordAccessUser | null {
const admin = config.channels.discord.admins.find((u) => u.userId === userId);
if (admin) {
config.channels.discord.admins = config.channels.discord.admins
.filter((u) => u.userId !== userId);
return admin;
}
const member = config.channels.discord.members.find((u) => u.userId === userId);
if (member) {
config.channels.discord.members = config.channels.discord.members
.filter((u) => u.userId !== userId);
return member;
}
return null;
}
export function promoteDiscordUserToAdmin(config: MercuryConfig, userId: string): DiscordAccessUser | null {
const member = config.channels.discord.members.find((u) => u.userId === userId);
if (!member) return null;
config.channels.discord.members = config.channels.discord.members
.filter((u) => u.userId !== userId);
config.channels.discord.admins.push(member);
return member;
}
export function demoteDiscordAdmin(config: MercuryConfig, userId: string): DiscordAccessUser | null {
if (config.channels.discord.admins.length <= 1) {
return null;
}
const admin = config.channels.discord.admins.find((u) => u.userId === userId);
if (!admin) return null;
config.channels.discord.admins = config.channels.discord.admins
.filter((u) => u.userId !== userId);
config.channels.discord.members.push(admin);
return admin;
}
export function clearDiscordAccess(config: MercuryConfig): MercuryConfig {
config.channels.discord.admins = [];
config.channels.discord.members = [];
config.channels.discord.pending = [];
return config;
}
export function migrateLegacyDiscordAccess(config: MercuryConfig): MercuryConfig {
const discord = config.channels.discord;
if (!discord) return config;
discord.admins = discord.admins || [];
discord.members = discord.members || [];
discord.pending = discord.pending || [];
return config;
}
// ── Slack access helpers ──────────────────────────────────────────
export function getSlackApprovedUsers(config: MercuryConfig): SlackAccessUser[] {
return [...config.channels.slack.admins, ...config.channels.slack.members];
}
export function getSlackAdmins(config: MercuryConfig): SlackAccessUser[] {
return config.channels.slack.admins;
}
export function getSlackPendingRequests(config: MercuryConfig): SlackPendingRequest[] {
return config.channels.slack.pending;
}
export function findSlackApprovedUser(config: MercuryConfig, userId: string): SlackAccessUser | undefined {
return getSlackApprovedUsers(config).find((u) => u.userId === userId);
}
export function findSlackAdmin(config: MercuryConfig, userId: string): SlackAccessUser | undefined {
return config.channels.slack.admins.find((u) => u.userId === userId);
}
export function findSlackPendingRequest(config: MercuryConfig, userId: string): SlackPendingRequest | undefined {
return config.channels.slack.pending.find((r) => r.userId === userId);
}
export function findSlackPendingRequestByPairingCode(config: MercuryConfig, pairingCode: string): SlackPendingRequest | undefined {
return config.channels.slack.pending.find((r) => r.pairingCode === pairingCode);
}
export function hasSlackAdmins(config: MercuryConfig): boolean {
return config.channels.slack.admins.length > 0;
}
export function getSlackAccessSummary(config: MercuryConfig): string {
return `${config.channels.slack.admins.length} admin${config.channels.slack.admins.length === 1 ? '' : 's'}, `
+ `${config.channels.slack.members.length} member${config.channels.slack.members.length === 1 ? '' : 's'}, `
+ `${config.channels.slack.pending.length} pending`;
}
export function addSlackPendingRequest(
config: MercuryConfig,
request: Omit<SlackPendingRequest, 'requestedAt'> & { requestedAt?: string },
): SlackPendingRequest {
const existing = findSlackPendingRequest(config, request.userId);
if (existing) {
existing.userName = request.userName || existing.userName;
existing.displayName = request.displayName || existing.displayName;
existing.pairingCode = request.pairingCode || existing.pairingCode;
return existing;
}
const created: SlackPendingRequest = {
...request,
requestedAt: request.requestedAt || new Date().toISOString(),
};
config.channels.slack.pending.push(created);
return created;
}
export function approveSlackPendingRequest(
config: MercuryConfig,
userId: string,
role: 'admin' | 'member' = 'member',
): SlackAccessUser | null {
const request = findSlackPendingRequest(config, userId);
if (!request) return null;
const approvedUser: SlackAccessUser = {
userId: request.userId,
userName: request.userName,
displayName: request.displayName,
role,
approvedAt: new Date().toISOString(),
};
config.channels.slack.pending = config.channels.slack.pending
.filter((r) => r.userId !== userId);
config.channels.slack.admins = config.channels.slack.admins
.filter((u) => u.userId !== userId);
config.channels.slack.members = config.channels.slack.members
.filter((u) => u.userId !== userId);
if (role === 'admin') {
config.channels.slack.admins.push(approvedUser);
} else {
config.channels.slack.members.push(approvedUser);
}
return approvedUser;
}
export function approveSlackPendingRequestByPairingCode(
config: MercuryConfig,
pairingCode: string,
): SlackAccessUser | null {
const request = findSlackPendingRequestByPairingCode(config, pairingCode);
if (!request) return null;
const role = hasSlackAdmins(config) ? 'member' : 'admin';
return approveSlackPendingRequest(config, request.userId, role);
}
export function rejectSlackPendingRequest(config: MercuryConfig, userId: string): SlackPendingRequest | null {
const request = findSlackPendingRequest(config, userId);
if (!request) return null;
config.channels.slack.pending = config.channels.slack.pending
.filter((r) => r.userId !== userId);
return request;
}
export function removeSlackUser(config: MercuryConfig, userId: string): SlackAccessUser | null {
const admin = config.channels.slack.admins.find((u) => u.userId === userId);
if (admin) {
config.channels.slack.admins = config.channels.slack.admins
.filter((u) => u.userId !== userId);
return admin;
}
const member = config.channels.slack.members.find((u) => u.userId === userId);
if (member) {
config.channels.slack.members = config.channels.slack.members
.filter((u) => u.userId !== userId);
return member;
}
return null;
}
export function promoteSlackUserToAdmin(config: MercuryConfig, userId: string): SlackAccessUser | null {
const member = config.channels.slack.members.find((u) => u.userId === userId);
if (!member) return null;
config.channels.slack.members = config.channels.slack.members
.filter((u) => u.userId !== userId);
config.channels.slack.admins.push(member);
return member;
}
export function demoteSlackAdmin(config: MercuryConfig, userId: string): SlackAccessUser | null {
if (config.channels.slack.admins.length <= 1) {
return null;
}
const admin = config.channels.slack.admins.find((u) => u.userId === userId);
if (!admin) return null;
config.channels.slack.admins = config.channels.slack.admins
.filter((u) => u.userId !== userId);
config.channels.slack.members.push(admin);
return admin;
}
export function clearSlackAccess(config: MercuryConfig): MercuryConfig {
config.channels.slack.admins = [];
config.channels.slack.members = [];
config.channels.slack.pending = [];
return config;
}
export function migrateLegacySlackAccess(config: MercuryConfig): MercuryConfig {
const slack = config.channels.slack;
if (!slack) return config;
slack.admins = slack.admins || [];
slack.members = slack.members || [];
slack.pending = slack.pending || [];
return config;
}