@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/extensions/zentui/custom-value-colors.ts

@@ -0,0 +1,93 @@
+import type { ColorSource, ColorSpec } from "./config";
+import {
+	type CustomVariableColorMode,
+	MAX_CUSTOM_VARIABLE_KEY_CODE_UNITS,
+	sanitizeCustomVariableText,
+} from "./custom-variables";
+import { isSupportedColorSpec, renderStyleForSource, type ThemeLike } from "./style";
+
+export type CustomValueColors = Readonly<Record<string, ColorSpec>>;
+
+// Persistent overrides are independent of the protocol's 16 active values. Reject
+// oversized maps as a whole rather than silently retaining an arbitrary subset.
+const MAX_CUSTOM_VALUE_COLOR_PROPERTIES = 1024;
+const MAX_CUSTOM_VALUE_COLOR_STYLE_CODE_UNITS = 4096;
+const excludedKeys = new Set(["__proto__", "constructor", "prototype"]);
+
+function isPublisherKey(key: string): boolean {
+	return (
+		typeof key === "string" &&
+		key.length > 0 &&
+		key.length <= MAX_CUSTOM_VARIABLE_KEY_CODE_UNITS &&
+		!excludedKeys.has(key) &&
+		!/[\s\x00-\x20\x7f-\x9f]/.test(key)
+	);
+}
+
+function isStyle(value: unknown): value is ColorSpec {
+	return (
+		typeof value === "string" &&
+		value.length <= MAX_CUSTOM_VALUE_COLOR_STYLE_CODE_UNITS &&
+		isSupportedColorSpec(value)
+	);
+}
+
+function emptyColors(): Record<string, ColorSpec> {
+	return Object.create(null) as Record<string, ColorSpec>;
+}
+
+/** Detached sparse data only; accessors and inherited properties never supply styles. */
+export function normalizeCustomValueColors(raw: unknown): CustomValueColors {
+	const colors = emptyColors();
+	try {
+		if (!raw || typeof raw !== "object" || Array.isArray(raw)) return Object.freeze(colors);
+		const keys = Reflect.ownKeys(raw);
+		if (keys.length > MAX_CUSTOM_VALUE_COLOR_PROPERTIES) return Object.freeze(colors);
+		for (const key of keys) {
+			if (typeof key !== "string" || !isPublisherKey(key)) continue;
+			const descriptor = Object.getOwnPropertyDescriptor(raw, key);
+			if (descriptor?.enumerable && "value" in descriptor && isStyle(descriptor.value)) {
+				colors[key] = descriptor.value;
+			}
+		}
+		return Object.freeze(colors);
+	} catch {
+		// Failed reflection (e.g. a revoked Proxy) must not leave a partial palette.
+		return Object.freeze(emptyColors());
+	}
+}
+
+/** Resolve by stable publisher ID, never an alias or prototype lookup. Empty is an override. */
+export function customValueColor(
+	colors: CustomValueColors | undefined,
+	key: string,
+): ColorSpec | undefined {
+	try {
+		if (!colors || typeof colors !== "object" || Array.isArray(colors) || !isPublisherKey(key))
+			return undefined;
+		const descriptor = Object.getOwnPropertyDescriptor(colors, key);
+		return descriptor?.enumerable && "value" in descriptor && isStyle(descriptor.value)
+			? descriptor.value
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function renderCustomValue(options: {
+	key: string;
+	raw: string;
+	colors?: CustomValueColors;
+	mode: CustomVariableColorMode;
+	theme: ThemeLike;
+	source: ColorSource;
+	fallbackStyle: ColorSpec;
+}): string {
+	const { key, raw, colors, mode, theme, source, fallbackStyle } = options;
+	const override = customValueColor(colors, key);
+	// An explicit override replaces all publisher SGR and links, including resets.
+	const text = sanitizeCustomVariableText(raw, override === undefined ? mode : "zentui");
+	if (!text) return "";
+	if (override !== undefined) return renderStyleForSource(theme, source, override, text);
+	return mode === "zentui" ? renderStyleForSource(theme, source, fallbackStyle, text) : text;
+}

package/dist/extensions/pi-zentui/extensions/zentui/custom-variable-demand.ts

@@ -0,0 +1,61 @@
+import {
+	FOOTER_FORMAT_ALIASES,
+	FOOTER_FORMAT_VARIABLES,
+	OPENCODE_FORMAT_VARIABLES,
+	type TemplateVariableConfig,
+	type ZentuiConfig,
+} from "./config";
+import { normalizeTemplateVariables } from "./custom-variable-format";
+import { compiledFooterFormat } from "./footer-format";
+import {
+	minimalistDemandsCustomVariable,
+	minimalistTemplateReferences,
+} from "./minimalist-template";
+
+/** Configuration demand only; callers separately prove current surface ownership. */
+export function editorMetadataReferences(config: ZentuiConfig): ReadonlySet<string> {
+	const editor = config.components.editor;
+	if (!editor.enabled) return new Set();
+	if (editor.style === "minimalist") return minimalistTemplateReferences(editor.styles.minimalist);
+	if (editor.style === "accent-rail") return new Set(editor.codexQuota ? ["codex_quota"] : []);
+	return new Set(compiledFooterFormat(editor.styles[editor.style].metadataFormat).references);
+}
+
+function demands(
+	style: TemplateVariableConfig,
+	references: ReadonlySet<string>,
+	reserved: readonly string[],
+	key?: string,
+): boolean {
+	return Object.entries(normalizeTemplateVariables(style.variables, reserved)).some(
+		([name, target]) => references.has(name) && (key === undefined || key === target),
+	);
+}
+
+export function editorDemandsCustomVariable(config: ZentuiConfig, key?: string): boolean {
+	const editor = config.components.editor;
+	if (!editor.enabled || editor.style === "accent-rail") return false;
+	if (editor.style === "minimalist")
+		return minimalistDemandsCustomVariable(editor.styles.minimalist, key);
+	return demands(
+		editor.styles[editor.style],
+		editorMetadataReferences(config),
+		OPENCODE_FORMAT_VARIABLES,
+		key,
+	);
+}
+
+export function footerDemandsCustomVariable(config: ZentuiConfig, key?: string): boolean {
+	const footer = config.components.footer;
+	if (footer.style !== "starship") return false;
+	const style = footer.styles.starship;
+	const references = new Set(compiledFooterFormat(style.format).references);
+	if (style.responsive)
+		for (const name of compiledFooterFormat(style.compactFormat).references) references.add(name);
+	return demands(
+		style,
+		references,
+		[...FOOTER_FORMAT_VARIABLES, ...Object.keys(FOOTER_FORMAT_ALIASES)],
+		key,
+	);
+}

package/dist/extensions/pi-zentui/extensions/zentui/custom-variable-format.ts

@@ -0,0 +1,80 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { MAX_CUSTOM_VARIABLE_KEY_CODE_UNITS, MAX_CUSTOM_VARIABLES } from "./custom-variables";
+
+/** Owner-local aliases reserve builtins, except the backward-compatible ci alias. */
+export function normalizeTemplateVariables(
+	value: unknown,
+	reserved: readonly string[],
+): Record<string, string> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const excluded = new Set([
+		...reserved,
+		"__proto__",
+		"constructor",
+		"prototype",
+		"fill",
+		"wrap",
+		"wrap_sep",
+		"join_sep",
+		"extensions",
+	]);
+	return Object.fromEntries(
+		Object.entries(value)
+			.filter(
+				([name, key]) =>
+					/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name) &&
+					(!excluded.has(name) || name === "ci") &&
+					typeof key === "string" &&
+					key.length > 0 &&
+					key.length <= MAX_CUSTOM_VARIABLE_KEY_CODE_UNITS &&
+					!/[\s\x00-\x20\x7f-\x9f]/.test(key),
+			)
+			.slice(0, MAX_CUSTOM_VARIABLES),
+	);
+}
+
+/** Internal width-equivalent probes survive packing only when a complete value fits.
+ * Probes are restored before any terminal output; publisher strings are never parsed as probes.
+ */
+export class AtomicTemplateValues {
+	private readonly values = new Map<string, { marker: string; probe: string; text: string }>();
+
+	constructor(values: ReadonlyMap<string, string>, source: readonly string[]) {
+		let candidate = 0xe000;
+		const reserved = [...source, ...values.values()].join("");
+		for (const [key, text] of values) {
+			const width = visibleWidth(text);
+			if (!width) continue;
+			while (candidate <= 0xf8ff && reserved.includes(String.fromCharCode(candidate))) candidate++;
+			if (candidate > 0xf8ff) break;
+			const marker = String.fromCharCode(candidate++);
+			if (visibleWidth(marker) !== 1) continue;
+			this.values.set(key, { marker, probe: marker.repeat(width), text });
+		}
+	}
+
+	resolve(key: string): string {
+		return this.values.get(key)?.probe ?? "";
+	}
+
+	omitted(source: readonly string[], rows: readonly string[]): string[] {
+		const input = source.join("\n");
+		const output = rows.join("\n");
+		return [...this.values]
+			.filter(([, { marker, probe }]) => {
+				const expected = input.split(probe).length - 1;
+				const actual = output.split(probe).length - 1;
+				// Also detect partial values cropped before the final packer source was captured.
+				const cells = output.split(marker).length - 1;
+				return expected !== actual || cells !== actual * probe.length;
+			})
+			.map(([key]) => key);
+	}
+
+	restore(rows: readonly string[]): string[] {
+		return rows.map((row) => {
+			for (const { probe, text } of this.values.values()) row = row.replaceAll(probe, text);
+			return row;
+		});
+	}
+}

package/dist/extensions/pi-zentui/extensions/zentui/custom-variables.ts

@@ -0,0 +1,152 @@
+import type { EventBus } from "@earendil-works/pi-coding-agent";
+import {
+	sanitizeExtensionStatusOriginalText,
+	sanitizeExtensionStatusText,
+} from "./extension-status";
+
+export const ZENTUI_VARIABLE_CAPABILITY_EVENT = "zentui:variable-capability";
+export const ZENTUI_VARIABLE_EVENT = "zentui:variable";
+export const ZENTUI_VARIABLE_PROTOCOL_VERSION = 1;
+
+export const MAX_CUSTOM_VARIABLES = 16;
+export const MAX_CUSTOM_VARIABLE_KEY_CODE_UNITS = 64;
+export const MAX_CUSTOM_VARIABLE_TEXT_CODE_UNITS = 256;
+
+export type CustomVariableCapability = {
+	supported: boolean;
+	active: boolean;
+	key?: string;
+	version?: number;
+};
+
+export type CustomVariableUpdate = {
+	key: string;
+	text?: string;
+};
+
+export type CustomVariableColorMode = "original" | "zentui";
+
+function isKey(value: unknown): value is string {
+	return (
+		typeof value === "string" &&
+		value.length > 0 &&
+		value.length <= MAX_CUSTOM_VARIABLE_KEY_CODE_UNITS
+	);
+}
+
+function eventRecord(value: unknown): Record<string, unknown> | undefined {
+	return value !== null && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+/** Read data only: publisher getters must not run as part of the protocol. */
+function eventField(record: Record<string, unknown>, key: string): unknown {
+	const descriptor = Object.getOwnPropertyDescriptor(record, key);
+	if (descriptor && !("value" in descriptor)) throw new TypeError("Accessor event field");
+	return descriptor?.value;
+}
+
+function variableUpdate(value: unknown): CustomVariableUpdate | undefined {
+	try {
+		const record = eventRecord(value);
+		if (!record) return undefined;
+		const key = eventField(record, "key");
+		const text = eventField(record, "text");
+		if (!isKey(key)) return undefined;
+		if (
+			text !== undefined &&
+			(typeof text !== "string" || text.length > MAX_CUSTOM_VARIABLE_TEXT_CODE_UNITS)
+		)
+			return undefined;
+		return { key, text: text as string | undefined };
+	} catch {
+		return undefined;
+	}
+}
+
+/** Session-scoped, surface-neutral values; keys are package-qualified by publisher convention. */
+export class CustomVariables {
+	private readonly values = new Map<string, string>();
+
+	constructor(
+		events: EventBus | undefined,
+		private readonly isActive: (key?: string) => boolean,
+		private readonly onChange: () => void,
+	) {
+		if (!events) return;
+		// Registration lasts for the extension runtime, not an editor factory's lifetime.
+		events.on(ZENTUI_VARIABLE_CAPABILITY_EVENT, (value) => {
+			try {
+				const capability = eventRecord(value);
+				if (!capability) return;
+				const key = eventField(capability, "key");
+				if (key !== undefined && !isKey(key)) return;
+				const active = this.isActive(key);
+				// Define data properties rather than invoking publisher setters.
+				Object.defineProperties(capability, {
+					supported: { value: true, writable: true, enumerable: true, configurable: true },
+					active: { value: active, writable: true, enumerable: true, configurable: true },
+					version: {
+						value: ZENTUI_VARIABLE_PROTOCOL_VERSION,
+						writable: true,
+						enumerable: true,
+						configurable: true,
+					},
+				});
+			} catch {
+				// Malformed or immutable probes must not break the publisher's event dispatch.
+			}
+		});
+		events.on(ZENTUI_VARIABLE_EVENT, (value) => {
+			const update = variableUpdate(value);
+			if (!update) return;
+			if (update.text === undefined || update.text.length === 0) {
+				if (!this.values.delete(update.key)) return;
+			} else {
+				if (!this.isActive(update.key)) return;
+				if (!this.values.has(update.key) && this.values.size >= MAX_CUSTOM_VARIABLES) return;
+				if (this.values.get(update.key) === update.text) return;
+				this.values.set(update.key, update.text);
+			}
+			this.onChange();
+		});
+	}
+
+	/** Detached raw snapshot in locale-independent key order; sanitize only at the consumer. */
+	snapshot(): ReadonlyMap<string, string> {
+		return new Map(
+			[...this.values].sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)),
+		);
+	}
+
+	clear(): void {
+		if (this.values.size === 0) return;
+		this.values.clear();
+		this.onChange();
+	}
+
+	/** Evict only keys no longer demanded by any independently owned consumer. */
+	reconcile(): void {
+		let changed = false;
+		for (const key of this.values.keys()) {
+			if (!this.isActive(key)) {
+				this.values.delete(key);
+				changed = true;
+			}
+		}
+		if (changed) this.onChange();
+	}
+}
+
+/** A safe single-line value, closing publisher links and styles before adjacent frame content. */
+export function sanitizeCustomVariableText(
+	value: string,
+	colorMode: CustomVariableColorMode = "original",
+): string {
+	if (colorMode === "zentui") return sanitizeExtensionStatusText(value);
+	const text = sanitizeExtensionStatusOriginalText(value);
+	let lastSgr: string | undefined;
+	for (const match of text.matchAll(/\x1b\[[0-9;:]*m/g)) lastSgr = match[0];
+	return lastSgr && lastSgr !== "\x1b[0m" && lastSgr !== "\x1b[m" ? `${text}\x1b[0m` : text;
+}

package/dist/extensions/pi-zentui/extensions/zentui/editor-metadata-format.ts

@@ -1,21 +1,37 @@
+import { stripVTControlCharacters } from "node:util";
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { ZentuiConfig } from "./config";
-import { type FormatToken, parseFooterFormat } from "./footer-format";
+import type { CodexQuota } from "./codex-quota";
+import { codexQuotaText, renderCodexQuota } from "./codex-quota-display";
+import { componentColor, editorShellColor } from "./component-colors";
+import { OPENCODE_FORMAT_VARIABLES, type ZentuiConfig } from "./config";
+import { renderCustomValue } from "./custom-value-colors";
+import { normalizeTemplateVariables } from "./custom-variable-format";
+import {
+	parseFooterFormat,
+	type ReadonlyFormatToken,
+	renderJoinedTokenFields,
+} from "./footer-format";
 import { buildSessionTokenLabel, formatCacheHitRate, formatContextPercentLabel } from "./format";
+import { type HostTemplateValues, isHostTemplateVariable } from "./host-template-values";
+import { liveMetadataColor } from "./live-metadata-display";
 import { EDITOR_ACCENT_FALLBACK, renderStyleForSourceOrFallback, safeThemeFg } from "./style";
 
 export type EditorMetadataValues = {
+	codexQuota?: CodexQuota;
 	model: string;
 	modelId: string;
 	modelName: string;
 	provider: string;
 	thinking: string;
 	sessionName: string;
+	fastMode?: string;
 	contextPercent?: number;
 	contextWindow?: number;
 	inputTokens?: number;
 	outputTokens?: number;
 	cacheHitRate?: number;
+	customVariables?: ReadonlyMap<string, string>;
+	hostTemplateValues?: HostTemplateValues;
 };
 
 type RenderedTokens = {
@@ -135,23 +151,38 @@ export function sanitizeEditorMetadataText(value: string): string {
 function editorThinkingStyle(config: ZentuiConfig, level: string): string | undefined {
 	switch (level.toLowerCase()) {
 		case "minimal":
-			return config.colors.editorThinkingMinimal ?? config.colors.editorThinking;
+			return (
+				componentColor(config, "editor", "thinkingMinimal") ??
+				componentColor(config, "editor", "thinking")
+			);
 		case "low":
-			return config.colors.editorThinkingLow ?? config.colors.editorThinking;
+			return (
+				componentColor(config, "editor", "thinkingLow") ??
+				componentColor(config, "editor", "thinking")
+			);
 		case "medium":
-			return config.colors.editorThinkingMedium ?? config.colors.editorThinking;
+			return (
+				componentColor(config, "editor", "thinkingMedium") ??
+				componentColor(config, "editor", "thinking")
+			);
 		case "high":
-			return config.colors.editorThinkingHigh ?? config.colors.editorThinking;
+			return (
+				componentColor(config, "editor", "thinkingHigh") ??
+				componentColor(config, "editor", "thinking")
+			);
 		case "xhigh":
-			return config.colors.editorThinkingXhigh ?? config.colors.editorThinking;
+			return (
+				componentColor(config, "editor", "thinkingXhigh") ??
+				componentColor(config, "editor", "thinking")
+			);
 		case "max":
 			return (
-				config.colors.editorThinkingMax ??
-				config.colors.editorThinkingXhigh ??
-				config.colors.editorThinking
+				componentColor(config, "editor", "thinkingMax") ??
+				componentColor(config, "editor", "thinkingXhigh") ??
+				componentColor(config, "editor", "thinking")
 			);
 		default:
-			return config.colors.editorThinking;
+			return componentColor(config, "editor", "thinking");
 	}
 }
 
@@ -160,7 +191,54 @@ function renderVariable(
 	values: EditorMetadataValues,
 	uiTheme: Theme,
 	config: ZentuiConfig,
+	shellMode = false,
 ): { plain: string; styled: string } {
+	const editor = config.components.editor;
+	const style =
+		editor.style === "opencode-copy-friendly"
+			? editor.styles[editor.style]
+			: editor.styles.opencode;
+	const aliases = normalizeTemplateVariables(style.variables, OPENCODE_FORMAT_VARIABLES);
+	if (isHostTemplateVariable(name) && !Object.hasOwn(aliases, name)) {
+		const plain = sanitizeEditorMetadataText(values.hostTemplateValues?.[name] ?? "");
+		return {
+			plain,
+			styled: plain
+				? renderStyleForSourceOrFallback(
+						uiTheme,
+						editor.colorSource,
+						liveMetadataColor(config, "editor", name) ?? componentColor(config, "editor", "border"),
+						"border",
+						plain,
+					)
+				: "",
+		};
+	}
+	if (Object.hasOwn(aliases, name)) {
+		const raw = values.customVariables?.get(aliases[name]) ?? "";
+		const text = renderCustomValue({
+			key: aliases[name],
+			raw,
+			colors: editor.customValueColors,
+			mode: style.extensionColorMode ?? "original",
+			theme: uiTheme,
+			source: editor.colorSource,
+			fallbackStyle: config.colors.extensionStatus,
+		});
+		const plain = sanitizeEditorMetadataText(text);
+		return {
+			plain,
+			styled: plain ? text : "",
+		};
+	}
+	if (name === "codex_quota") {
+		const styled = renderCodexQuota(values.codexQuota, uiTheme, config, "editor");
+		return { plain: styled ? codexQuotaText(values.codexQuota) : "", styled };
+	}
+	if (name === "fast_mode") {
+		const plain = sanitizeEditorMetadataText(values.fastMode ?? "");
+		return { plain, styled: plain ? safeThemeFg(uiTheme, "accent", plain) : "" };
+	}
 	const colorSource = config.components.editor.colorSource;
 	const thinking = values.thinking.toLowerCase() === "off" ? "" : values.thinking;
 	const raw =
@@ -190,13 +268,19 @@ function renderVariable(
 	if (!plain) return { plain: "", styled: "" };
 
 	if (name === "model" || name === "model_id" || name === "model_name") {
+		const chrome = shellMode
+			? editorShellColor(config)
+			: {
+					color: componentColor(config, "editor", "model"),
+					fallback: EDITOR_ACCENT_FALLBACK,
+				};
 		return {
 			plain,
 			styled: renderStyleForSourceOrFallback(
 				uiTheme,
 				colorSource,
-				config.colors.editorModel,
-				EDITOR_ACCENT_FALLBACK,
+				chrome.color,
+				chrome.fallback,
 				plain,
 			),
 		};
@@ -207,7 +291,7 @@ function renderVariable(
 			styled: renderStyleForSourceOrFallback(
 				uiTheme,
 				colorSource,
-				config.colors.editorProvider,
+				componentColor(config, "editor", "provider"),
 				"text",
 				plain,
 			),
@@ -232,10 +316,37 @@ function renderVariable(
 }
 
 function renderTokens(
-	tokens: FormatToken[],
+	tokens: readonly ReadonlyFormatToken[],
+	values: EditorMetadataValues,
+	uiTheme: Theme,
+	config: ZentuiConfig,
+	shellMode = false,
+): RenderedTokens {
+	const hasJoin = tokens.some((token) => token.kind === "var" && token.name === "join_sep");
+	let hasDynamic = false;
+	let hasNonEmptyDynamic = false;
+	const styled = renderJoinedTokenFields(
+		tokens,
+		(field) => {
+			const rendered = renderTokenField(field, values, uiTheme, config, shellMode);
+			hasDynamic ||= rendered.hasDynamic;
+			if (!hasJoin || stripVTControlCharacters(rendered.styled).trim())
+				hasNonEmptyDynamic ||= rendered.hasNonEmptyDynamic;
+			return rendered.styled;
+		},
+		() => safeThemeFg(uiTheme, "border", " · "),
+	);
+	// An empty join cannot keep an enclosing optional group alive.
+	if (hasJoin && !stripVTControlCharacters(styled).trim()) hasDynamic = true;
+	return { styled, hasDynamic, hasNonEmptyDynamic };
+}
+
+function renderTokenField(
+	tokens: readonly ReadonlyFormatToken[],
 	values: EditorMetadataValues,
 	uiTheme: Theme,
 	config: ZentuiConfig,
+	shellMode = false,
 ): RenderedTokens {
 	let styled = "";
 	let hasDynamic = false;
@@ -253,13 +364,13 @@ function renderTokens(
 		}
 		if (token.kind === "var") {
 			hasDynamic = true;
-			const rendered = renderVariable(token.name, values, uiTheme, config);
+			const rendered = renderVariable(token.name, values, uiTheme, config, shellMode);
 			styled += rendered.styled;
 			if (rendered.plain) hasNonEmptyDynamic = true;
 			continue;
 		}
 
-		const rendered = renderTokens(token.tokens, values, uiTheme, config);
+		const rendered = renderTokens(token.tokens, values, uiTheme, config, shellMode);
 		const visible = !rendered.hasDynamic || rendered.hasNonEmptyDynamic;
 		hasDynamic = true;
 		if (visible) {
@@ -276,6 +387,7 @@ export function renderEditorMetadataFormatSplit(
 	values: EditorMetadataValues,
 	uiTheme: Theme,
 	config: ZentuiConfig,
+	shellMode = false,
 ): EditorMetadataZones {
 	const tokens = parseFooterFormat(sanitizeEditorMetadataText(format));
 	const fillIndices: number[] = [];
@@ -287,22 +399,23 @@ export function renderEditorMetadataFormatSplit(
 	const second = fillIndices[1];
 	if (first === undefined) {
 		return {
-			left: renderTokens(tokens, values, uiTheme, config).styled,
+			left: renderTokens(tokens, values, uiTheme, config, shellMode).styled,
 			middle: "",
 			right: "",
 		};
 	}
 	if (second === undefined) {
 		return {
-			left: renderTokens(tokens.slice(0, first), values, uiTheme, config).styled,
+			left: renderTokens(tokens.slice(0, first), values, uiTheme, config, shellMode).styled,
 			middle: "",
-			right: renderTokens(tokens.slice(first + 1), values, uiTheme, config).styled,
+			right: renderTokens(tokens.slice(first + 1), values, uiTheme, config, shellMode).styled,
 		};
 	}
 	return {
-		left: renderTokens(tokens.slice(0, first), values, uiTheme, config).styled,
-		middle: renderTokens(tokens.slice(first + 1, second), values, uiTheme, config).styled,
-		right: renderTokens(tokens.slice(second + 1), values, uiTheme, config).styled,
+		left: renderTokens(tokens.slice(0, first), values, uiTheme, config, shellMode).styled,
+		middle: renderTokens(tokens.slice(first + 1, second), values, uiTheme, config, shellMode)
+			.styled,
+		right: renderTokens(tokens.slice(second + 1), values, uiTheme, config, shellMode).styled,
 	};
 }
 
@@ -311,11 +424,13 @@ export function renderEditorMetadataFormat(
 	values: EditorMetadataValues,
 	uiTheme: Theme,
 	config: ZentuiConfig,
+	shellMode = false,
 ): string {
 	return renderTokens(
 		parseFooterFormat(sanitizeEditorMetadataText(format)),
 		values,
 		uiTheme,
 		config,
+		shellMode,
 	).styled;
 }