@hasna/statusline 0.0.2 → 0.0.4

package/README.md

@@ -39,6 +39,12 @@ anything that returns `null` or throws. A failed segment never breaks the host U
 | `current-dir` | off | Current working directory (basename) | `StatusContext.cwd` | never (always renders basename) | `open-statusline` |
 | `model` | off | Current model name (no context tag) | `StatusContext.model.id` via friendly formatter | no model id | `fable 5` |
 | `model-context` | on | Model name with context-size tag | same formatter, keeps `[tag]` suffix | no model id | `fable 5 [1m]` |
+| `model-with-reasoning` | off | Model name with its reasoning effort | `model.display_name` (or friendly id) + `effort.level`; falls back to `thinking.enabled`, which the host defaults to on | no model | `Fable (xhigh)` |
+| `auth-profile` | off | Account profile this session runs as | this process's `CLAUDE_CONFIG_DIR`, resolved against the accounts registry | config dir is unmanaged and has no login | `account001` |
+| `auth-email` | off | Account email this session is logged in as | the agent's own login record for this config dir, else the registry | no login recorded | `dev@example.com` |
+| `five-hour-limit` | off | Percentage of the 5-hour rate limit used | `rate_limits.five_hour.used_percentage` | host reports no limit data | `5h:42%` |
+| `seven-day-limit` | off | Percentage of the 7-day rate limit used | `rate_limits.seven_day.used_percentage` | host reports no limit data | `7d:12%` |
+| `thread-title` | off | Thread title set with `/rename` | `session_name` | thread not renamed | `ship it` |
 | `context-used` | off | Percentage of context window used | session transcript JSONL (`contextUsage`) | transcript missing/unreadable | `10%` |
 | `context-remaining` | on | Percentage of context window remaining | transcript via `contextUsage` | transcript missing/unreadable | `90% left` |
 | `used-tokens` | off | Total tokens in the context window | transcript usage block (input + output) | transcript missing/unreadable | `102k tok` |
@@ -60,6 +66,51 @@ JSONL for the last assistant entry with a `usage` block and sums
 With the test fixture transcript (100k input-side tokens on a 1m window), expect
 `context-used` → `10%`, `context-remaining` → `90% left`, `used-tokens` → `102k tok`.
 
+### Which account am I? (`auth-profile`)
+
+Statusline payloads carry no account or profile field, so `auth-profile` reads the
+config dir **this process** was handed — `CLAUDE_CONFIG_DIR`, which multi-account
+launchers set per session — and resolves it in order:
+
+1. the `@hasna/accounts` registry entry whose `dir` matches, preferring one that
+   belongs to the agent being rendered (a dir can be claimed by several tools;
+   another tool's entry is never adopted);
+2. the managed layout `<accountsHome>/profiles/<tool>/<name>`, for dirs the local
+   registry has no entry for;
+3. the account email the agent recorded in that dir, when neither names a profile.
+
+It never consults an "active"/"current" profile pointer. Those are global — and,
+against a shared registry, global across every machine: two sessions running under
+different accounts would both report whichever profile was switched to last.
+Resolving from the process's own config dir keeps concurrent sessions independent.
+
+Where the agent's login record lives mirrors Claude Code's own rule: `.config.json`
+in the config dir wins, otherwise `.claude<oauth-variant>.json`. Note the base dir
+is the config dir **or the home dir** — with `CLAUDE_CONFIG_DIR` unset the file is
+`~/.claude.json`, a sibling of `~/.claude` rather than something inside it.
+
+Registry location comes from `@hasna/accounts` itself when it is installed
+alongside this package (imported lazily, only when an auth segment renders);
+otherwise from its documented overrides `ACCOUNTS_STORE_PATH`, then
+`ACCOUNTS_HOME`, then `~/.hasna/accounts`. `@hasna/accounts` is not a dependency —
+with none of it present the segment renders nothing rather than guessing.
+
+**Known limitation.** Renaming a profile does not move its dir. For a profile the
+local registry has no entry for, step 2 therefore reports the name the dir was
+created with until the registry catches up. Step 1 is tried first so a profile the
+registry knows about always wins.
+
+### Colours
+
+Segments may declare a colour, applied by `renderLine` when colours are on
+(the default). The rate-limit segments escalate from yellow to red past 80%.
+
+```bash
+statusline colors off      # or set "colors": false in the config
+```
+
+`NO_COLOR` in the environment always wins.
+
 ### Quick reference from `statusline list`
 
 `statusline list` is compact by default so it stays friendly in agent terminals —
@@ -109,6 +160,7 @@ statusbar width.
 statusline list                          # compact segment summary
 statusline enable used-tokens duration    # turn segments on (appended at the end)
 statusline disable loc                    # turn segments off
+statusline colors off                     # drop ANSI colours
 statusline order machine project model-context cost   # exact order = enabled set
 statusline separator " | "                # change the separator
 statusline preview                        # render a sample line from the current dir
@@ -198,7 +250,17 @@ bun install -g @hasna/statusline
 statusline install claude
 ```
 
-`installClaude()` writes to `~/.claude/settings.json`:
+`installClaude()` writes to `$CLAUDE_CONFIG_DIR/settings.json`, falling back to
+`~/.claude/settings.json`. This matters for multi-account setups: when a session is
+bound to an isolated config dir, `~/.claude/settings.json` is never read, so
+installing there wires up a statusline that silently never runs.
+
+Only `~/.claude` is created on demand. Every other target — an isolated config
+dir, or a path passed as `installClaude(path)` — must already exist: installing
+there is a request to configure a profile someone else created, not to fabricate
+one. The rule follows the target, not the shell you install from, so driving a
+list of profiles gives the same answer from any session. Pass the environment to
+resolve against as `installClaude(undefined, env)`.
 
 ```json
 {
@@ -222,8 +284,13 @@ on every status refresh — **no restart needed**.
 | `cost.total_lines_added/removed` | `cost.totalLinesAdded/Removed` |
 | `transcript_path` | `transcriptPath` |
 | `session_id` | `sessionId` |
+| `session_name` | `sessionName` |
 | `version` | `version` |
 | `output_style.name` | `outputStyle` |
+| `effort.level` | `effort` |
+| `thinking.enabled` | `thinking` |
+| `rate_limits.five_hour.used_percentage` | `rateLimits.fiveHour.usedPercentage` |
+| `rate_limits.seven_day.used_percentage` | `rateLimits.sevenDay.usedPercentage` |
 
 Every field is optional — partial or empty payloads still produce a usable context.
 

package/dist/accounts.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Which account is *this* session running as?
+ *
+ * The host agent's statusline payload carries no account or profile field, so
+ * the answer has to come from the process environment. Tools that manage
+ * several logins (`@hasna/accounts`, and Claude Code itself) isolate each
+ * login in its own config dir and point the child process at it via
+ * `CLAUDE_CONFIG_DIR`. That variable is per-process, so it is the only signal
+ * that stays correct when several sessions run under different accounts at the
+ * same time.
+ *
+ * Deliberately NOT used: any "active"/"current"/"applied" profile pointer.
+ * Those are global — every concurrent session would report whichever profile
+ * was switched to last, which is the staleness this module exists to avoid.
+ */
+export interface SessionAccount {
+    /** Config dir this session is running against (canonicalized). */
+    configDir: string;
+    /** Managed profile name owning that dir, when it can be resolved. */
+    profile: string | null;
+    /** Tool id the profile belongs to (e.g. "claude"), when known. */
+    tool: string | null;
+    /**
+     * How `profile` was resolved. `"layout"` means it was read off the dir path
+     * rather than the registry, which is authoritative about the dir but can lag
+     * a rename — see `layoutProfile`. Surfaced for diagnostics, not for display.
+     */
+    source: "registry" | "layout" | null;
+}
+type Env = Record<string, string | undefined>;
+/** Config dir the current process is bound to, for settings and registry lookup. */
+export declare function sessionConfigDir(env?: Env): string;
+/**
+ * Path of the host agent's account record for this session, or null when none
+ * of its known filenames are present.
+ */
+export declare function sessionStateFile(env?: Env): string | null;
+/**
+ * Resolve the profile owning this session. `tool` is the agent being rendered
+ * for, used to disambiguate a config dir claimed by several tools. Never throws.
+ */
+export declare function sessionAccount(env?: Env, tool?: string): Promise<SessionAccount>;
+/**
+ * Email this session is logged in as. The host agent's own record for this
+ * config dir wins over the registry's copy, which can lag behind a re-login.
+ * Read separately from `sessionAccount` because it parses the agent's state
+ * blob, which is large enough to only touch when a segment asks for it.
+ */
+export declare function sessionAccountEmail(env?: Env, tool?: string): Promise<string | null>;
+export {};

package/dist/cli.js

@@ -1,36 +1,6 @@
 #!/usr/bin/env bun
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -52,6 +22,7 @@ import { dirname, join } from "path";
 function defaultConfig() {
   return {
     separator: " \xB7 ",
+    colors: true,
     segments: [
       "machine",
       "project",
@@ -79,7 +50,8 @@ function loadConfig(path = configPath()) {
     const fallback = defaultConfig();
     return {
       separator: typeof raw.separator === "string" ? raw.separator : fallback.separator,
-      segments: Array.isArray(raw.segments) ? raw.segments.filter((s) => typeof s === "string") : fallback.segments
+      segments: Array.isArray(raw.segments) ? raw.segments.filter((s) => typeof s === "string") : fallback.segments,
+      colors: typeof raw.colors === "boolean" ? raw.colors : fallback.colors
     };
   } catch {
     return defaultConfig();
@@ -107,8 +79,15 @@ function parseClaudeInput(input) {
     } : undefined,
     transcriptPath: input?.transcript_path || undefined,
     sessionId: input?.session_id || undefined,
+    sessionName: input?.session_name || undefined,
     version: input?.version || undefined,
-    outputStyle: input?.output_style?.name || undefined
+    outputStyle: input?.output_style?.name || undefined,
+    effort: input?.effort?.level || undefined,
+    thinking: typeof input?.thinking?.enabled === "boolean" ? input.thinking.enabled : undefined,
+    rateLimits: input?.rate_limits ? {
+      fiveHour: { usedPercentage: numberOr(input.rate_limits.five_hour?.used_percentage) },
+      sevenDay: { usedPercentage: numberOr(input.rate_limits.seven_day?.used_percentage) }
+    } : undefined
   };
 }
 function numberOr(v) {
@@ -253,6 +232,158 @@ function windowSize(ctx) {
   return ctx.model?.id?.includes("[1m]") ? 1e6 : 200000;
 }
 
+// src/accounts.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, resolve, sep } from "path";
+var CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
+var DEFAULT_CONFIG_SUBDIR = ".claude";
+var STORE_PATH_ENV = "ACCOUNTS_STORE_PATH";
+var ACCOUNTS_HOME_ENV = "ACCOUNTS_HOME";
+var DEFAULT_ACCOUNTS_HOME = [".hasna", "accounts"];
+var STORE_FILE = "accounts.json";
+var PROFILES_SUBDIR = "profiles";
+var STATE_FILE_PREFERRED = ".config.json";
+var STATE_FILE_PREFIX = ".claude";
+var STATE_FILE_SUFFIX = ".json";
+var CUSTOM_OAUTH_ENV = "CLAUDE_CODE_CUSTOM_OAUTH_URL";
+var OAUTH_VARIANTS = ["", "-custom-oauth", "-local-oauth", "-staging-oauth"];
+function str(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function home(env) {
+  return str(env.HOME) ?? homedir2();
+}
+function expandHome(path, env) {
+  return path === "~" || path.startsWith(`~${sep}`) ? join2(home(env), path.slice(1)) : path;
+}
+function canonical(path, env) {
+  const abs = resolve(expandHome(path, env));
+  try {
+    return realpathSync(abs);
+  } catch {
+    return abs;
+  }
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var ACCOUNTS_STORAGE_MODULE = "@hasna/accounts/storage";
+var storagePromise;
+function accountsStorage() {
+  storagePromise ??= import(ACCOUNTS_STORAGE_MODULE).then((mod) => typeof mod?.storePath === "function" && typeof mod?.profilesDir === "function" ? mod : null, () => null);
+  return storagePromise;
+}
+async function accountsPaths(env) {
+  const homeOverride = str(env[ACCOUNTS_HOME_ENV]);
+  const storeOverride = str(env[STORE_PATH_ENV]);
+  if (!homeOverride && !storeOverride) {
+    const storage = await accountsStorage();
+    try {
+      if (storage)
+        return { store: storage.storePath(), profiles: storage.profilesDir() };
+    } catch {}
+  }
+  const base = homeOverride ?? join2(home(env), ...DEFAULT_ACCOUNTS_HOME);
+  return {
+    store: storeOverride ?? join2(base, STORE_FILE),
+    profiles: join2(base, PROFILES_SUBDIR)
+  };
+}
+function registryEntry(store, configDir, env, tool) {
+  if (!existsSync3(store))
+    return null;
+  const entries = readJson(store)?.profiles;
+  if (!Array.isArray(entries))
+    return null;
+  let untyped = null;
+  let first = null;
+  for (const entry of entries) {
+    const dir = str(entry?.dir);
+    if (!dir || canonical(dir, env) !== configDir)
+      continue;
+    const entryTool = str(entry?.tool);
+    if (tool && entryTool === tool)
+      return entry;
+    if (!entryTool)
+      untyped ??= entry;
+    first ??= entry;
+  }
+  return tool ? untyped : first;
+}
+function layoutProfile(profilesRoot, configDir, env) {
+  if (!existsSync3(configDir))
+    return null;
+  const prefix = canonical(profilesRoot, env) + sep;
+  if (!configDir.startsWith(prefix))
+    return null;
+  const parts = configDir.slice(prefix.length).split(sep);
+  if (parts.length !== 2)
+    return null;
+  const [tool, profile] = parts;
+  if (!tool || !profile)
+    return null;
+  return { configDir, profile, tool, source: "layout" };
+}
+function sessionConfigDir(env = process.env) {
+  return canonical(str(env[CONFIG_DIR_ENV]) ?? join2(home(env), DEFAULT_CONFIG_SUBDIR), env);
+}
+function sessionStateFile(env = process.env) {
+  const base = canonical(str(env[CONFIG_DIR_ENV]) ?? home(env), env);
+  const preferred = join2(base, STATE_FILE_PREFERRED);
+  if (existsSync3(preferred))
+    return preferred;
+  const variants = str(env[CUSTOM_OAUTH_ENV]) ? ["-custom-oauth", ...OAUTH_VARIANTS] : OAUTH_VARIANTS;
+  for (const variant of variants) {
+    const candidate = join2(base, `${STATE_FILE_PREFIX}${variant}${STATE_FILE_SUFFIX}`);
+    if (existsSync3(candidate))
+      return candidate;
+  }
+  return null;
+}
+async function sessionAccount(env = process.env, tool) {
+  const configDir = sessionConfigDir(env);
+  const unresolved = { configDir, profile: null, tool: null, source: null };
+  try {
+    const paths = await accountsPaths(env);
+    const entry = registryEntry(paths.store, configDir, env, tool);
+    const name = str(entry?.name);
+    if (name)
+      return { configDir, profile: name, tool: str(entry?.tool), source: "registry" };
+    return layoutProfile(paths.profiles, configDir, env) ?? unresolved;
+  } catch {
+    return unresolved;
+  }
+}
+async function sessionAccountEmail(env = process.env, tool) {
+  try {
+    const stateFile = sessionStateFile(env);
+    const live = stateFile ? str(readJson(stateFile)?.oauthAccount?.emailAddress) : null;
+    if (live)
+      return live;
+    const paths = await accountsPaths(env);
+    return str(registryEntry(paths.store, sessionConfigDir(env), env, tool)?.email);
+  } catch {
+    return null;
+  }
+}
+
+// src/settings.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join3 } from "path";
+function sessionFastMode(env = process.env) {
+  try {
+    const raw = readFileSync4(join3(sessionConfigDir(env), "settings.json"), "utf8");
+    return JSON.parse(raw)?.fastMode === true;
+  } catch {
+    return false;
+  }
+}
+
 // src/segments/index.ts
 function friendlyModel(id) {
   let tag = null;
@@ -270,6 +401,14 @@ function friendlyModel(id) {
   return { name: name || mid, tag };
 }
 var dir = (ctx) => ctx.cwd || process.cwd();
+function modelName(ctx) {
+  if (ctx.model?.displayName)
+    return ctx.model.displayName.toLowerCase();
+  return ctx.model?.id ? friendlyModel(ctx.model.id).name : null;
+}
+function limitPercent(pct) {
+  return typeof pct === "number" ? pct : 0;
+}
 var segments = [
   {
     id: "machine",
@@ -348,6 +487,73 @@ var segments = [
       return tag ? `${name} ${tag}` : name;
     }
   },
+  {
+    id: "model-with-reasoning",
+    description: "Model name with its reasoning effort (or thinking, when on)",
+    defaultEnabled: false,
+    color: "cyan",
+    render(ctx) {
+      const name = modelName(ctx);
+      if (!name)
+        return null;
+      if (ctx.effort)
+        return `${name} (${ctx.effort.toLowerCase()})`;
+      if (ctx.thinking)
+        return `${name} (thinking)`;
+      return name;
+    }
+  },
+  {
+    id: "fast-mode",
+    description: `Shows "fast" when fast mode is on for this session's config dir`,
+    defaultEnabled: false,
+    color: "yellow",
+    render: () => sessionFastMode(process.env) ? "fast" : null
+  },
+  {
+    id: "auth-profile",
+    description: "Account profile this session runs as (omitted when unmanaged)",
+    defaultEnabled: false,
+    color: "magenta",
+    async render(ctx) {
+      const account = await sessionAccount(process.env, ctx.provider);
+      return account.profile ?? await sessionAccountEmail(process.env, ctx.provider);
+    }
+  },
+  {
+    id: "auth-email",
+    description: "Account email this session is logged in as (omitted when unknown)",
+    defaultEnabled: false,
+    color: "magenta",
+    render: (ctx) => sessionAccountEmail(process.env, ctx.provider)
+  },
+  {
+    id: "five-hour-limit",
+    description: "Percentage of the 5-hour rate limit used (omitted when unreported)",
+    defaultEnabled: false,
+    color: (ctx) => limitPercent(ctx.rateLimits?.fiveHour?.usedPercentage) >= 80 ? "red" : "yellow",
+    render(ctx) {
+      const pct = ctx.rateLimits?.fiveHour?.usedPercentage;
+      return typeof pct === "number" ? `5h:${Math.round(pct)}%` : null;
+    }
+  },
+  {
+    id: "seven-day-limit",
+    description: "Percentage of the 7-day rate limit used (omitted when unreported)",
+    defaultEnabled: false,
+    color: (ctx) => limitPercent(ctx.rateLimits?.sevenDay?.usedPercentage) >= 80 ? "red" : "yellow",
+    render(ctx) {
+      const pct = ctx.rateLimits?.sevenDay?.usedPercentage;
+      return typeof pct === "number" ? `7d:${Math.round(pct)}%` : null;
+    }
+  },
+  {
+    id: "thread-title",
+    description: "Thread title set with /rename (omitted until named)",
+    defaultEnabled: false,
+    color: "blue",
+    render: (ctx) => ctx.sessionName || null
+  },
   {
     id: "context-used",
     description: "Percentage of context window used (omitted when unknown)",
@@ -431,6 +637,12 @@ var segments = [
     description: "Session identifier (short)",
     defaultEnabled: false,
     render: (ctx) => ctx.sessionId ? ctx.sessionId.split("-")[0] : null
+  },
+  {
+    id: "newline",
+    description: "Row break \u2014 segments after it render on the next line",
+    defaultEnabled: false,
+    render: () => null
   }
 ];
 function getSegment(id) {
@@ -438,24 +650,51 @@ function getSegment(id) {
 }
 
 // src/render.ts
+var ANSI = {
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m",
+  blue: "\x1B[34m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m"
+};
+var RESET = "\x1B[0m";
+function colorsEnabled(cfg, env = process.env) {
+  if (env.NO_COLOR)
+    return false;
+  return cfg.colors !== false;
+}
+function paint(segment, text, ctx) {
+  const color = typeof segment.color === "function" ? segment.color(ctx) : segment.color;
+  const code = color ? ANSI[color] : undefined;
+  return code ? `${code}${text}${RESET}` : text;
+}
 async function renderLine(ctx, cfg) {
-  const parts = [];
+  const colorize = colorsEnabled(cfg);
+  const rows = [[]];
   for (const id of cfg.segments) {
+    if (id === "newline") {
+      rows.push([]);
+      continue;
+    }
     const segment = getSegment(id);
     if (!segment)
       continue;
     try {
       const out = await segment.render(ctx);
       if (out)
-        parts.push(out);
+        rows[rows.length - 1].push(colorize ? paint(segment, out, ctx) : out);
     } catch {}
   }
-  return parts.join(cfg.separator);
+  return rows.map((parts) => parts.join(cfg.separator)).filter((row) => row.length > 0).join(`
+`);
 }
 // package.json
 var package_default = {
   name: "@hasna/statusline",
-  version: "0.0.2",
+  version: "0.0.4",
   description: "Tiny composable statusline CLI for AI coding agents \u2014 pre-built toggleable segments for Claude Code, with a provider model for others",
   license: "Apache-2.0",
   type: "module",
@@ -515,30 +754,52 @@ var package_default = {
     bun: ">=1.0.0"
   },
   dependencies: {
-    "@modelcontextprotocol/sdk": "^1.12.1",
-    zod: "^3.25.76"
+    "@modelcontextprotocol/sdk": "1.12.1",
+    zod: "3.25.76"
   },
   devDependencies: {
     "@types/bun": "^1.2.4",
-    typescript: "^5.7.3"
+    typescript: "5.9.3"
   }
 };
 // src/install.ts
-import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join2 } from "path";
-function installClaude(settingsPath = join2(homedir2(), ".claude", "settings.json")) {
+import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "path";
+function defaultSettingsPath(env) {
+  return join4(env.HOME || homedir3(), ".claude", "settings.json");
+}
+function claudeSettingsPath(env = process.env) {
+  const home2 = env.HOME || homedir3();
+  const raw = env.CLAUDE_CONFIG_DIR?.trim();
+  if (!raw)
+    return defaultSettingsPath(env);
+  const configDir = raw === "~" || raw.startsWith("~/") ? join4(home2, raw.slice(1)) : raw;
+  return join4(configDir, "settings.json");
+}
+function installClaude(settingsPath, env = process.env) {
+  const target = settingsPath ?? claudeSettingsPath(env);
   const binary = Bun.which("statusline") || "statusline";
   let settings = {};
-  if (existsSync3(settingsPath)) {
-    settings = JSON.parse(readFileSync3(settingsPath, "utf8"));
-    copyFileSync(settingsPath, `${settingsPath}.bak-statusline`);
+  if (existsSync4(target)) {
+    try {
+      settings = JSON.parse(readFileSync5(target, "utf8"));
+    } catch (error) {
+      throw new Error(`${target} is not valid JSON \u2014 fix or move it first`);
+    }
+    copyFileSync(target, `${target}.bak-statusline`);
   }
-  settings.statusLine = { type: "command", command: `${binary} render` };
-  mkdirSync2(dirname2(settingsPath), { recursive: true });
-  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + `
+  settings.statusLine = { ...settings.statusLine, type: "command", command: `${binary} render` };
+  const configDir = dirname2(target);
+  if (!existsSync4(configDir)) {
+    if (resolve2(target) !== resolve2(defaultSettingsPath(env))) {
+      throw new Error(`config dir ${configDir} does not exist \u2014 create the profile first`);
+    }
+    mkdirSync2(configDir, { recursive: true });
+  }
+  writeFileSync2(target, JSON.stringify(settings, null, 2) + `
 `);
-  return settingsPath;
+  return target;
 }
 
 // src/index.ts
@@ -590,6 +851,9 @@ function setSeparator(separator, config = loadConfig()) {
     throw new Error("separator must be a non-empty string");
   return { config: { ...config, separator }, changed: ["separator"] };
 }
+function setColors(colors, config = loadConfig()) {
+  return { config: { ...config, colors }, changed: ["colors"] };
+}
 function resetStatuslineConfig() {
   return defaultConfig();
 }
@@ -602,7 +866,11 @@ function sampleClaudeInput(cwd = process.cwd()) {
     model: { id: "claude-fable-5[1m]", display_name: "Fable" },
     cost: { total_cost_usd: 12.34, total_duration_ms: 5400000, total_lines_added: 42, total_lines_removed: 7 },
     version: statuslineVersion,
-    session_id: "preview0-0000-0000-0000-000000000000"
+    session_id: "preview0-0000-0000-0000-000000000000",
+    session_name: "preview thread",
+    effort: { level: "high" },
+    thinking: { enabled: true },
+    rate_limits: { five_hour: { used_percentage: 42 } }
   };
 }
 async function previewStatusline(config = loadConfig(), cwd = process.cwd()) {
@@ -658,6 +926,7 @@ usage:
   statusline disable <id...>     disable segments
   statusline order <id...>       set the exact segment order (also defines enabled set)
   statusline separator <str>     set the separator (default " \xB7 ")
+  statusline colors <on|off>     toggle segment colours (default on)
   statusline preview             render with a sample payload from the current directory
   statusline reset               restore default config
   statusline install [claude]    wire into Claude Code (~/.claude/settings.json)
@@ -978,6 +1247,15 @@ order: ${result.config.segments.join(", ") || "(none)"}`);
         console.log(`separator: "${result.config.separator}"`);
         return;
       }
+      case "colors": {
+        const value = args[0];
+        if (value !== "on" && value !== "off")
+          throw new Error("usage: statusline colors <on|off>");
+        const result = setColors(value === "on", loadConfig());
+        saveConfig(result.config);
+        console.log(`colors: ${value}`);
+        return;
+      }
       case "reset": {
         saveConfig(defaultConfig());
         console.log(`reset to defaults (${configPath()})`);

package/dist/config.d.ts

@@ -2,6 +2,8 @@ export interface StatuslineConfig {
     separator: string;
     /** Ordered list of enabled segment ids. */
     segments: string[];
+    /** Colourize segments that ask for it (default on; off when `NO_COLOR` is set). */
+    colors?: boolean;
 }
 export declare function defaultConfig(): StatuslineConfig;
 export declare function configPath(path?: string): string;

package/dist/index.d.ts

@@ -1,11 +1,12 @@
 import { type StatuslineConfig } from "./config.js";
+export { sessionAccount, sessionAccountEmail, sessionConfigDir, sessionStateFile, type SessionAccount, } from "./accounts.js";
 export { defaultConfig, loadConfig, saveConfig, configPath, type StatuslineConfig } from "./config.js";
 export { contextUsage, type ContextUsage } from "./context-window.js";
 export { compactAge, compactDuration, compactNum, money } from "./format.js";
 export { gitBranch, gitProjectName, gitRoot, lastCommitEpoch, trackedLineCount } from "./git.js";
-export { installClaude } from "./install.js";
+export { claudeSettingsPath, installClaude } from "./install.js";
 export { parseClaudeInput } from "./providers/claude.js";
-export type { Segment, StatusContext } from "./providers/types.js";
+export type { Segment, SegmentColor, StatusContext } from "./providers/types.js";
 export { renderLine } from "./render.js";
 export { getSegment, segments } from "./segments/index.js";
 export declare const statuslineVersion: string;
@@ -25,6 +26,7 @@ export declare function enableSegments(ids: string[], config?: StatuslineConfig)
 export declare function disableSegments(ids: string[], config?: StatuslineConfig): ConfigUpdateResult;
 export declare function orderSegments(ids: string[], config?: StatuslineConfig): ConfigUpdateResult;
 export declare function setSeparator(separator: string, config?: StatuslineConfig): ConfigUpdateResult;
+export declare function setColors(colors: boolean, config?: StatuslineConfig): ConfigUpdateResult;
 export declare function resetStatuslineConfig(): StatuslineConfig;
 export declare function renderStatusline(input?: Record<string, unknown>, config?: StatuslineConfig): Promise<string>;
 export declare function sampleClaudeInput(cwd?: string): Record<string, unknown>;