@rynfar/meridian 1.72.0 → 1.74.0

package/dist/cli-dh0a1bw4.js

@@ -0,0 +1,619 @@
+import {
+  env,
+  init_env
+} from "./cli-1jstkdj9.js";
+import {
+  configPath,
+  defaultConfigDir,
+  getSetting,
+  init_configDir,
+  setSetting
+} from "./cli-eehk3052.js";
+
+// src/proxy/profiles.ts
+init_configDir();
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/proxy/routing.ts
+import { createHash } from "node:crypto";
+var ACTIVE_PRIORITY = "active+priority";
+var ROUTING_MODES = ["active", "sticky", "priority", ACTIVE_PRIORITY];
+function getRoutingMode(raw) {
+  const lower = raw?.toLowerCase();
+  if (lower === "sticky")
+    return "sticky";
+  if (lower === "priority")
+    return "priority";
+  if (lower && lower.replace(/[\s+_-]/g, "") === "activepriority")
+    return ACTIVE_PRIORITY;
+  return "active";
+}
+function isPoolRouting(mode) {
+  return mode === "priority" || mode === ACTIVE_PRIORITY;
+}
+function getPriorityFailbackPolicy(raw) {
+  return raw?.toLowerCase() === "next-user-turn" ? "next-user-turn" : "new-conversation";
+}
+function shouldPromotePriorityAssignment(input) {
+  return input.policy === "next-user-turn" && input.requestKind === "human" && input.requestId !== undefined && input.requestId !== input.assignment.requestId;
+}
+function classifyRouteKind(input) {
+  if (input.priorityHop)
+    return input.routingMode === ACTIVE_PRIORITY ? "active+priority-hop" : "priority-hop";
+  if (input.pinnedProfileHeader)
+    return "pinned";
+  if (input.routingMode === "sticky")
+    return "sticky";
+  if (input.routingMode === "priority")
+    return "priority";
+  if (input.routingMode === ACTIVE_PRIORITY)
+    return ACTIVE_PRIORITY;
+  if (input.routingMode === "active")
+    return "active";
+  return;
+}
+function rendezvousScore(sessionKey, profileId) {
+  const digest = createHash("sha256").update(`${sessionKey}\x00${profileId}`).digest();
+  return digest.readBigUInt64BE(0);
+}
+function pickStickyProfile(sessionKey, profileIds) {
+  if (!sessionKey || profileIds.length === 0)
+    return;
+  let best;
+  let bestScore = -1n;
+  for (const id of profileIds) {
+    const score = rendezvousScore(sessionKey, id);
+    if (score > bestScore) {
+      bestScore = score;
+      best = id;
+    }
+  }
+  return best;
+}
+function resolvePriorityOrder(configuredIds, orderSetting) {
+  const existing = new Set(configuredIds);
+  const order = [];
+  const unknown = [];
+  for (const id of orderSetting ?? []) {
+    if (!existing.has(id)) {
+      unknown.push(id);
+      continue;
+    }
+    if (!order.includes(id))
+      order.push(id);
+  }
+  for (const id of configuredIds)
+    if (!order.includes(id))
+      order.push(id);
+  return { order, unknown };
+}
+function choosePriorityProfile(order, isExhausted) {
+  const preferred = order[0];
+  if (preferred === undefined)
+    return;
+  for (const id of order) {
+    if (!isExhausted(id))
+      return { id, allExhausted: false };
+  }
+  return { id: preferred, allExhausted: true };
+}
+function chooseActivePriorityCandidates(activeId, order, isExhausted, assigned) {
+  const pool = [...new Set(order.includes(activeId) ? order : [activeId, ...order])];
+  let first;
+  if (!isExhausted(activeId)) {
+    first = activeId;
+  } else if (assigned && assigned !== activeId && pool.includes(assigned) && !isExhausted(assigned)) {
+    first = assigned;
+  } else {
+    first = pool.find((id) => !isExhausted(id)) ?? activeId;
+  }
+  return [first, ...pool.filter((id) => id !== first && !isExhausted(id))];
+}
+
+class ProfileExhaustion {
+  now;
+  marks = new Map;
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  mark(id, until, reason) {
+    const existing = this.marks.get(id);
+    if (existing && existing.until >= until)
+      return;
+    this.marks.set(id, { until, reason });
+  }
+  isExhausted(id) {
+    const entry = this.marks.get(id);
+    if (!entry)
+      return false;
+    if (entry.until <= this.now()) {
+      this.marks.delete(id);
+      return false;
+    }
+    return true;
+  }
+  snapshot() {
+    const out = [];
+    for (const [id, entry] of this.marks) {
+      if (entry.until <= this.now()) {
+        this.marks.delete(id);
+        continue;
+      }
+      out.push({ id, until: entry.until, reason: entry.reason });
+    }
+    return out;
+  }
+}
+
+class AssignmentStore {
+  max;
+  entries = new Map;
+  constructor(max) {
+    this.max = max;
+  }
+  get(key) {
+    const value = this.entries.get(key);
+    if (value === undefined)
+      return;
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    if (this.entries.size > this.max) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest !== undefined)
+        this.entries.delete(oldest);
+    }
+  }
+  compareAndSet(key, expected, value) {
+    if (this.entries.get(key) !== expected)
+      return false;
+    this.set(key, value);
+    return true;
+  }
+  get size() {
+    return this.entries.size;
+  }
+}
+var COOLDOWN_WINDOWS = ["seven_day", "five_hour"];
+var COOLDOWN_CAP_MS = {
+  five_hour: 6 * 60 * 60000,
+  seven_day: 8 * 24 * 60 * 60000
+};
+function cooldownCapMs(type) {
+  return COOLDOWN_CAP_MS[type];
+}
+function resolveCooldownUntil(windows, now, defaultMs) {
+  return findCooldownReset(windows, now) ?? now + defaultMs;
+}
+function findCooldownReset(windows, now) {
+  for (const type of COOLDOWN_WINDOWS) {
+    const match = windows.find((w) => w.type === type && w.exhausted && (w.resetsAt ?? 0) > now);
+    if (match?.resetsAt) {
+      return Math.min(match.resetsAt, now + cooldownCapMs(type));
+    }
+  }
+  return null;
+}
+
+// src/proxy/followActive.ts
+init_env();
+var FOLLOW_POLL_INTERVAL_MS = 1e4;
+var FOLLOW_FETCH_TIMEOUT_MS = 2000;
+var FOLLOW_STALE_AFTER_MS = 120000;
+var MAX_PROFILE_ID_LENGTH = 128;
+function parseFollowTarget(raw) {
+  const trimmed = raw?.trim();
+  if (!trimmed)
+    return { kind: "off" };
+  const withScheme = trimmed.includes("://") ? trimmed : `http://${trimmed}`;
+  let parsed;
+  try {
+    parsed = new URL(withScheme);
+  } catch {
+    return { kind: "invalid", raw: trimmed, message: "not a URL" };
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return { kind: "invalid", raw: trimmed, message: `unsupported scheme "${parsed.protocol}"` };
+  }
+  if (!parsed.hostname) {
+    return { kind: "invalid", raw: trimmed, message: "no host" };
+  }
+  return { kind: "on", url: `${parsed.protocol}//${parsed.host}` };
+}
+var LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "::1", "[::1]", "0.0.0.0", "::", "[::]"]);
+function isSelfTarget(url, selfHost, selfPort) {
+  const target = parseFollowTarget(url);
+  if (target.kind !== "on")
+    return false;
+  const parsed = new URL(target.url);
+  const targetPort = parsed.port ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80;
+  if (targetPort !== selfPort)
+    return false;
+  const targetHost = parsed.hostname.toLowerCase();
+  const ownHost = selfHost.toLowerCase();
+  if (targetHost === ownHost)
+    return true;
+  return LOOPBACK_HOSTS.has(targetHost) && LOOPBACK_HOSTS.has(ownHost);
+}
+function readActiveProfile(body) {
+  if (typeof body !== "object" || body === null)
+    return;
+  const value = body.activeProfile;
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > MAX_PROFILE_ID_LENGTH)
+    return;
+  return trimmed;
+}
+var MAX_CREDENTIAL_DIR_LENGTH = 4096;
+function readFollowedRoster(body) {
+  if (typeof body !== "object" || body === null)
+    return;
+  const entries = body.profiles;
+  if (!Array.isArray(entries))
+    return;
+  const adoptable = [];
+  const unadoptable = [];
+  let sawField = false;
+  for (const entry of entries) {
+    if (typeof entry !== "object" || entry === null)
+      continue;
+    const record = entry;
+    if (typeof record.id !== "string")
+      continue;
+    const id = record.id.trim();
+    if (!id || id.length > MAX_PROFILE_ID_LENGTH)
+      continue;
+    if (!("credentialDir" in record))
+      continue;
+    sawField = true;
+    const dir = record.credentialDir;
+    if (typeof dir === "string" && dir.trim() && dir.length <= MAX_CREDENTIAL_DIR_LENGTH) {
+      adoptable.push({ id, credentialDir: dir.trim() });
+    } else {
+      unadoptable.push(id);
+    }
+  }
+  return sawField ? { adoptable, unadoptable } : undefined;
+}
+function sameRoster(a, b) {
+  if (!a || !b)
+    return a === b;
+  if (a.adoptable.length !== b.adoptable.length)
+    return false;
+  if (a.unadoptable.length !== b.unadoptable.length)
+    return false;
+  return a.adoptable.every((p, i) => p.id === b.adoptable[i].id && p.credentialDir === b.adoptable[i].credentialDir) && a.unadoptable.every((id, i) => id === b.unadoptable[i]);
+}
+function logRosterChange(previous, next, url) {
+  const before = new Map((previous?.adoptable ?? []).map((p) => [p.id, p.credentialDir]));
+  const added = next.adoptable.filter((p) => !before.has(p.id)).map((p) => p.id);
+  const moved = next.adoptable.filter((p) => before.has(p.id) && before.get(p.id) !== p.credentialDir).map((p) => p.id);
+  const after = new Set(next.adoptable.map((p) => p.id));
+  const removed = [...before.keys()].filter((id) => !after.has(id));
+  if (added.length || removed.length || moved.length) {
+    console.warn(`[PROXY] Profiles from ${url}: now serving ${next.adoptable.length}` + (added.length ? `; added ${added.join(", ")}` : "") + (removed.length ? `; withdrew ${removed.join(", ")}` : "") + (moved.length ? `; relocated ${moved.join(", ")}` : "") + ".");
+  }
+  const unadoptableChanged = next.unadoptable.length !== (previous?.unadoptable.length ?? 0) || next.unadoptable.some((id, i) => id !== previous?.unadoptable[i]);
+  if (next.unadoptable.length && unadoptableChanged) {
+    console.warn(`[PROXY] ${url} also has ${next.unadoptable.join(", ")}, which cannot be taken from it: ` + `their credentials are an inline key or token rather than a file on this machine, and a ` + `secret is never sent over this link. Configure them here to serve them here.`);
+  }
+}
+function decideFollowedProfile(state, availableIds, now, staleAfterMs = FOLLOW_STALE_AFTER_MS) {
+  const good = state.lastGood;
+  if (!good)
+    return { follow: false, reason: "no-value" };
+  if (!availableIds.includes(good.profileId)) {
+    return { follow: false, reason: "unknown-profile", followedValue: good.profileId };
+  }
+  return { follow: true, profileId: good.profileId, stale: now - good.at >= staleAfterMs };
+}
+var cachedRaw;
+var cachedTarget = { kind: "off" };
+var warnedInvalid;
+var disabledReason;
+var state = {};
+var pollTimer;
+var bannerLogged = false;
+var errorLogged = false;
+function followTarget() {
+  if (disabledReason)
+    return;
+  const raw = env("FOLLOW_ACTIVE");
+  if (raw !== cachedRaw) {
+    cachedRaw = raw;
+    cachedTarget = parseFollowTarget(raw);
+  }
+  if (cachedTarget.kind === "invalid") {
+    if (warnedInvalid !== cachedTarget.raw) {
+      warnedInvalid = cachedTarget.raw;
+      console.warn(`[PROXY] MERIDIAN_FOLLOW_ACTIVE="${cachedTarget.raw}" is not usable (${cachedTarget.message}). ` + `Expected a Meridian base URL, e.g. http://127.0.0.1:3456. Follow mode is OFF; ` + `this instance uses its own active profile.`);
+    }
+    return;
+  }
+  return cachedTarget.kind === "on" ? { url: cachedTarget.url } : undefined;
+}
+function isFollowEnabled() {
+  return followTarget() !== undefined;
+}
+function followedActiveProfile(availableIds) {
+  if (!isFollowEnabled())
+    return;
+  return decideFollowedProfile(state, availableIds, Date.now());
+}
+function adoptedProfiles() {
+  if (!isFollowEnabled())
+    return [];
+  return state.lastRoster?.roster.adoptable ?? [];
+}
+function followStatus(availableIds) {
+  const target = followTarget();
+  if (!target)
+    return;
+  const outcome = decideFollowedProfile(state, availableIds, Date.now());
+  const roster = state.lastRoster;
+  return {
+    url: target.url,
+    activeProfile: outcome.follow ? outcome.profileId : null,
+    followedValue: state.lastGood?.profileId ?? null,
+    reason: outcome.follow ? null : outcome.reason,
+    stale: outcome.follow ? outcome.stale : false,
+    lastSyncedAt: state.lastGood?.at ?? null,
+    lastError: state.lastError?.message ?? null,
+    adoptedProfiles: (roster?.roster.adoptable ?? []).map((p) => p.id),
+    unadoptableProfiles: roster?.roster.unadoptable ?? [],
+    rosterSyncedAt: roster?.at ?? null
+  };
+}
+async function pollFollowedActiveProfile() {
+  const target = followTarget();
+  if (!target)
+    return;
+  const now = Date.now();
+  try {
+    const res = await fetch(`${target.url}/profiles/list`, {
+      signal: AbortSignal.timeout(FOLLOW_FETCH_TIMEOUT_MS),
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok)
+      throw new Error(`HTTP ${res.status}`);
+    const body = await res.json();
+    const value = readActiveProfile(body);
+    if (!value)
+      throw new Error("response carried no usable activeProfile");
+    const previous = state.lastGood?.profileId;
+    const roster = readFollowedRoster(body);
+    const previousRoster = state.lastRoster?.roster;
+    state = {
+      lastGood: { profileId: value, at: now },
+      lastRoster: roster ? { roster, at: now } : state.lastRoster,
+      lastPollAt: now
+    };
+    if (roster && !sameRoster(roster, previousRoster))
+      logRosterChange(previousRoster, roster, target.url);
+    if (previous !== value) {
+      console.warn(`[PROXY] Active profile now following "${value}" from ${target.url}` + (previous ? ` (was "${previous}")` : ""));
+    } else if (errorLogged) {
+      console.warn(`[PROXY] Recovered contact with ${target.url}; still following "${value}".`);
+    }
+    errorLogged = false;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    state = { ...state, lastPollAt: now, lastError: { message, at: now } };
+    if (!errorLogged) {
+      errorLogged = true;
+      console.warn(`[PROXY] Could not read the active profile from ${target.url} (${message}). ` + (state.lastGood ? `Continuing on the last known value "${state.lastGood.profileId}".` : `No value has ever been read; using this instance's own active profile.`));
+    }
+  }
+}
+function startFollowPolling(self) {
+  if (pollTimer)
+    return;
+  const target = followTarget();
+  if (!target)
+    return;
+  if (self && isSelfTarget(target.url, self.host, self.port)) {
+    disabledReason = `MERIDIAN_FOLLOW_ACTIVE (${target.url}) points at this instance's own address. ` + `Following yourself would freeze the active profile permanently — the followed value ` + `could never change and local switching would be refused. Follow mode is OFF.`;
+    console.warn(`[PROXY] ${disabledReason}`);
+    return;
+  }
+  pollFollowedActiveProfile();
+  pollTimer = setInterval(() => {
+    pollFollowedActiveProfile();
+  }, FOLLOW_POLL_INTERVAL_MS);
+  if (pollTimer.unref)
+    pollTimer.unref();
+}
+function stopFollowPolling() {
+  if (!pollTimer)
+    return;
+  clearInterval(pollTimer);
+  pollTimer = undefined;
+}
+function logFollowBanner(routingMode) {
+  if (bannerLogged)
+    return;
+  const target = followTarget();
+  if (!target)
+    return;
+  bannerLogged = true;
+  console.warn(`[PROXY] FOLLOWING ACTIVE PROFILE (MERIDIAN_FOLLOW_ACTIVE=${target.url}): ` + `this instance takes its active profile from ${target.url}, not from its own settings. ` + `Local switching is refused; the x-meridian-profile header still overrides per request.`);
+  if (routingMode === "priority") {
+    console.warn(`[PROXY] Routing is "priority", which dispatches unpinned requests across the pool ` + `without consulting the active profile — follow mode will have no visible effect on them.`);
+  }
+}
+
+// src/proxy/profiles.ts
+var DISK_CACHE_TTL_MS = 5000;
+var diskProfilesCache = [];
+var diskProfilesCacheAt = 0;
+var diskProfilesCachePath = "";
+function profilesRelocationNotice(configuredFile, defaultFile, defaultFileExists) {
+  if (configuredFile === defaultFile || !defaultFileExists)
+    return;
+  return `[meridian] No profiles at ${configuredFile}, but ${defaultFile} exists. ` + `MERIDIAN_CONFIG_DIR moves the whole config directory, not settings.json alone — ` + `copy profiles.json (and profiles/) across, or unset the variable to use the default.`;
+}
+var warnedProfilesLeftBehind = false;
+function warnIfProfilesLeftBehind(configuredFile) {
+  if (warnedProfilesLeftBehind || !diskDiscoveryEnabled)
+    return;
+  const defaultFile = join(defaultConfigDir(), "profiles.json");
+  const notice = profilesRelocationNotice(configuredFile, defaultFile, existsSync(defaultFile));
+  if (!notice)
+    return;
+  warnedProfilesLeftBehind = true;
+  console.warn(notice);
+}
+function loadProfilesFromDisk() {
+  const file = configPath("profiles.json");
+  if (diskProfilesCachePath === file && diskProfilesCacheAt > 0 && Date.now() - diskProfilesCacheAt < DISK_CACHE_TTL_MS) {
+    return diskProfilesCache;
+  }
+  diskProfilesCachePath = file;
+  try {
+    if (!existsSync(file)) {
+      warnIfProfilesLeftBehind(file);
+      diskProfilesCache = [];
+    } else {
+      diskProfilesCache = JSON.parse(readFileSync(file, "utf-8"));
+    }
+    diskProfilesCacheAt = Date.now();
+    return diskProfilesCache;
+  } catch (err) {
+    console.warn(`[meridian] Failed to read ${file}: ${err instanceof Error ? err.message : err}`);
+    diskProfilesCacheAt = Date.now();
+    diskProfilesCache = [];
+    return [];
+  }
+}
+function invalidateDiskProfileCache() {
+  diskProfilesCacheAt = 0;
+}
+var DEFAULT_PROFILE_ID = "default";
+var activeProfileId;
+function setActiveProfile(profileId) {
+  activeProfileId = profileId;
+  setSetting("activeProfile", profileId);
+}
+function getActiveProfileId() {
+  return activeProfileId;
+}
+var warnedUnknownFollowed;
+function resolveActiveProfileId(availableIds) {
+  const outcome = followedActiveProfile(availableIds);
+  if (!outcome)
+    return activeProfileId;
+  if (outcome.follow) {
+    warnedUnknownFollowed = undefined;
+    return outcome.profileId;
+  }
+  if (outcome.reason === "unknown-profile" && outcome.followedValue !== warnedUnknownFollowed) {
+    warnedUnknownFollowed = outcome.followedValue;
+    console.warn(`[meridian] Followed instance is on profile "${outcome.followedValue}", which is not configured here. ` + `Using this instance's own active profile instead.`);
+  }
+  return activeProfileId;
+}
+function getEffectiveActiveProfileId(configProfiles) {
+  return resolveActiveProfileId(getEffectiveProfiles(configProfiles).map((p) => p.id));
+}
+function resetActiveProfile() {
+  activeProfileId = undefined;
+  warnedUnknownFollowed = undefined;
+}
+function restoreActiveProfile(configProfiles) {
+  if (activeProfileId)
+    return;
+  if (!diskDiscoveryEnabled)
+    return;
+  const saved = getSetting("activeProfile");
+  if (!saved)
+    return;
+  const effective = getEffectiveProfiles(configProfiles);
+  if (effective.length === 0 || effective.some((p) => p.id === saved)) {
+    activeProfileId = saved;
+  } else {
+    console.warn(`[meridian] Saved active profile "${saved}" not found. Using default.`);
+  }
+}
+var diskDiscoveryEnabled = false;
+function enableDiskProfileDiscovery() {
+  diskDiscoveryEnabled = true;
+}
+function getEffectiveProfiles(configProfiles) {
+  const fromConfig = configProfiles ?? [];
+  const configIds = new Set(fromConfig.map((p) => p.id));
+  const fromDisk = diskDiscoveryEnabled ? loadProfilesFromDisk().filter((p) => !configIds.has(p.id)) : [];
+  const localIds = new Set([...configIds, ...fromDisk.map((p) => p.id)]);
+  const adopted = adoptedProfiles().filter((p) => !localIds.has(p.id)).map((p) => ({ id: p.id, claudeConfigDir: p.credentialDir }));
+  return [...fromConfig, ...fromDisk, ...adopted];
+}
+function shareableCredentialDir(resolved) {
+  const keys = Object.keys(resolved.env);
+  if (keys.length !== 1 || keys[0] !== "CLAUDE_CONFIG_DIR")
+    return null;
+  return resolved.env.CLAUDE_CONFIG_DIR ?? null;
+}
+function hasProfiles(configProfiles) {
+  return getEffectiveProfiles(configProfiles).length > 0;
+}
+function resolveProfile(profiles, defaultProfile, requestedId, options) {
+  const effective = getEffectiveProfiles(profiles);
+  if (effective.length === 0) {
+    return { id: DEFAULT_PROFILE_ID, type: "claude-max", env: {} };
+  }
+  const stickyId = options?.routingMode === "sticky" && options.stickySessionKey ? pickStickyProfile(options.stickySessionKey, effective.map((p) => p.id)) : undefined;
+  const activeId = resolveActiveProfileId(effective.map((p) => p.id));
+  const resolvedId = requestedId || stickyId || activeId || defaultProfile || effective[0].id;
+  const profile = findProfileByIdOrAlias(effective, resolvedId);
+  if (!profile) {
+    console.warn(`[meridian] Unknown profile "${resolvedId}". Using first configured profile.`);
+    return buildResolvedProfile(effective[0]);
+  }
+  return buildResolvedProfile(profile);
+}
+function findProfileByIdOrAlias(profiles, id) {
+  return profiles.find((p) => p.id === id) ?? profiles.find((p) => p.aliases?.includes(id));
+}
+function buildResolvedProfile(profile) {
+  if (profile.oauthToken || profile.type === "oauth-token") {
+    const env3 = {};
+    if (profile.oauthToken) {
+      env3.CLAUDE_CODE_OAUTH_TOKEN = profile.oauthToken;
+      env3.CLAUDE_CONFIG_DIR = configPath("profiles", profile.id);
+    }
+    return { id: profile.id, type: "oauth-token", env: env3 };
+  }
+  const type = profile.type ?? "claude-max";
+  if (type === "api") {
+    const env3 = {};
+    if (profile.apiKey)
+      env3.ANTHROPIC_API_KEY = profile.apiKey;
+    if (profile.baseUrl)
+      env3.ANTHROPIC_BASE_URL = profile.baseUrl;
+    return { id: profile.id, type, env: env3 };
+  }
+  const env2 = {};
+  if (profile.claudeConfigDir)
+    env2.CLAUDE_CONFIG_DIR = profile.claudeConfigDir;
+  return { id: profile.id, type, env: env2 };
+}
+function listProfiles(profiles, defaultProfile) {
+  const effective = getEffectiveProfiles(profiles);
+  if (effective.length === 0)
+    return [];
+  const currentActive = resolveActiveProfileId(effective.map((p) => p.id)) || defaultProfile || effective[0].id;
+  return effective.map((p) => ({
+    id: p.id,
+    type: p.type ?? "claude-max",
+    isActive: p.id === currentActive,
+    ...p.aliases && p.aliases.length > 0 ? { aliases: p.aliases } : {}
+  }));
+}
+
+export { ACTIVE_PRIORITY, ROUTING_MODES, getRoutingMode, isPoolRouting, getPriorityFailbackPolicy, shouldPromotePriorityAssignment, classifyRouteKind, resolvePriorityOrder, choosePriorityProfile, chooseActivePriorityCandidates, ProfileExhaustion, AssignmentStore, cooldownCapMs, resolveCooldownUntil, findCooldownReset, FOLLOW_POLL_INTERVAL_MS, followStatus, startFollowPolling, stopFollowPolling, logFollowBanner, profilesRelocationNotice, loadProfilesFromDisk, invalidateDiskProfileCache, setActiveProfile, getActiveProfileId, resolveActiveProfileId, getEffectiveActiveProfileId, resetActiveProfile, restoreActiveProfile, enableDiskProfileDiscovery, getEffectiveProfiles, shareableCredentialDir, hasProfiles, resolveProfile, findProfileByIdOrAlias, listProfiles };

package/dist/cli-eehk3052.js

@@ -0,0 +1,57 @@
+import {
+  __esm
+} from "./cli-p9swy5t3.js";
+
+// src/configDir.ts
+import { join } from "node:path";
+import { homedir } from "node:os";
+function defaultConfigDir() {
+  return join(homedir(), ".config", "meridian");
+}
+function configDir() {
+  return process.env.MERIDIAN_CONFIG_DIR || defaultConfigDir();
+}
+function configPath(...segments) {
+  return join(configDir(), ...segments);
+}
+var init_configDir = () => {};
+
+// src/settings.ts
+init_configDir();
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+function settingsFile() {
+  return configPath("settings.json");
+}
+var TELEMETRY_SETTING_LIMITS = {
+  telemetryRetentionDays: { min: 1, max: 3650 },
+  telemetrySize: { min: 10, max: 1e6 },
+  diagnosticLogSize: { min: 10, max: 1e6 }
+};
+function loadSettings() {
+  const file = settingsFile();
+  try {
+    if (!existsSync(file))
+      return {};
+    return JSON.parse(readFileSync(file, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveSettings(patch) {
+  const file = settingsFile();
+  const current = loadSettings();
+  const merged = { ...current, ...patch };
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(merged, null, 2) + `
+`, { encoding: "utf-8", mode: 384 });
+  return merged;
+}
+function getSetting(key) {
+  return loadSettings()[key];
+}
+function setSetting(key, value) {
+  return saveSettings({ [key]: value });
+}
+
+export { defaultConfigDir, configDir, configPath, init_configDir, TELEMETRY_SETTING_LIMITS, getSetting, setSetting };