@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/utils/earlyInput.js

@@ -0,0 +1,166 @@
+/**
+ * Early Input Capture
+ *
+ * This module captures terminal input that is typed before the REPL is fully
+ * initialized. Users often type `claude` and immediately start typing their
+ * prompt, but those early keystrokes would otherwise be lost during startup.
+ *
+ * Usage:
+ * 1. Call startCapturingEarlyInput() as early as possible in cli.tsx
+ * 2. When REPL is ready, call consumeEarlyInput() to get any buffered text
+ * 3. stopCapturingEarlyInput() is called automatically when input is consumed
+ */
+import { lastGrapheme } from './intl.js';
+// Buffer for early input characters
+let earlyInputBuffer = '';
+// Flag to track if we're currently capturing
+let isCapturing = false;
+// Reference to the readable handler so we can remove it later
+let readableHandler = null;
+/**
+ * Start capturing stdin data early, before the REPL is initialized.
+ * Should be called as early as possible in the startup sequence.
+ *
+ * Only captures if stdin is a TTY (interactive terminal).
+ */
+export function startCapturingEarlyInput() {
+    // Only capture in interactive mode: stdin must be a TTY, and we must not
+    // be in print mode. Raw mode disables ISIG (terminal Ctrl+C → SIGINT),
+    // which would make -p uninterruptible.
+    if (!process.stdin.isTTY ||
+        isCapturing ||
+        process.argv.includes('-p') ||
+        process.argv.includes('--print')) {
+        return;
+    }
+    isCapturing = true;
+    earlyInputBuffer = '';
+    // Set stdin to raw mode and use 'readable' event like Ink does
+    // This ensures compatibility with how the REPL will handle stdin later
+    try {
+        process.stdin.setEncoding('utf8');
+        process.stdin.setRawMode(true);
+        process.stdin.ref();
+        readableHandler = () => {
+            let chunk = process.stdin.read();
+            while (chunk !== null) {
+                if (typeof chunk === 'string') {
+                    processChunk(chunk);
+                }
+                chunk = process.stdin.read();
+            }
+        };
+        process.stdin.on('readable', readableHandler);
+    }
+    catch {
+        // If we can't set raw mode, just silently continue without early capture
+        isCapturing = false;
+    }
+}
+/**
+ * Process a chunk of input data
+ */
+function processChunk(str) {
+    let i = 0;
+    while (i < str.length) {
+        const char = str[i];
+        const code = char.charCodeAt(0);
+        // Ctrl+C (code 3) - stop capturing and exit immediately.
+        // We use process.exit here instead of gracefulShutdown because at this
+        // early stage of startup, the shutdown machinery isn't initialized yet.
+        if (code === 3) {
+            stopCapturingEarlyInput();
+            // eslint-disable-next-line custom-rules/no-process-exit
+            process.exit(130); // Standard exit code for Ctrl+C
+            return;
+        }
+        // Ctrl+D (code 4) - EOF, stop capturing
+        if (code === 4) {
+            stopCapturingEarlyInput();
+            return;
+        }
+        // Backspace (code 127 or 8) - remove last grapheme cluster
+        if (code === 127 || code === 8) {
+            if (earlyInputBuffer.length > 0) {
+                const last = lastGrapheme(earlyInputBuffer);
+                earlyInputBuffer = earlyInputBuffer.slice(0, -(last.length || 1));
+            }
+            i++;
+            continue;
+        }
+        // Skip escape sequences (arrow keys, function keys, focus events, etc.)
+        // All escape sequences start with ESC (0x1B) and end with a byte in 0x40-0x7E
+        if (code === 27) {
+            i++; // Skip the ESC character
+            // Skip until the terminating byte (@ to ~) or end of string
+            while (i < str.length &&
+                !(str.charCodeAt(i) >= 64 && str.charCodeAt(i) <= 126)) {
+                i++;
+            }
+            if (i < str.length)
+                i++; // Skip the terminating byte
+            continue;
+        }
+        // Skip other control characters (except tab and newline)
+        if (code < 32 && code !== 9 && code !== 10 && code !== 13) {
+            i++;
+            continue;
+        }
+        // Convert carriage return to newline
+        if (code === 13) {
+            earlyInputBuffer += '\n';
+            i++;
+            continue;
+        }
+        // Add printable characters and allowed control chars to buffer
+        earlyInputBuffer += char;
+        i++;
+    }
+}
+/**
+ * Stop capturing early input.
+ * Called automatically when input is consumed, or can be called manually.
+ */
+export function stopCapturingEarlyInput() {
+    if (!isCapturing) {
+        return;
+    }
+    isCapturing = false;
+    if (readableHandler) {
+        process.stdin.removeListener('readable', readableHandler);
+        readableHandler = null;
+    }
+    // Don't reset stdin state - the REPL's Ink App will manage stdin state.
+    // If we call setRawMode(false) here, it can interfere with the REPL's
+    // own stdin setup which happens around the same time.
+}
+/**
+ * Consume any early input that was captured.
+ * Returns the captured input and clears the buffer.
+ * Automatically stops capturing when called.
+ */
+export function consumeEarlyInput() {
+    stopCapturingEarlyInput();
+    const input = earlyInputBuffer.trim();
+    earlyInputBuffer = '';
+    return input;
+}
+/**
+ * Check if there is any early input available without consuming it.
+ */
+export function hasEarlyInput() {
+    return earlyInputBuffer.trim().length > 0;
+}
+/**
+ * Seed the early input buffer with text that will appear pre-filled
+ * in the prompt input when the REPL renders. Does not auto-submit.
+ */
+export function seedEarlyInput(text) {
+    earlyInputBuffer = text;
+}
+/**
+ * Check if early input capture is currently active.
+ */
+export function isCapturingEarlyInput() {
+    return isCapturing;
+}

package/dist/utils/env.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Environment detection — platform, runtime, config paths, network.
+ */
+export declare const env: {
+    platform: "darwin" | "linux" | "win32";
+    terminal: string;
+    shell: string;
+    isCI: boolean;
+};
+export declare function getHostPlatform(): "macos" | "linux" | "windows";
+export declare function getHostPlatformForAnalytics(): string;
+export declare function isWSL(): boolean;
+/** ~/.claude/ directory (Claude Code compatible) */
+export declare function getGlobalClaudeDir(): string;
+/** ~/.code-shell/ directory */
+export declare function getGlobalCodeShellDir(): string;
+/** Resolve a file in ~/.claude/ or ~/.code-shell/ (claude takes precedence) */
+export declare function getGlobalClaudeFile(filename: string): string | undefined;
+export declare function getRuntime(): "bun" | "deno" | "node";
+export declare function getPackageManager(cwd?: string): "bun" | "pnpm" | "yarn" | "npm";
+export declare function hasInternetAccess(): Promise<boolean>;
+export declare const JETBRAINS_IDES: readonly ["idea", "pycharm", "webstorm", "phpstorm", "rubymine", "clion", "goland", "rider", "datagrip", "fleet"];
+export declare function isJetBrainsTerminal(): boolean;
+export declare function isVSCodeTerminal(): boolean;

package/dist/utils/env.js

@@ -0,0 +1,104 @@
+/**
+ * Environment detection — platform, runtime, config paths, network.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+// ─── Platform / Terminal ────────────────────────────────────────────
+export const env = {
+    platform: process.platform,
+    terminal: process.env.TERM_PROGRAM ?? process.env.TERM ?? "unknown",
+    shell: process.env.SHELL ?? (process.platform === "win32" ? "cmd.exe" : "/bin/sh"),
+    isCI: !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI),
+};
+export function getHostPlatform() {
+    if (process.platform === "darwin")
+        return "macos";
+    if (process.platform === "win32")
+        return "windows";
+    return "linux";
+}
+export function getHostPlatformForAnalytics() {
+    return getHostPlatform();
+}
+export function isWSL() {
+    if (process.platform !== "linux")
+        return false;
+    try {
+        const release = execSync("uname -r", { encoding: "utf-8", timeout: 2000 });
+        return /microsoft|wsl/i.test(release);
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Config Paths ───────────────────────────────────────────────────
+const HOME = homedir();
+/** ~/.claude/ directory (Claude Code compatible) */
+export function getGlobalClaudeDir() {
+    return join(HOME, ".claude");
+}
+/** ~/.code-shell/ directory */
+export function getGlobalCodeShellDir() {
+    return join(HOME, ".code-shell");
+}
+/** Resolve a file in ~/.claude/ or ~/.code-shell/ (claude takes precedence) */
+export function getGlobalClaudeFile(filename) {
+    const claudePath = join(getGlobalClaudeDir(), filename);
+    if (existsSync(claudePath))
+        return claudePath;
+    const csPath = join(getGlobalCodeShellDir(), filename);
+    if (existsSync(csPath))
+        return csPath;
+    return undefined;
+}
+// ─── Runtime / Package Manager ──────────────────────────────────────
+export function getRuntime() {
+    if (typeof globalThis.Bun !== "undefined")
+        return "bun";
+    if (typeof globalThis.Deno !== "undefined")
+        return "deno";
+    return "node";
+}
+export function getPackageManager(cwd) {
+    const dir = cwd ?? process.cwd();
+    if (existsSync(join(dir, "bun.lock")) || existsSync(join(dir, "bun.lockb")))
+        return "bun";
+    if (existsSync(join(dir, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(join(dir, "yarn.lock")))
+        return "yarn";
+    return "npm";
+}
+// ─── Network ────────────────────────────────────────────────────────
+let _hasInternet;
+export async function hasInternetAccess() {
+    if (_hasInternet !== undefined)
+        return _hasInternet;
+    try {
+        const { connect } = await import("node:net");
+        return await new Promise((resolve) => {
+            const socket = connect({ host: "1.1.1.1", port: 443, timeout: 3000 });
+            socket.on("connect", () => { socket.destroy(); _hasInternet = true; resolve(true); });
+            socket.on("error", () => { _hasInternet = false; resolve(false); });
+            socket.on("timeout", () => { socket.destroy(); _hasInternet = false; resolve(false); });
+        });
+    }
+    catch {
+        _hasInternet = false;
+        return false;
+    }
+}
+// ─── IDE Detection ──────────────────────────────────────────────────
+export const JETBRAINS_IDES = [
+    "idea", "pycharm", "webstorm", "phpstorm", "rubymine",
+    "clion", "goland", "rider", "datagrip", "fleet",
+];
+export function isJetBrainsTerminal() {
+    return !!(process.env.TERMINAL_EMULATOR?.includes("JetBrains") ||
+        process.env.JETBRAINS_IDE);
+}
+export function isVSCodeTerminal() {
+    return process.env.TERM_PROGRAM === "vscode";
+}

package/dist/utils/envUtils.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Environment variable helpers — ported from CC's utils/envUtils with full implementations.
+ */
+/**
+ * Returns the Claude/Code Shell config home directory.
+ * Defaults to ~/.claude, overridable via CLAUDE_CONFIG_DIR env var.
+ * Memoized — keyed off CLAUDE_CONFIG_DIR so tests that change the env var get a fresh value.
+ */
+export declare function getClaudeConfigHomeDir(): string;
+export declare function getTeamsDir(): string;
+export declare function isEnvTruthy(val: string | boolean | undefined): boolean;
+export declare function isEnvDefinedFalsy(envVar: string | boolean | undefined): boolean;
+/**
+ * Check if NODE_OPTIONS contains a specific flag.
+ */
+export declare function hasNodeOption(flag: string): boolean;
+/**
+ * --bare / CLAUDE_CODE_SIMPLE — skip hooks, LSP, plugin sync, skill dir-walk,
+ * attribution, background prefetches, and ALL keychain/credential reads.
+ */
+export declare function isBareMode(): boolean;
+/**
+ * Parses an array of environment variable strings into a key-value object.
+ * @param rawEnvArgs Array of strings in KEY=VALUE format
+ */
+export declare function parseEnvVars(rawEnvArgs: string[] | undefined): Record<string, string>;
+/**
+ * Get the AWS region with fallback to default.
+ */
+export declare function getAWSRegion(): string;
+/**
+ * Get the default Vertex AI region.
+ */
+export declare function getDefaultVertexRegion(): string;
+/**
+ * Check if bash commands should maintain project working directory.
+ */
+export declare function shouldMaintainProjectWorkingDir(): boolean;
+/**
+ * Check if running on Homespace (ant-internal cloud environment).
+ */
+export declare function isRunningOnHomespace(): boolean;
+/**
+ * Get the Vertex AI region for a specific model.
+ */
+export declare function getVertexRegionForModel(model: string | undefined): string | undefined;
+/**
+ * Stub: Check if running inside a protected namespace.
+ * Always returns false in Code Shell (Anthropic-internal feature).
+ */
+export declare function isInProtectedNamespace(): boolean;

package/dist/utils/envUtils.js

@@ -0,0 +1,135 @@
+/**
+ * Environment variable helpers — ported from CC's utils/envUtils with full implementations.
+ */
+import { homedir } from 'os';
+import { join } from 'path';
+// Memoize cache for getClaudeConfigHomeDir
+let _configHomeDirCache = null;
+let _configHomeDirCacheKey = undefined;
+/**
+ * Returns the Claude/Code Shell config home directory.
+ * Defaults to ~/.claude, overridable via CLAUDE_CONFIG_DIR env var.
+ * Memoized — keyed off CLAUDE_CONFIG_DIR so tests that change the env var get a fresh value.
+ */
+export function getClaudeConfigHomeDir() {
+    const envKey = process.env.CLAUDE_CONFIG_DIR;
+    if (_configHomeDirCache !== null && _configHomeDirCacheKey === envKey) {
+        return _configHomeDirCache;
+    }
+    _configHomeDirCacheKey = envKey;
+    _configHomeDirCache = (envKey ?? join(homedir(), '.claude')).normalize('NFC');
+    return _configHomeDirCache;
+}
+export function getTeamsDir() {
+    return join(getClaudeConfigHomeDir(), 'teams');
+}
+export function isEnvTruthy(val) {
+    if (!val)
+        return false;
+    if (typeof val === 'boolean')
+        return val;
+    const normalizedValue = val.toLowerCase().trim();
+    return ['1', 'true', 'yes', 'on'].includes(normalizedValue);
+}
+export function isEnvDefinedFalsy(envVar) {
+    if (envVar === undefined)
+        return false;
+    if (typeof envVar === 'boolean')
+        return !envVar;
+    if (!envVar)
+        return false;
+    const normalizedValue = envVar.toLowerCase().trim();
+    return ['0', 'false', 'no', 'off'].includes(normalizedValue);
+}
+/**
+ * Check if NODE_OPTIONS contains a specific flag.
+ */
+export function hasNodeOption(flag) {
+    const nodeOptions = process.env.NODE_OPTIONS;
+    if (!nodeOptions)
+        return false;
+    return nodeOptions.split(/\s+/).includes(flag);
+}
+/**
+ * --bare / CLAUDE_CODE_SIMPLE — skip hooks, LSP, plugin sync, skill dir-walk,
+ * attribution, background prefetches, and ALL keychain/credential reads.
+ */
+export function isBareMode() {
+    return (isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE) ||
+        process.argv.includes('--bare'));
+}
+/**
+ * Parses an array of environment variable strings into a key-value object.
+ * @param rawEnvArgs Array of strings in KEY=VALUE format
+ */
+export function parseEnvVars(rawEnvArgs) {
+    const parsedEnv = {};
+    if (rawEnvArgs) {
+        for (const envStr of rawEnvArgs) {
+            const [key, ...valueParts] = envStr.split('=');
+            if (!key || valueParts.length === 0) {
+                throw new Error(`Invalid environment variable format: ${envStr}, environment variables should be added as: -e KEY1=value1 -e KEY2=value2`);
+            }
+            parsedEnv[key] = valueParts.join('=');
+        }
+    }
+    return parsedEnv;
+}
+/**
+ * Get the AWS region with fallback to default.
+ */
+export function getAWSRegion() {
+    return process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';
+}
+/**
+ * Get the default Vertex AI region.
+ */
+export function getDefaultVertexRegion() {
+    return process.env.CLOUD_ML_REGION || 'us-east5';
+}
+/**
+ * Check if bash commands should maintain project working directory.
+ */
+export function shouldMaintainProjectWorkingDir() {
+    return isEnvTruthy(process.env.CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR);
+}
+/**
+ * Check if running on Homespace (ant-internal cloud environment).
+ */
+export function isRunningOnHomespace() {
+    return (process.env.USER_TYPE === 'ant' &&
+        isEnvTruthy(process.env.COO_RUNNING_ON_HOMESPACE));
+}
+/**
+ * Model prefix → env var for Vertex region overrides.
+ */
+const VERTEX_REGION_OVERRIDES = [
+    ['claude-haiku-4-5', 'VERTEX_REGION_CLAUDE_HAIKU_4_5'],
+    ['claude-3-5-haiku', 'VERTEX_REGION_CLAUDE_3_5_HAIKU'],
+    ['claude-3-5-sonnet', 'VERTEX_REGION_CLAUDE_3_5_SONNET'],
+    ['claude-3-7-sonnet', 'VERTEX_REGION_CLAUDE_3_7_SONNET'],
+    ['claude-opus-4-1', 'VERTEX_REGION_CLAUDE_4_1_OPUS'],
+    ['claude-opus-4', 'VERTEX_REGION_CLAUDE_4_0_OPUS'],
+    ['claude-sonnet-4-6', 'VERTEX_REGION_CLAUDE_4_6_SONNET'],
+    ['claude-sonnet-4-5', 'VERTEX_REGION_CLAUDE_4_5_SONNET'],
+    ['claude-sonnet-4', 'VERTEX_REGION_CLAUDE_4_0_SONNET'],
+];
+/**
+ * Get the Vertex AI region for a specific model.
+ */
+export function getVertexRegionForModel(model) {
+    if (model) {
+        const match = VERTEX_REGION_OVERRIDES.find(([prefix]) => model.startsWith(prefix));
+        if (match) {
+            return process.env[match[1]] || getDefaultVertexRegion();
+        }
+    }
+    return getDefaultVertexRegion();
+}
+/**
+ * Stub: Check if running inside a protected namespace.
+ * Always returns false in Code Shell (Anthropic-internal feature).
+ */
+export function isInProtectedNamespace() {
+    return false;
+}

package/dist/utils/execFileNoThrow.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Execute a child process without throwing on non-zero exit.
+ *
+ * Distinguishes between:
+ * - Spawn failure (file not found, permission denied) → code = null
+ * - Non-zero exit (process ran but returned error) → code = exit code
+ * - Success → code = 0
+ */
+export interface ExecFileNoThrowResult {
+    /** Process exit code (0 = success, null = spawn failed). */
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}
+export interface ExecFileNoThrowOptions {
+    /** stdin input to pipe to the process. */
+    input?: string;
+    /** Working directory. */
+    cwd?: string;
+    /** Timeout in ms (default 10_000). */
+    timeout?: number;
+    /** Environment variables to merge. */
+    env?: Record<string, string | undefined>;
+    /** Shell to run in (if true, uses platform default). */
+    shell?: boolean | string;
+}
+/**
+ * Run a command and return exit code + stdout/stderr.
+ * Never throws — spawn failures return code=null.
+ */
+export declare function execFileNoThrow(file: string, args: string[], options?: ExecFileNoThrowOptions): Promise<ExecFileNoThrowResult>;
+/**
+ * execFileNoThrow with explicit cwd (convenience wrapper).
+ */
+export declare function execFileNoThrowWithCwd(cwd: string, file: string, args: string[], options?: Omit<ExecFileNoThrowOptions, "cwd">): Promise<ExecFileNoThrowResult>;
+/**
+ * @deprecated Use execFileNoThrow directly.
+ */
+export declare function execSyncWithDefaults_DEPRECATED(..._args: any[]): any;

package/dist/utils/execFileNoThrow.js

@@ -0,0 +1,74 @@
+/**
+ * Execute a child process without throwing on non-zero exit.
+ *
+ * Distinguishes between:
+ * - Spawn failure (file not found, permission denied) → code = null
+ * - Non-zero exit (process ran but returned error) → code = exit code
+ * - Success → code = 0
+ */
+import { execFile } from "node:child_process";
+/**
+ * Run a command and return exit code + stdout/stderr.
+ * Never throws — spawn failures return code=null.
+ */
+export function execFileNoThrow(file, args, options) {
+    return new Promise((resolve) => {
+        const execOpts = {
+            timeout: options?.timeout ?? 10_000,
+            maxBuffer: 10 * 1024 * 1024, // 10MB
+            encoding: "utf-8",
+        };
+        if (options?.cwd)
+            execOpts.cwd = options.cwd;
+        if (options?.env)
+            execOpts.env = { ...process.env, ...options.env };
+        if (options?.shell)
+            execOpts.shell = options.shell === true ? undefined : options.shell;
+        const child = execFile(file, args, execOpts, (error, stdout, stderr) => {
+            if (error) {
+                // Distinguish spawn failure vs non-zero exit
+                const errno = error;
+                if (errno.code === "ENOENT" || errno.code === "EACCES" || errno.code === "EPERM") {
+                    // Spawn failure — file not found or permission denied
+                    resolve({
+                        code: null,
+                        stdout: String(stdout ?? ""),
+                        stderr: errno.message,
+                    });
+                }
+                else {
+                    // Non-zero exit or killed by signal
+                    resolve({
+                        code: error.code != null ? (typeof error.code === "number" ? error.code : 1) : 1,
+                        stdout: String(stdout ?? ""),
+                        stderr: String(stderr ?? ""),
+                    });
+                }
+            }
+            else {
+                resolve({
+                    code: 0,
+                    stdout: String(stdout ?? ""),
+                    stderr: String(stderr ?? ""),
+                });
+            }
+        });
+        // Pipe stdin if provided
+        if (options?.input && child.stdin) {
+            child.stdin.write(options.input);
+            child.stdin.end();
+        }
+    });
+}
+/**
+ * execFileNoThrow with explicit cwd (convenience wrapper).
+ */
+export function execFileNoThrowWithCwd(cwd, file, args, options) {
+    return execFileNoThrow(file, args, { ...options, cwd });
+}
+/**
+ * @deprecated Use execFileNoThrow directly.
+ */
+export function execSyncWithDefaults_DEPRECATED(..._args) {
+    return undefined;
+}

package/dist/utils/format.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Formats a byte count to a human-readable string (KB, MB, GB).
+ * @example formatFileSize(1536) → "1.5KB"
+ */
+export declare function formatFileSize(sizeInBytes: number): string;
+/**
+ * Formats milliseconds as seconds with 1 decimal place (e.g. `1234` → `"1.2s"`).
+ * Unlike formatDuration, always keeps the decimal — use for sub-minute timings
+ * where the fractional second is meaningful (TTFT, hook durations, etc.).
+ */
+export declare function formatSecondsShort(ms: number): string;
+export declare function formatDuration(ms: number, options?: {
+    hideTrailingZeros?: boolean;
+    mostSignificantOnly?: boolean;
+}): string;
+export declare function formatNumber(number: number): string;
+export declare function formatTokens(count: number): string;
+type RelativeTimeStyle = 'long' | 'short' | 'narrow';
+type RelativeTimeOptions = {
+    style?: RelativeTimeStyle;
+    numeric?: 'always' | 'auto';
+};
+export declare function formatRelativeTime(date: Date, options?: RelativeTimeOptions & {
+    now?: Date;
+}): string;
+export declare function formatRelativeTimeAgo(date: Date, options?: RelativeTimeOptions & {
+    now?: Date;
+}): string;
+/**
+ * Formats log metadata for display (time, size or message count, branch, tag, PR)
+ */
+export declare function formatLogMetadata(log: {
+    modified: Date;
+    messageCount: number;
+    fileSize?: number;
+    gitBranch?: string;
+    tag?: string;
+    agentSetting?: string;
+    prNumber?: number;
+    prRepository?: string;
+}): string;
+export declare function formatResetTime(timestampInSeconds: number | undefined, showTimezone?: boolean, showTime?: boolean): string | undefined;
+export declare function formatResetText(resetsAt: string, showTimezone?: boolean, showTime?: boolean): string;
+export {};