@rynfar/meridian 1.71.1 → 1.73.0

package/dist/{cli-8yp89fan.js → cli-p9ca4p13.js}

@@ -118,7 +118,9 @@ var themeCss = `
     background: rgba(188,140,255,0.12);
     border: 1px solid rgba(188,140,255,0.35);
     cursor: default;
-  }
+    .meridian-header .mh-profile.following { border-color: var(--accent2, #bc8cff); }
+  .meridian-header .mh-profile .mh-profile-follow {
+    color: var(--accent2, #bc8cff); font-size: 10px;  }
   .meridian-header .mh-status {
     display: inline-flex; align-items: center; gap: 6px;
     font-size: 11px; color: var(--muted, #8b949e); white-space: nowrap;
@@ -193,7 +195,20 @@ var themeCss = `
     fetch('/profiles/list').then(function(r) { return r.json(); }).then(function(data) {
       var current = (data.profiles || []).find(function(p) { return p.isActive; });
       if (!current) { profileChip.classList.remove('visible'); return; }
-      profileChip.innerHTML = esc(current.id) + ' <span class="mh-profile-type">' + esc(current.type || '') + '</span>';
+      // Follow mode: say so on every page. An instance quietly taking its
+      // active profile from another one, with a picker that won't stick, is
+      // otherwise an hour of confusion.
+      var follow = data.follow;
+      var followLabel = follow ? (follow.activeProfile ? 'following' : 'follow: local') : '';
+      if (follow && follow.stale) followLabel += ' (stale)';
+      profileChip.innerHTML = esc(current.id) + ' <span class="mh-profile-type">' + esc(current.type || '') + '</span>'
+        + (follow ? ' <span class="mh-profile-follow">' + esc(followLabel) + '</span>' : '');
+      profileChip.classList.toggle('following', !!follow);
+      profileChip.title = follow
+        ? 'Active profile follows ' + follow.url + ' (MERIDIAN_FOLLOW_ACTIVE)'
+          + (follow.activeProfile ? '' : ' — no usable value from it, using the local profile')
+          + '. Switching here is refused; switch on the followed instance.'
+        : 'Active profile — switch from the home page';
       profileChip.classList.add('visible');
     }).catch(function() {});
   }

package/dist/cli-qpfky8wy.js

@@ -0,0 +1,133 @@
+import {
+  configPath,
+  getSetting,
+  init_configDir,
+  setSetting
+} from "./cli-eehk3052.js";
+
+// src/proxy/profileRename.ts
+init_configDir();
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var INVALID_PROFILE_ID = /[^a-zA-Z0-9_-]/;
+function isValidProfileId(id) {
+  return id.length > 0 && !INVALID_PROFILE_ID.test(id);
+}
+function defaultProfilesDir() {
+  return configPath("profiles");
+}
+function defaultProfilesConfigFile() {
+  return configPath("profiles.json");
+}
+function loadProfileConfigFrom(file) {
+  if (!existsSync(file))
+    return [];
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf-8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (err) {
+    console.warn(`[meridian] Failed to read ${file}: ${err instanceof Error ? err.message : err}`);
+    return [];
+  }
+}
+function saveProfileConfigTo(file, profiles) {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(profiles, null, 2)}
+`, { mode: 384 });
+}
+function reclaimAlias(profiles, name) {
+  return profiles.map((p) => {
+    if (!p.aliases?.includes(name))
+      return p;
+    const remaining = p.aliases.filter((a) => a !== name);
+    const next = { ...p };
+    if (remaining.length > 0)
+      next.aliases = remaining;
+    else
+      delete next.aliases;
+    return next;
+  });
+}
+function planProfileRename(profiles, from, to, profilesDir) {
+  if (!isValidProfileId(to)) {
+    return {
+      ok: false,
+      error: `Invalid profile name "${to}".`,
+      hint: "Use only letters, numbers, hyphens, underscores."
+    };
+  }
+  const target = profiles.find((p) => p.id === from);
+  if (!target) {
+    return { ok: false, error: `Profile "${from}" not found.`, hint: "Run: meridian profile list" };
+  }
+  if (from === to) {
+    return { ok: false, error: `Profile "${from}" is already called that.` };
+  }
+  if (profiles.some((p) => p.id === to)) {
+    return { ok: false, error: `Profile "${to}" already exists.`, hint: "Run: meridian profile list" };
+  }
+  const oldDir = join(profilesDir, from);
+  const newDir = join(profilesDir, to);
+  const ownsDir = target.claudeConfigDir === oldDir;
+  const isOauthToken = Boolean(target.oauthToken) || target.type === "oauth-token";
+  const aliases = [...new Set([...target.aliases ?? [], from])].filter((a) => a !== to);
+  const renamed = { ...target, id: to, aliases };
+  if (ownsDir)
+    renamed.claudeConfigDir = newDir;
+  const next = reclaimAlias(profiles, to).map((p) => p.id === from ? renamed : p);
+  const plan = { profiles: next, aliases };
+  if (ownsDir || isOauthToken)
+    plan.dirMove = { from: oldDir, to: newDir };
+  return { ok: true, plan };
+}
+function applyProfileRename(from, to, options = {}) {
+  const profilesDir = options.profilesDir ?? defaultProfilesDir();
+  const configFile = options.configFile ?? defaultProfilesConfigFile();
+  const profiles = loadProfileConfigFrom(configFile);
+  const planned = planProfileRename(profiles, from, to, profilesDir);
+  if (!planned.ok)
+    return planned;
+  const { plan } = planned;
+  let movedDir;
+  if (plan.dirMove && existsSync(plan.dirMove.from)) {
+    if (existsSync(plan.dirMove.to)) {
+      return {
+        ok: false,
+        error: `Cannot rename to "${to}": ${plan.dirMove.to} already exists.`,
+        hint: "Remove or move that directory, then retry."
+      };
+    }
+    try {
+      renameSync(plan.dirMove.from, plan.dirMove.to);
+      movedDir = plan.dirMove;
+    } catch (err) {
+      return {
+        ok: false,
+        error: `Could not move credentials for "${from}": ${err instanceof Error ? err.message : err}`
+      };
+    }
+  }
+  try {
+    saveProfileConfigTo(configFile, plan.profiles);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    if (movedDir) {
+      try {
+        renameSync(movedDir.to, movedDir.from);
+      } catch (undoErr) {
+        const undoReason = undoErr instanceof Error ? undoErr.message : String(undoErr);
+        return {
+          ok: false,
+          error: `Could not write ${configFile} (${reason}), and could not move credentials back (${undoReason}).`,
+          hint: `Profile "${from}" still expects its credentials at ${movedDir.from} — move ${movedDir.to} back by hand.`
+        };
+      }
+    }
+    return { ok: false, error: `Could not write ${configFile}: ${reason}` };
+  }
+  if (getSetting("activeProfile") === from)
+    setSetting("activeProfile", to);
+  return { ok: true, from, to, aliases: plan.aliases, profiles: plan.profiles };
+}
+
+export { isValidProfileId, defaultProfilesDir, defaultProfilesConfigFile, loadProfileConfigFrom, saveProfileConfigTo, reclaimAlias, planProfileRename, applyProfileRename };

package/dist/cli.js

@@ -1,16 +1,20 @@
 #!/usr/bin/env node
 import {
   startProxyServer
-} from "./cli-ryt69ryf.js";
-import"./cli-5jxyma6z.js";
+} from "./cli-p5zbk952.js";
+import"./cli-82e2m44k.js";
+import"./cli-dh0a1bw4.js";
+import"./cli-8sw5wr9j.js";
+import"./cli-grfp0s1j.js";
 import"./cli-sry5aqdj.js";
-import"./cli-8yp89fan.js";
+import"./cli-p9ca4p13.js";
 import {
   resolveClaudeExecutableAsync
-} from "./cli-9e5cxp89.js";
-import"./cli-khhjyk04.js";
-import"./cli-vj9cv18n.js";
-import"./cli-hxxy0m1z.js";
+} from "./cli-2h3w5n6g.js";
+import"./cli-chsp880k.js";
+import"./cli-1jstkdj9.js";
+import"./cli-qpfky8wy.js";
+import"./cli-eehk3052.js";
 import {
   __require
 } from "./cli-p9swy5t3.js";
@@ -35,6 +39,7 @@ Usage: meridian [command] [options]
 
 Commands:
   (default)        Start the proxy server
+  status           Show what a running instance is doing (the / page, in the terminal)
   setup            Configure the OpenCode plugin (run once after install)
   profile          Manage Claude account profiles (add, list, switch, remove)
   refresh-token    Refresh the Claude Code OAuth token
@@ -60,7 +65,7 @@ See https://github.com/rynfar/meridian for full documentation.`);
   process.exit(0);
 }
 if (args[0] === "profile") {
-  const { profileAdd, profileAddOauthToken, profileList, profileRemove, profileSwitch, profileLogin, profileHelp } = await import("./profileCli-1eecbmgk.js");
+  const { profileAdd, profileAddOauthToken, profileList, profileRemove, profileRename, profileSwitch, profileLogin, profileHelp } = await import("./profileCli-1bfgc05h.js");
   const subcommand = args[1];
   const profileId = args[2];
   const headless = args.includes("--headless");
@@ -76,6 +81,8 @@ if (args[0] === "profile") {
     profileList();
   else if (subcommand === "remove" && profileId)
     profileRemove(profileId);
+  else if (subcommand === "rename" && profileId && args[3])
+    profileRename(profileId, args[3]);
   else if (subcommand === "switch" && profileId)
     await profileSwitch(profileId);
   else if (subcommand === "login" && profileId)
@@ -93,7 +100,7 @@ if (args[0] === "setup") {
     runSetup,
     SUPPORTED_OPENCODE_V2_VERSIONS,
     UnparseableConfigError
-  } = await import("./setup-ndmjpy23.js");
+  } = await import("./setup-7fr49z92.js");
   const forceV1 = args.includes("--v1");
   const forceV2 = args.includes("--v2");
   if (forceV1 && forceV2) {
@@ -172,7 +179,7 @@ Restart OpenCode for the plugin to take effect.`);
   process.exit(0);
 }
 if (args[0] === "refresh-token") {
-  const { refreshOAuthToken } = await import("./tokenRefresh-kzz08kea.js");
+  const { refreshOAuthToken } = await import("./tokenRefresh-eg9h83wd.js");
   const success = await refreshOAuthToken();
   if (success) {
     console.log("Token refreshed successfully");
@@ -189,6 +196,23 @@ var host = process.env.MERIDIAN_HOST ?? process.env.CLAUDE_PROXY_HOST ?? "127.0.
 var idleTimeoutSeconds = parseInt(process.env.MERIDIAN_IDLE_TIMEOUT_SECONDS ?? process.env.CLAUDE_PROXY_IDLE_TIMEOUT_SECONDS ?? "120", 10);
 var pluginDir = process.env.MERIDIAN_PLUGIN_DIR;
 var pluginConfigPath = process.env.MERIDIAN_PLUGIN_CONFIG;
+async function printRunningInstance() {
+  const { probeMeridian } = await import("./statusProbe-9x9q261e.js");
+  const result = await probeMeridian(host, port, { apiKey: process.env.MERIDIAN_API_KEY });
+  if (result.kind === "meridian") {
+    const { renderCliDashboard } = await import("./cliDashboard-c0dvkj4y.js");
+    process.stdout.write(renderCliDashboard({ host, port, ...result.snapshot }, { color: process.stdout.isTTY === true }));
+  }
+  return result;
+}
+if (args[0] === "status") {
+  const result = await printRunningInstance();
+  if (result.kind === "meridian")
+    process.exit(0);
+  const { formatStatusMessage } = await import("./statusProbe-9x9q261e.js");
+  console.error(formatStatusMessage(result, host, port));
+  process.exit(1);
+}
 var profiles;
 var defaultProfile;
 try {
@@ -205,7 +229,7 @@ async function runCli(start = startProxyServer, runAuthCheck = async () => {
   return execFile(claudePath, ["auth", "status"], { timeout: 5000 });
 }) {
   try {
-    const { findOpencodeConfigPath, checkPluginConfigured, findPluginPath } = await import("./setup-ndmjpy23.js");
+    const { findOpencodeConfigPath, checkPluginConfigured, findPluginPath } = await import("./setup-7fr49z92.js");
     const configPath = findOpencodeConfigPath();
     const { existsSync } = await import("fs");
     if (existsSync(configPath) && !checkPluginConfigured(configPath)) {
@@ -230,9 +254,11 @@ async function runCli(start = startProxyServer, runAuthCheck = async () => {
     console.error("\x1B[33m⚠ Could not verify Claude auth status. If requests fail, run: claude login\x1B[0m");
   }
   if (!profiles) {
-    const { enableDiskProfileDiscovery } = await import("./profiles-wch9h234.js");
+    const { enableDiskProfileDiscovery } = await import("./profiles-0mp32ek9.js");
     enableDiskProfileDiscovery();
   }
+  const { enableOrganizationLookup } = await import("./organizationName-90f0atkn.js");
+  enableOrganizationLookup();
   const proxy = await start({ port, host, idleTimeoutSeconds, pluginDir, pluginConfigPath, profiles, defaultProfile, version, installProcessErrorHandlers: true });
   proxy.server.on("error", (error) => {
     if (error.code === "EADDRINUSE") {
@@ -258,6 +284,15 @@ async function runCli(start = startProxyServer, runAuthCheck = async () => {
   process.on("SIGINT", handleShutdownSignal);
 }
 if (__require.main == __require.module) {
+  const { isPortAvailable } = await import("./statusProbe-9x9q261e.js");
+  if (!await isPortAvailable(host, port)) {
+    const result = await printRunningInstance();
+    if (result.kind === "meridian")
+      process.exit(0);
+    const { formatConflictMessage } = await import("./statusProbe-9x9q261e.js");
+    console.error(formatConflictMessage(result, host, port));
+    process.exit(1);
+  }
   await runCli();
 }
 export {

package/dist/cliDashboard-c0dvkj4y.js

@@ -0,0 +1,325 @@
+import {
+  WINDOW_LABELS,
+  classifyUtilization,
+  computeWeeklyPace,
+  formatResetCountdown
+} from "./cli-3zwfvexc.js";
+import"./cli-p9swy5t3.js";
+
+// src/telemetry/cliDashboard.ts
+var PALETTE = {
+  green: 71,
+  yellow: 178,
+  red: 203,
+  muted: 246,
+  accent: 75
+};
+var colorPaint = (text, color) => `\x1B[38;5;${PALETTE[color]}m${text}\x1B[0m`;
+var plainPaint = (text) => text;
+var UNKNOWN = "—";
+function isNum(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function usd(v) {
+  if (!isNum(v))
+    return UNKNOWN;
+  if (v > 0 && v < 0.01)
+    return `$${v.toFixed(4)}`;
+  if (v < 100)
+    return `$${v.toFixed(2)}`;
+  return `$${Math.round(v).toLocaleString("en-US")}`;
+}
+function tokens(v) {
+  if (!isNum(v))
+    return UNKNOWN;
+  if (v >= 1e6)
+    return `${(v / 1e6).toFixed(1)}M`;
+  if (v >= 1000)
+    return `${(v / 1000).toFixed(1)}k`;
+  return String(v);
+}
+function millis(v) {
+  if (!isNum(v) || v === 0)
+    return UNKNOWN;
+  return v < 1000 ? `${v}ms` : `${(v / 1000).toFixed(1)}s`;
+}
+function windowLabel(type) {
+  const known = WINDOW_LABELS[type];
+  if (known)
+    return known;
+  return type.replace(/^seven_day_/, "7d ").replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function utilizationColor(utilization) {
+  const status = classifyUtilization(utilization);
+  return status === "high" ? "red" : status === "warn" ? "yellow" : "green";
+}
+function paceStatus(pace) {
+  return pace.projectedPct != null && pace.projectedPct >= 100 ? "over" : pace.status;
+}
+function paceColor(status) {
+  return status === "over" ? "red" : status === "ahead" ? "yellow" : "green";
+}
+var BAR_WIDTH = 28;
+var BAR_FILL = "█";
+var BAR_TRACK = "░";
+var BAR_MARKER = "┃";
+function clampPct(pct) {
+  return Math.max(0, Math.min(100, pct));
+}
+function renderBar(pct, color, paint, markerPct) {
+  const filled = Math.round(clampPct(pct) / 100 * BAR_WIDTH);
+  const marker = markerPct == null ? -1 : Math.min(Math.round(clampPct(markerPct) / 100 * BAR_WIDTH), BAR_WIDTH - 1);
+  const cells = [];
+  for (let i2 = 0;i2 < BAR_WIDTH; i2++) {
+    if (i2 === marker)
+      cells.push({ ch: BAR_MARKER, role: "marker" });
+    else if (i2 < filled)
+      cells.push({ ch: BAR_FILL, role: "fill" });
+    else
+      cells.push({ ch: BAR_TRACK, role: "track" });
+  }
+  let out = "";
+  let i = 0;
+  while (i < cells.length) {
+    const role = cells[i].role;
+    let run = "";
+    while (i < cells.length && cells[i].role === role) {
+      run += cells[i].ch;
+      i++;
+    }
+    out += role === "fill" ? paint(run, color) : role === "track" ? paint(run, "muted") : run;
+  }
+  return out;
+}
+function buildAccounts(input, now) {
+  const byProfile = input.summary?.costEstimate?.byProfile ?? {};
+  const quotaByProfile = {};
+  for (const entry of input.quota?.profiles ?? []) {
+    quotaByProfile[entry.id || entry.profile || "default"] = entry.windows ?? [];
+  }
+  const configured = input.profileList?.profiles ?? [];
+  const candidates = [];
+  if (configured.length > 0) {
+    for (const p of configured) {
+      const id = p.id ?? "default";
+      candidates.push({ id, label: id, isActive: p.isActive === true, configured: true });
+    }
+  } else {
+    const auth = input.health?.auth;
+    const email = auth?.loggedIn && auth.email || "";
+    const seen = new Set;
+    for (const key of [...Object.keys(quotaByProfile), ...Object.keys(byProfile)]) {
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      candidates.push({
+        id: key,
+        label: key === "default" ? email || "account" : key,
+        isActive: false,
+        configured: false
+      });
+    }
+  }
+  const isPriority = input.profileList?.routing === "priority";
+  const blocks = [];
+  for (const candidate of candidates) {
+    const cost = byProfile[candidate.id];
+    const windows = (quotaByProfile[candidate.id] ?? []).filter((w) => w.utilization != null);
+    if (!candidate.configured && windows.length === 0 && !cost)
+      continue;
+    const rows = [];
+    for (const w of windows) {
+      const utilization = w.utilization;
+      if (!isNum(utilization))
+        continue;
+      rows.push({
+        label: windowLabel(w.type ?? ""),
+        pct: Math.round(utilization * 100),
+        figure: `${Math.round(utilization * 100)}%`,
+        color: utilizationColor(utilization),
+        note: formatResetCountdown(w.resetsAt, now)
+      });
+    }
+    let weekly;
+    for (const w of windows)
+      if (w.type === "seven_day")
+        weekly = w;
+    const pace = weekly ? computeWeeklyPace(weekly.utilization, weekly.resetsAt, now) : null;
+    if (pace) {
+      const status = paceStatus(pace);
+      const projected = pace.projectedPct;
+      const figure = status === "over" ? projected != null ? `${projected}%` : "100%" : `${pace.deltaPct >= 0 ? "+" : "-"}${Math.abs(pace.deltaPct)}%`;
+      rows.push({
+        label: "pace",
+        pct: pace.actualPct,
+        markerPct: pace.expectedPct,
+        figure,
+        color: paceColor(status),
+        note: status === "over" ? "runs out before reset" : projected != null ? `~${projected}% by reset` : ""
+      });
+    }
+    const badges = [];
+    if (isPriority) {
+      const order = input.profileList?.profileOrder ?? [];
+      const idx = order.indexOf(candidate.id);
+      if (idx >= 0)
+        badges.push({ text: `#${idx + 1} in pool`, color: "muted" });
+      const exhausted = (input.profileList?.exhausted ?? []).find((e) => e.id === candidate.id);
+      if (exhausted) {
+        badges.push({
+          text: `exhausted · resets ${formatResetCountdown(exhausted.until, now)}`,
+          color: "red"
+        });
+      }
+    } else if (candidate.isActive) {
+      badges.push({ text: "ACTIVE", color: "accent" });
+    }
+    const requests = cost?.requests;
+    blocks.push({
+      label: candidate.label,
+      isActive: candidate.isActive,
+      badges,
+      cost: usd(cost ? cost.estimatedUsd : 0),
+      sub: isNum(requests) ? `${requests} request${requests === 1 ? "" : "s"} · est. API value · 24h` : "no traffic · 24h",
+      rows
+    });
+  }
+  return blocks;
+}
+function buildStrip(summary) {
+  const tu = summary.tokenUsage ?? {};
+  const hitRate = tu.avgCacheHitRate;
+  const errors = summary.errorCount;
+  const items = [
+    {
+      label: "Requests",
+      value: isNum(summary.totalRequests) ? String(summary.totalRequests) : UNKNOWN,
+      detail: !isNum(errors) ? UNKNOWN : errors > 0 ? `${errors} error${errors === 1 ? "" : "s"}` : "no errors",
+      detailColor: isNum(errors) && errors > 0 ? "red" : undefined
+    },
+    {
+      label: "Tokens Out",
+      value: tokens(tu.totalOutputTokens),
+      detail: `${tokens(tu.totalInputTokens)} in`
+    },
+    {
+      label: "Cache Hit",
+      value: isNum(hitRate) ? `${Math.round(hitRate * 100)}%` : UNKNOWN,
+      valueColor: isNum(hitRate) && hitRate >= 0.5 ? "green" : undefined,
+      detail: "prompt cache"
+    },
+    {
+      label: "Est. API Value",
+      value: usd(summary.costEstimate?.totalUsd),
+      detail: "list prices"
+    },
+    {
+      label: "Median Response",
+      value: millis(summary.totalDuration?.p50),
+      detail: `p95 ${millis(summary.totalDuration?.p95)}`
+    }
+  ];
+  const violations = summary.envelopeViolationCount;
+  if (isNum(violations) && violations > 0) {
+    items.push({
+      label: "Envelope",
+      value: String(violations),
+      valueColor: "red",
+      detail: "wire-contract violations",
+      detailColor: "red"
+    });
+  }
+  return items;
+}
+function healthPill(health) {
+  const status = health?.status;
+  if (status === "healthy")
+    return { label: "Operational", color: "green" };
+  if (status === "degraded")
+    return { label: "Degraded", color: "yellow" };
+  return { label: "Offline", color: "red" };
+}
+function activeProfileChip(profileList) {
+  const active = (profileList?.profiles ?? []).find((p) => p.isActive === true);
+  if (!active?.id)
+    return null;
+  return active.type ? `${active.id} ${active.type}` : active.id;
+}
+var INDENT = "  ";
+function renderCliDashboard(input, options = {}) {
+  const paint = options.color ? colorPaint : plainPaint;
+  const bold = options.color ? (t) => `\x1B[1m${t}\x1B[22m` : (t) => t;
+  const now = input.now ?? Date.now();
+  const out = [];
+  const pill = healthPill(input.health);
+  const chip = activeProfileChip(input.profileList);
+  out.push(`${bold("MERIDIAN")}  ${paint("●", pill.color)} ${pill.label}` + (chip ? `  ${paint("·", "muted")}  ${chip}` : ""));
+  out.push("");
+  out.push(`${INDENT}ANTHROPIC_BASE_URL=http://${input.host}:${input.port}`);
+  const meta = [];
+  const auth = input.health?.auth;
+  if (auth?.loggedIn) {
+    meta.push(`${auth.email ?? ""}${auth.subscriptionType ? ` (${auth.subscriptionType})` : ""}`);
+  }
+  meta.push(input.health?.mode ?? "internal");
+  meta.push(`port ${input.port}`);
+  out.push(`${INDENT}${paint(meta.join(" · "), "muted")}`);
+  out.push("");
+  const accounts = buildAccounts(input, now);
+  const accountsNote = input.unavailable?.accounts;
+  if (accounts.length > 0 || accountsNote) {
+    out.push(paint(accounts.length === 1 ? "ACCOUNT" : "ACCOUNTS", "muted"));
+    out.push("");
+    if (accountsNote) {
+      out.push(`${INDENT}${paint(accountsNote, "yellow")}`);
+      out.push("");
+    }
+    const allRows = accounts.flatMap((a) => a.rows);
+    const labelWidth = Math.max(0, ...allRows.map((r) => r.label.length));
+    const figureWidth = Math.max(0, ...allRows.map((r) => r.figure.length));
+    const costColumn = INDENT.length + 2 + labelWidth + 2 + BAR_WIDTH + 2 + figureWidth;
+    for (const account of accounts) {
+      const dot = paint("●", account.isActive ? "accent" : "muted");
+      const badges = account.badges.map((b) => b.color ? paint(b.text, b.color) : b.text).join("  ");
+      const headLeft = `${account.label}${badges ? `  ${badges}` : ""}`;
+      const headLeftPlain = account.label + (account.badges.length > 0 ? `  ${account.badges.map((b) => b.text).join("  ")}` : "");
+      const gap = Math.max(1, costColumn - INDENT.length - 2 - headLeftPlain.length - account.cost.length);
+      out.push(`${INDENT}${dot} ${headLeft}${" ".repeat(gap)}${bold(account.cost)}`);
+      out.push(`${INDENT}  ${paint(account.sub, "muted")}`);
+      if (account.rows.length === 0) {
+        out.push(`${INDENT}  ${paint("no usage data yet", "muted")}`);
+      }
+      for (const row of account.rows) {
+        const label = row.label.padEnd(labelWidth);
+        const bar = renderBar(row.pct, row.color, paint, row.markerPct);
+        const figure = row.figure.padStart(figureWidth);
+        const note = row.note ? `  ${paint(row.note, "muted")}` : "";
+        out.push(`${INDENT}  ${paint(label, "muted")}  ${bar}  ${paint(figure, row.color)}${note}`);
+      }
+      out.push("");
+    }
+  }
+  const trafficNote = input.unavailable?.traffic;
+  out.push(paint("LAST 24 HOURS", "muted"));
+  out.push("");
+  if (trafficNote) {
+    out.push(`${INDENT}${paint(trafficNote, "yellow")}`);
+  } else {
+    const items = buildStrip(input.summary ?? {});
+    const labelWidth = Math.max(...items.map((i) => i.label.length));
+    const valueWidth = Math.max(...items.map((i) => i.value.length));
+    for (const item of items) {
+      const label = paint(item.label.padEnd(labelWidth), "muted");
+      const valuePlain = item.value.padStart(valueWidth);
+      const value = item.valueColor ? paint(valuePlain, item.valueColor) : valuePlain;
+      const detail = item.detailColor ? paint(item.detail, item.detailColor) : paint(item.detail, "muted");
+      out.push(`${INDENT}${label}  ${value}  ${detail}`);
+    }
+  }
+  return `${out.join(`
+`)}
+`;
+}
+export {
+  renderCliDashboard
+};

package/dist/configDir.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Where Meridian keeps its own configuration.
+ *
+ * One directory holds everything Meridian persists for itself — settings.json,
+ * profiles.json, the per-profile CLAUDE_CONFIG_DIRs under profiles/,
+ * adapter-instances.json, sdk-features.json, model-pricing.json, telemetry.db.
+ * `MERIDIAN_CONFIG_DIR` moves that directory, so a second instance pointed at
+ * an empty one gets its own everything rather than inheriting the first
+ * instance's accounts.
+ *
+ * Resolved per call, never frozen at import time. A module-level constant is
+ * computed before the CLI has parsed argv or a test has set the variable, and
+ * can then be changed by neither.
+ *
+ * NOTE: deliberately does NOT honour XDG_CONFIG_HOME — anyone who has that set
+ * would silently relocate to a different config directory and appear to lose
+ * everything in it.
+ *
+ * NOTE: read straight from process.env rather than through env.ts, which would
+ * also accept a CLAUDE_PROXY_CONFIG_DIR alias. This variable postdates that
+ * prefix, so there is no legacy deployment to stay compatible with and no
+ * reason to start accepting a second name for it.
+ */
+/** The directory used when MERIDIAN_CONFIG_DIR is unset. */
+export declare function defaultConfigDir(): string;
+/** The directory Meridian's configuration lives in. */
+export declare function configDir(): string;
+/** A path inside the config directory, e.g. `configPath("profiles.json")`. */
+export declare function configPath(...segments: string[]): string;
+//# sourceMappingURL=configDir.d.ts.map

package/dist/configDir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configDir.d.ts","sourceRoot":"","sources":["../src/configDir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,4DAA4D;AAC5D,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,uDAAuD;AACvD,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAExD"}

package/dist/organizationName-90f0atkn.js

@@ -0,0 +1,29 @@
+import {
+  ORGANIZATION_REFRESH_AFTER_MS,
+  ORGANIZATION_RETRY_AFTER_MS,
+  enableOrganizationLookup,
+  extractOrganizationName,
+  fetchOrganizationName,
+  organizationNames,
+  organizationNeedsRefresh,
+  readOrganizations,
+  refreshOrganizationNameSoon,
+  rememberOrganizationName,
+  resetOrganizationLookupForTesting
+} from "./cli-8sw5wr9j.js";
+import"./cli-chsp880k.js";
+import"./cli-1jstkdj9.js";
+import"./cli-p9swy5t3.js";
+export {
+  resetOrganizationLookupForTesting,
+  rememberOrganizationName,
+  refreshOrganizationNameSoon,
+  readOrganizations,
+  organizationNeedsRefresh,
+  organizationNames,
+  fetchOrganizationName,
+  extractOrganizationName,
+  enableOrganizationLookup,
+  ORGANIZATION_RETRY_AFTER_MS,
+  ORGANIZATION_REFRESH_AFTER_MS
+};