thaddeus 1.0.26 → 1.0.28

package/src/utils/localInstaller.js

@@ -0,0 +1,130 @@
+/**
+ * Utilities for handling local installation
+ */
+import { access, chmod, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { saveGlobalConfig } from './config.js';
+import { getClaudeConfigHomeDir } from './envUtils.js';
+import { getErrnoCode } from './errors.js';
+import { execFileNoThrowWithCwd } from './execFileNoThrow.js';
+import { getFsImplementation } from './fsOperations.js';
+import { logError } from './log.js';
+import { jsonStringify } from './slowOperations.js';
+// Lazy getters: getClaudeConfigHomeDir() is memoized and reads process.env.
+// Evaluating at module scope would capture the value before entrypoints like
+// hfi.tsx get a chance to set CLAUDE_CONFIG_DIR in main(), and would also
+// populate the memoize cache with that stale value for all 150+ other callers.
+function getLocalInstallDir() {
+    return join(getClaudeConfigHomeDir(), 'local');
+}
+export function getLocalClaudePath() {
+    return join(getLocalInstallDir(), 'claude');
+}
+/**
+ * Check if we're running from our managed local installation
+ */
+export function isRunningFromLocalInstallation() {
+    const execPath = process.argv[1] || '';
+    return execPath.includes('/.claude/local/node_modules/');
+}
+/**
+ * Write `content` to `path` only if the file does not already exist.
+ * Uses O_EXCL ('wx') for atomic create-if-missing.
+ */
+async function writeIfMissing(path, content, mode) {
+    try {
+        await writeFile(path, content, { encoding: 'utf8', flag: 'wx', mode });
+        return true;
+    }
+    catch (e) {
+        if (getErrnoCode(e) === 'EEXIST')
+            return false;
+        throw e;
+    }
+}
+/**
+ * Ensure the local package environment is set up
+ * Creates the directory, package.json, and wrapper script
+ */
+export async function ensureLocalPackageEnvironment() {
+    try {
+        const localInstallDir = getLocalInstallDir();
+        // Create installation directory (recursive, idempotent)
+        await getFsImplementation().mkdir(localInstallDir);
+        // Create package.json if it doesn't exist
+        await writeIfMissing(join(localInstallDir, 'package.json'), jsonStringify({ name: 'claude-local', version: '0.0.1', private: true }, null, 2));
+        // Create the wrapper script if it doesn't exist
+        const wrapperPath = join(localInstallDir, 'claude');
+        const created = await writeIfMissing(wrapperPath, `#!/bin/sh\nexec "${localInstallDir}/node_modules/.bin/claude" "$@"`, 0o755);
+        if (created) {
+            // Mode in writeFile is masked by umask; chmod to ensure executable bit.
+            await chmod(wrapperPath, 0o755);
+        }
+        return true;
+    }
+    catch (error) {
+        logError(error);
+        return false;
+    }
+}
+/**
+ * Install or update Claude CLI package in the local directory
+ * @param channel - Release channel to use (latest or stable)
+ * @param specificVersion - Optional specific version to install (overrides channel)
+ */
+export async function installOrUpdateClaudePackage(channel, specificVersion) {
+    try {
+        // First ensure the environment is set up
+        if (!(await ensureLocalPackageEnvironment())) {
+            return 'install_failed';
+        }
+        // Use specific version if provided, otherwise use channel tag
+        const versionSpec = specificVersion
+            ? specificVersion
+            : channel === 'stable'
+                ? 'stable'
+                : 'latest';
+        const result = await execFileNoThrowWithCwd('npm', ['install', `${MACRO.PACKAGE_URL}@${versionSpec}`], { cwd: getLocalInstallDir(), maxBuffer: 1000000 });
+        if (result.code !== 0) {
+            const error = new Error(`Failed to install Thaddeus CLI package: ${result.stderr}`);
+            logError(error);
+            return result.code === 190 ? 'in_progress' : 'install_failed';
+        }
+        // Set installMethod to 'local' to prevent npm permission warnings
+        saveGlobalConfig(current => ({
+            ...current,
+            installMethod: 'local',
+        }));
+        return 'success';
+    }
+    catch (error) {
+        logError(error);
+        return 'install_failed';
+    }
+}
+/**
+ * Check if local installation exists.
+ * Pure existence probe — callers use this to choose update path / UI hints.
+ */
+export async function localInstallationExists() {
+    try {
+        await access(join(getLocalInstallDir(), 'node_modules', '.bin', 'claude'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get shell type to determine appropriate path setup
+ */
+export function getShellType() {
+    const shellPath = process.env.SHELL || '';
+    if (shellPath.includes('zsh'))
+        return 'zsh';
+    if (shellPath.includes('bash'))
+        return 'bash';
+    if (shellPath.includes('fish'))
+        return 'fish';
+    return 'unknown';
+}

package/src/utils/lockfile.js

@@ -0,0 +1,30 @@
+/**
+ * Lazy accessor for proper-lockfile.
+ *
+ * proper-lockfile depends on graceful-fs, which monkey-patches every fs
+ * method on first require (~8ms). Static imports of proper-lockfile pull this
+ * cost into the startup path even when no locking happens (e.g. `--help`).
+ *
+ * Import this module instead of `proper-lockfile` directly. The underlying
+ * package is only loaded the first time a lock function is actually called.
+ */
+let _lockfile;
+function getLockfile() {
+    if (!_lockfile) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        _lockfile = require('proper-lockfile');
+    }
+    return _lockfile;
+}
+export function lock(file, options) {
+    return getLockfile().lock(file, options);
+}
+export function lockSync(file, options) {
+    return getLockfile().lockSync(file, options);
+}
+export function unlock(file, options) {
+    return getLockfile().unlock(file, options);
+}
+export function check(file, options) {
+    return getLockfile().check(file, options);
+}

package/src/utils/log.js

@@ -0,0 +1,280 @@
+import { feature } from 'bun:bundle';
+import { readdir, readFile, stat } from 'fs/promises';
+import memoize from 'lodash-es/memoize.js';
+import { join } from 'path';
+import { setLastAPIRequest, setLastAPIRequestMessages, } from '../bootstrap/state.js';
+import { TICK_TAG } from '../constants/xml.js';
+import { sortLogs, } from '../types/logs.js';
+import { CACHE_PATHS } from './cachePaths.js';
+import { stripDisplayTags, stripDisplayTagsAllowEmpty } from './displayTags.js';
+import { isEnvTruthy } from './envUtils.js';
+import { toError } from './errors.js';
+import { isEssentialTrafficOnly } from './privacyLevel.js';
+import { jsonParse } from './slowOperations.js';
+/**
+ * Gets the display title for a log/session with fallback logic.
+ * Skips firstPrompt if it starts with a tick/goal tag (autonomous mode auto-prompt).
+ * Strips display-unfriendly tags (like <ide_opened_file>) from the result.
+ * Falls back to a truncated session ID when no other title is available.
+ */
+export function getLogDisplayTitle(log, defaultTitle) {
+    // Skip firstPrompt if it's a tick/goal message (autonomous mode auto-prompt)
+    const isAutonomousPrompt = log.firstPrompt?.startsWith(`<${TICK_TAG}>`);
+    // Strip display-unfriendly tags (command-name, ide_opened_file, etc.) early
+    // so that command-only prompts (e.g. /clear) become empty and fall through
+    // to the next fallback instead of showing raw XML tags.
+    // Note: stripDisplayTags returns the original when stripping yields empty,
+    // so we call stripDisplayTagsAllowEmpty to detect command-only prompts.
+    const strippedFirstPrompt = log.firstPrompt
+        ? stripDisplayTagsAllowEmpty(log.firstPrompt)
+        : '';
+    const useFirstPrompt = strippedFirstPrompt && !isAutonomousPrompt;
+    const title = log.agentName ||
+        log.customTitle ||
+        log.summary ||
+        (useFirstPrompt ? strippedFirstPrompt : undefined) ||
+        defaultTitle ||
+        // For autonomous sessions without other context, show a meaningful label
+        (isAutonomousPrompt ? 'Autonomous session' : undefined) ||
+        // Fall back to truncated session ID for lite logs with no metadata
+        (log.sessionId ? log.sessionId.slice(0, 8) : '') ||
+        '';
+    // Strip display-unfriendly tags (like <ide_opened_file>) for cleaner titles
+    return stripDisplayTags(title).trim();
+}
+export function dateToFilename(date) {
+    return date.toISOString().replace(/[:.]/g, '-');
+}
+// In-memory error log for recent errors
+// Moved from bootstrap/state.ts to break import cycle
+const MAX_IN_MEMORY_ERRORS = 100;
+let inMemoryErrorLog = [];
+function addToInMemoryErrorLog(errorInfo) {
+    if (inMemoryErrorLog.length >= MAX_IN_MEMORY_ERRORS) {
+        inMemoryErrorLog.shift(); // Remove oldest error
+    }
+    inMemoryErrorLog.push(errorInfo);
+}
+const errorQueue = [];
+// Sink - initialized during app startup
+let errorLogSink = null;
+/**
+ * Attach the error log sink that will receive all error events.
+ * Queued events are drained immediately to ensure no errors are lost.
+ *
+ * Idempotent: if a sink is already attached, this is a no-op. This allows
+ * calling from both the preAction hook (for subcommands) and setup() (for
+ * the default command) without coordination.
+ */
+export function attachErrorLogSink(newSink) {
+    if (errorLogSink !== null) {
+        return;
+    }
+    errorLogSink = newSink;
+    // Drain the queue immediately - errors should not be delayed
+    if (errorQueue.length > 0) {
+        const queuedEvents = [...errorQueue];
+        errorQueue.length = 0;
+        for (const event of queuedEvents) {
+            switch (event.type) {
+                case 'error':
+                    errorLogSink.logError(event.error);
+                    break;
+                case 'mcpError':
+                    errorLogSink.logMCPError(event.serverName, event.error);
+                    break;
+                case 'mcpDebug':
+                    errorLogSink.logMCPDebug(event.serverName, event.message);
+                    break;
+            }
+        }
+    }
+}
+/**
+ * Logs an error to multiple destinations for debugging and monitoring.
+ *
+ * This function logs errors to:
+ * - Debug logs (visible via `claude --debug` or `tail -f ~/.claude/debug/latest`)
+ * - In-memory error log (accessible via `getInMemoryErrors()`, useful for including
+ *   in bug reports or displaying recent errors to users)
+ * - Persistent error log file (only for internal 'ant' users, stored in ~/.claude/errors/)
+ *
+ * Usage:
+ * ```ts
+ * logError(new Error('Failed to connect'))
+ * ```
+ *
+ * To view errors:
+ * - Debug: Run `claude --debug` or `tail -f ~/.claude/debug/latest`
+ * - In-memory: Call `getInMemoryErrors()` to get recent errors for the current session
+ */
+const isHardFailMode = memoize(() => {
+    return process.argv.includes('--hard-fail');
+});
+export function logError(error) {
+    const err = toError(error);
+    if (feature('HARD_FAIL') && isHardFailMode()) {
+        // biome-ignore lint/suspicious/noConsole:: intentional crash output
+        console.error('[HARD FAIL] logError called with:', err.stack || err.message);
+        // eslint-disable-next-line custom-rules/no-process-exit
+        process.exit(1);
+    }
+    try {
+        // Check if error reporting should be disabled
+        if (
+        // Cloud providers (Bedrock/Vertex/Foundry) always disable features
+        isEnvTruthy(process.env.THADDEUS_USE_BEDROCK) ||
+            isEnvTruthy(process.env.THADDEUS_USE_VERTEX) ||
+            isEnvTruthy(process.env.THADDEUS_USE_FOUNDRY) ||
+            process.env.DISABLE_ERROR_REPORTING ||
+            isEssentialTrafficOnly()) {
+            return;
+        }
+        const errorStr = err.stack || err.message;
+        const errorInfo = {
+            error: errorStr,
+            timestamp: new Date().toISOString(),
+        };
+        // Always add to in-memory log (no dependencies needed)
+        addToInMemoryErrorLog(errorInfo);
+        // If sink not attached, queue the event
+        if (errorLogSink === null) {
+            errorQueue.push({ type: 'error', error: err });
+            return;
+        }
+        errorLogSink.logError(err);
+    }
+    catch {
+        // pass
+    }
+}
+export function getInMemoryErrors() {
+    return [...inMemoryErrorLog];
+}
+/**
+ * Loads the list of error logs
+ * @returns List of error logs sorted by date
+ */
+export function loadErrorLogs() {
+    return loadLogList(CACHE_PATHS.errors());
+}
+/**
+ * Gets an error log by its index
+ * @param index Index in the sorted list of logs (0-based)
+ * @returns Log data or null if not found
+ */
+export async function getErrorLogByIndex(index) {
+    const logs = await loadErrorLogs();
+    return logs[index] || null;
+}
+/**
+ * Internal function to load and process logs from a specified path
+ * @param path Directory containing logs
+ * @returns Array of logs sorted by date
+ * @private
+ */
+async function loadLogList(path) {
+    let files;
+    try {
+        files = await readdir(path, { withFileTypes: true });
+    }
+    catch {
+        logError(new Error(`No logs found at ${path}`));
+        return [];
+    }
+    const logData = await Promise.all(files.map(async (file, i) => {
+        const fullPath = join(path, file.name);
+        const content = await readFile(fullPath, { encoding: 'utf8' });
+        const messages = jsonParse(content);
+        const firstMessage = messages[0];
+        const lastMessage = messages[messages.length - 1];
+        const firstPrompt = firstMessage?.type === 'user' &&
+            typeof firstMessage?.message?.content === 'string'
+            ? firstMessage?.message?.content
+            : 'No prompt';
+        // For new random filenames, we'll get stats from the file itself
+        const fileStats = await stat(fullPath);
+        // Check if it's a sidechain by looking at filename
+        const isSidechain = fullPath.includes('sidechain');
+        // For new files, use the file modified time as date
+        const date = dateToFilename(fileStats.mtime);
+        return {
+            date,
+            fullPath,
+            messages,
+            value: i, // hack: overwritten after sorting, right below this
+            created: parseISOString(firstMessage?.timestamp || date),
+            modified: lastMessage?.timestamp
+                ? parseISOString(lastMessage.timestamp)
+                : parseISOString(date),
+            firstPrompt: firstPrompt.split('\n')[0]?.slice(0, 50) +
+                (firstPrompt.length > 50 ? '…' : '') || 'No prompt',
+            messageCount: messages.length,
+            isSidechain,
+        };
+    }));
+    return sortLogs(logData.filter(_ => _ !== null)).map((_, i) => ({
+        ..._,
+        value: i,
+    }));
+}
+function parseISOString(s) {
+    const b = s.split(/\D+/);
+    return new Date(Date.UTC(parseInt(b[0], 10), parseInt(b[1], 10) - 1, parseInt(b[2], 10), parseInt(b[3], 10), parseInt(b[4], 10), parseInt(b[5], 10), parseInt(b[6], 10)));
+}
+export function logMCPError(serverName, error) {
+    try {
+        // If sink not attached, queue the event
+        if (errorLogSink === null) {
+            errorQueue.push({ type: 'mcpError', serverName, error });
+            return;
+        }
+        errorLogSink.logMCPError(serverName, error);
+    }
+    catch {
+        // Silently fail
+    }
+}
+export function logMCPDebug(serverName, message) {
+    try {
+        // If sink not attached, queue the event
+        if (errorLogSink === null) {
+            errorQueue.push({ type: 'mcpDebug', serverName, message });
+            return;
+        }
+        errorLogSink.logMCPDebug(serverName, message);
+    }
+    catch {
+        // Silently fail
+    }
+}
+/**
+ * Captures the last API request for inclusion in bug reports.
+ */
+export function captureAPIRequest(params, querySource) {
+    // startsWith, not exact match — users with non-default output styles get
+    // variants like 'repl_main_thread:outputStyle:Explanatory' (querySource.ts).
+    if (!querySource || !querySource.startsWith('repl_main_thread')) {
+        return;
+    }
+    // Store params WITHOUT messages to avoid retaining the entire conversation
+    // for all users. Messages are already persisted to the transcript file and
+    // available via React state.
+    const { messages, ...paramsWithoutMessages } = params;
+    setLastAPIRequest(paramsWithoutMessages);
+    // For ant users only: also keep a reference to the final messages array so
+    // /share's serialized_conversation.json captures the exact post-compaction,
+    // THADDEUS.md-injected payload the API received. Overwritten each turn;
+    // dumpPrompts.ts already holds 5 full request bodies for ants, so this is
+    // not a new retention class.
+    setLastAPIRequestMessages(process.env.USER_TYPE === 'ant' ? messages : null);
+}
+/**
+ * Reset error log state for testing purposes only.
+ * @internal
+ */
+export function _resetErrorLogForTesting() {
+    errorLogSink = null;
+    errorQueue.length = 0;
+    inMemoryErrorLog = [];
+}

package/src/utils/logoV2Utils.js

@@ -0,0 +1,256 @@
+import { getDirectConnectServerUrl, getSessionId } from '../bootstrap/state.js';
+import { stringWidth } from '../ink/stringWidth.js';
+import { getSubscriptionName, isClaudeAISubscriber } from './auth.js';
+import { getCwd } from './cwd.js';
+import { getDisplayPath } from './file.js';
+import { truncate, truncateToWidth, truncateToWidthNoEllipsis, } from './format.js';
+import { getStoredChangelogFromMemory, parseChangelog } from './releaseNotes.js';
+import { gt } from './semver.js';
+import { loadMessageLogs } from './sessionStorage.js';
+import { getInitialSettings } from './settings/settings.js';
+// Layout constants
+const MAX_LEFT_WIDTH = 50;
+const MAX_USERNAME_LENGTH = 20;
+const BORDER_PADDING = 4;
+const DIVIDER_WIDTH = 1;
+const CONTENT_PADDING = 2;
+/**
+ * Determines the layout mode based on terminal width
+ */
+export function getLayoutMode(columns) {
+    if (columns >= 70)
+        return 'horizontal';
+    return 'compact';
+}
+/**
+ * Calculates layout dimensions for the LogoV2 component
+ */
+export function calculateLayoutDimensions(columns, layoutMode, optimalLeftWidth) {
+    if (layoutMode === 'horizontal') {
+        const leftWidth = optimalLeftWidth;
+        const usedSpace = BORDER_PADDING + CONTENT_PADDING + DIVIDER_WIDTH + leftWidth;
+        const availableForRight = columns - usedSpace;
+        let rightWidth = Math.max(30, availableForRight);
+        const totalWidth = Math.min(leftWidth + rightWidth + DIVIDER_WIDTH + CONTENT_PADDING, columns - BORDER_PADDING);
+        // Recalculate right width if we had to cap the total
+        if (totalWidth < leftWidth + rightWidth + DIVIDER_WIDTH + CONTENT_PADDING) {
+            rightWidth = totalWidth - leftWidth - DIVIDER_WIDTH - CONTENT_PADDING;
+        }
+        return { leftWidth, rightWidth, totalWidth };
+    }
+    // Vertical mode
+    const totalWidth = Math.min(columns - BORDER_PADDING, MAX_LEFT_WIDTH + 20);
+    return {
+        leftWidth: totalWidth,
+        rightWidth: totalWidth,
+        totalWidth,
+    };
+}
+/**
+ * Calculates optimal left panel width based on content
+ */
+export function calculateOptimalLeftWidth(welcomeMessage, truncatedCwd, modelLine) {
+    const contentWidth = Math.max(stringWidth(welcomeMessage), stringWidth(truncatedCwd), stringWidth(modelLine), 20);
+    return Math.min(contentWidth + 4, MAX_LEFT_WIDTH); // +4 for padding
+}
+/**
+ * Formats the welcome message based on username
+ */
+export function formatWelcomeMessage(username) {
+    if (!username || username.length > MAX_USERNAME_LENGTH) {
+        return 'Welcome back!';
+    }
+    return `Welcome back ${username}!`;
+}
+/**
+ * Truncates a path in the middle if it's too long.
+ * Width-aware: uses stringWidth() for correct CJK/emoji measurement.
+ */
+export function truncatePath(path, maxLength) {
+    if (stringWidth(path) <= maxLength)
+        return path;
+    const separator = '/';
+    const ellipsis = '…';
+    const ellipsisWidth = 1; // '…' is always 1 column
+    const separatorWidth = 1;
+    const parts = path.split(separator);
+    const first = parts[0] || '';
+    const last = parts[parts.length - 1] || '';
+    const firstWidth = stringWidth(first);
+    const lastWidth = stringWidth(last);
+    // Only one part, so show as much of it as we can
+    if (parts.length === 1) {
+        return truncateToWidth(path, maxLength);
+    }
+    // We don't have enough space to show the last part, so truncate it
+    // But since firstPart is empty (unix) we don't want the extra ellipsis
+    if (first === '' && ellipsisWidth + separatorWidth + lastWidth >= maxLength) {
+        return `${separator}${truncateToWidth(last, Math.max(1, maxLength - separatorWidth))}`;
+    }
+    // We have a first part so let's show the ellipsis and truncate last part
+    if (first !== '' &&
+        ellipsisWidth * 2 + separatorWidth + lastWidth >= maxLength) {
+        return `${ellipsis}${separator}${truncateToWidth(last, Math.max(1, maxLength - ellipsisWidth - separatorWidth))}`;
+    }
+    // Truncate first and leave last
+    if (parts.length === 2) {
+        const availableForFirst = maxLength - ellipsisWidth - separatorWidth - lastWidth;
+        return `${truncateToWidthNoEllipsis(first, availableForFirst)}${ellipsis}${separator}${last}`;
+    }
+    // Now we start removing middle parts
+    let available = maxLength - firstWidth - lastWidth - ellipsisWidth - 2 * separatorWidth;
+    // Just the first and last are too long, so truncate first
+    if (available <= 0) {
+        const availableForFirst = Math.max(0, maxLength - lastWidth - ellipsisWidth - 2 * separatorWidth);
+        const truncatedFirst = truncateToWidthNoEllipsis(first, availableForFirst);
+        return `${truncatedFirst}${separator}${ellipsis}${separator}${last}`;
+    }
+    // Try to keep as many middle parts as possible
+    const middleParts = [];
+    for (let i = parts.length - 2; i > 0; i--) {
+        const part = parts[i];
+        if (part && stringWidth(part) + separatorWidth <= available) {
+            middleParts.unshift(part);
+            available -= stringWidth(part) + separatorWidth;
+        }
+        else {
+            break;
+        }
+    }
+    if (middleParts.length === 0) {
+        return `${first}${separator}${ellipsis}${separator}${last}`;
+    }
+    return `${first}${separator}${ellipsis}${separator}${middleParts.join(separator)}${separator}${last}`;
+}
+// Simple cache for preloaded activity
+let cachedActivity = [];
+let cachePromise = null;
+/**
+ * Preloads recent conversations for display in Logo v2
+ */
+export async function getRecentActivity() {
+    // Return existing promise if already loading
+    if (cachePromise) {
+        return cachePromise;
+    }
+    const currentSessionId = getSessionId();
+    cachePromise = loadMessageLogs(10)
+        .then(logs => {
+        cachedActivity = logs
+            .filter(log => {
+            if (log.isSidechain)
+                return false;
+            if (log.sessionId === currentSessionId)
+                return false;
+            if (log.summary?.includes('I apologize'))
+                return false;
+            // Filter out sessions where both summary and firstPrompt are "No prompt" or missing
+            const hasSummary = log.summary && log.summary !== 'No prompt';
+            const hasFirstPrompt = log.firstPrompt && log.firstPrompt !== 'No prompt';
+            return hasSummary || hasFirstPrompt;
+        })
+            .slice(0, 3);
+        return cachedActivity;
+    })
+        .catch(() => {
+        cachedActivity = [];
+        return cachedActivity;
+    });
+    return cachePromise;
+}
+/**
+ * Gets cached activity synchronously
+ */
+export function getRecentActivitySync() {
+    return cachedActivity;
+}
+/**
+ * Formats release notes for display, with smart truncation
+ */
+export function formatReleaseNoteForDisplay(note, maxWidth) {
+    // Simply truncate at the max width, same as Recent Activity descriptions
+    return truncate(note, maxWidth);
+}
+/**
+ * Gets the common logo display data used by both LogoV2 and CondensedLogo
+ */
+export function getLogoDisplayData() {
+    const version = process.env.DEMO_VERSION ?? MACRO.VERSION;
+    const serverUrl = getDirectConnectServerUrl();
+    const displayPath = process.env.DEMO_VERSION
+        ? '/code/claude'
+        : getDisplayPath(getCwd());
+    const cwd = serverUrl
+        ? `${displayPath} in ${serverUrl.replace(/^https?:\/\//, '')}`
+        : displayPath;
+    const billingType = isClaudeAISubscriber()
+        ? getSubscriptionName()
+        : 'API Usage Billing';
+    const agentName = getInitialSettings().agent;
+    return {
+        version,
+        cwd,
+        billingType,
+        agentName,
+    };
+}
+/**
+ * Determines how to display model and billing information based on available width
+ */
+export function formatModelAndBilling(modelName, billingType, availableWidth) {
+    const separator = ' · ';
+    const combinedWidth = stringWidth(modelName) + separator.length + stringWidth(billingType);
+    const shouldSplit = combinedWidth > availableWidth;
+    if (shouldSplit) {
+        return {
+            shouldSplit: true,
+            truncatedModel: truncate(modelName, availableWidth),
+            truncatedBilling: truncate(billingType, availableWidth),
+        };
+    }
+    return {
+        shouldSplit: false,
+        truncatedModel: truncate(modelName, Math.max(availableWidth - stringWidth(billingType) - separator.length, 10)),
+        truncatedBilling: billingType,
+    };
+}
+/**
+ * Gets recent release notes for Logo v2 display
+ * For ants, uses commits bundled at build time
+ * For external users, uses public changelog
+ */
+export function getRecentReleaseNotesSync(maxItems) {
+    // For ants, use bundled changelog
+    if (process.env.USER_TYPE === 'ant') {
+        const changelog = MACRO.VERSION_CHANGELOG;
+        if (changelog) {
+            const commits = changelog.trim().split('\n').filter(Boolean);
+            return commits.slice(0, maxItems);
+        }
+        return [];
+    }
+    const changelog = getStoredChangelogFromMemory();
+    if (!changelog) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = parseChangelog(changelog);
+    }
+    catch {
+        return [];
+    }
+    // Get notes from recent versions
+    const allNotes = [];
+    const versions = Object.keys(parsed)
+        .sort((a, b) => (gt(a, b) ? -1 : 1))
+        .slice(0, 3); // Look at top 3 recent versions
+    for (const version of versions) {
+        const notes = parsed[version];
+        if (notes) {
+            allNotes.push(...notes);
+        }
+    }
+    // Return raw notes without filtering or premature truncation
+    return allNotes.slice(0, maxItems);
+}