lark-remote 0.1.12 → 0.2.0

package/dist/common/fs.js

@@ -1,4 +1,6 @@
 import fs from 'node:fs';
+import { getLogger } from '../logger/index.js';
+import { currentPlatform, isWin32 } from '../platform/select.js';
 /**
  * Unlink a file, silently ignoring ENOENT and other errors.
  *
@@ -8,10 +10,62 @@ import fs from 'node:fs';
  */
 export function silentlyUnlink(path) {
     try {
-        fs.unlinkSync(path);
+        withBusyRetry(() => fs.unlinkSync(path));
     }
-    catch {
-        /* ignore — file may not exist */
+    catch (err) {
+        // 占用放弃（win32 重试耗尽 / posix 首次占用即失败）：按设计「告警，
+        // 不静默吞」，但清理路径不向调用方抛错（保持本函数契约）
+        getLogger().warn(`[fs] silentlyUnlink gave up on busy file ${path}: ${String(err)}`);
+    }
+}
+/**
+ * win32 句柄占用重试：rename/unlink 目标被
+ * 其他句柄持有时报 EPERM/EBUSY（共享冲突），短暂退避后重试通常即可成功。
+ * 仅 win32 启用重试：posix 上这两个错误码不是「占用瞬态」语义（如 NFS 权限
+ * 问题），立即失败——避免忙等阻塞单线程 bridge 的事件循环。
+ */
+const BUSY_CODES = new Set(['EPERM', 'EBUSY']);
+/**
+ * 退避参数（取参照项目上线验证值）：
+ * 最多 5 次，第 n 次失败后睡 BASE_RETRY_DELAY_MS × n——总阻塞上界 ~250ms。
+ * Windows 上杀毒/索引器持锁更久，窗口比短退避更稳。
+ */
+const BASE_RETRY_DELAY_MS = 25;
+const MAX_RETRY_ATTEMPTS = 5;
+export function isBusyError(err) {
+    return BUSY_CODES.has(err?.code ?? '');
+}
+function busySleep(ms) {
+    if (ms <= 0)
+        return;
+    const end = Date.now() + ms;
+    // 同步退避只能忙等（调用方均为 sync API）；总上界 ~250ms
+    while (Date.now() < end) {
+        /* spin */
+    }
+}
+/**
+ * 对 sync 文件操作套占用退避重试：win32 上遇 EPERM/EBUSY 按退避序列重试，
+ * 其他错误或重试耗尽后抛最后一个错误；posix 上占用错误不重试、立即失败。
+ * `onGiveUp` 仅在「占用导致的放弃」时回调（告警/保留现场）；非占用错误
+ * （如 EXDEV）不走回调、直接透传，避免误触发调用方的占用善后逻辑。
+ */
+export function withBusyRetry(op, opts) {
+    const win32 = isWin32(opts?.platform ?? currentPlatform);
+    for (let attempt = 1;; attempt++) {
+        try {
+            return op();
+        }
+        catch (err) {
+            if (!isBusyError(err))
+                throw err;
+            if (!win32 || attempt >= MAX_RETRY_ATTEMPTS) {
+                // 真正放弃才回调：中间重试失败不能触发「保留现场」类善后
+                opts?.onGiveUp?.(err);
+                throw err;
+            }
+            busySleep(BASE_RETRY_DELAY_MS * attempt);
+        }
     }
 }
 //# sourceMappingURL=fs.js.map

package/dist/common/truncate.d.ts

@@ -16,12 +16,6 @@ export declare const DEFAULT_TRUNCATE_SUFFIX = "\u2026\uFF08\u5DF2\u622A\u65AD\u
  * pathological tool_result never inflates the replay payload to megabytes.
  */
 export declare const TOOL_RESULT_MAX_BYTES = 4000;
-/**
- * Fit a UTF-8 string into `maxBytes` by iterating Unicode codepoints, never
- * splitting a multi-byte sequence. When `fromEnd` is true, keeps the TAIL
- * (useful for logs/tails); otherwise keeps the HEAD.
- */
-export declare function fitUtf8(value: string, maxBytes: number, fromEnd?: boolean): string;
 /**
  * Truncate a UTF-8 string to fit within `maxBytes`, appending `suffix`
  * (default `…（已截断）`) when truncation occurs. When `fromEnd` is true, keeps

package/dist/common/truncate.js

@@ -21,7 +21,7 @@ export const TOOL_RESULT_MAX_BYTES = 4000;
  * splitting a multi-byte sequence. When `fromEnd` is true, keeps the TAIL
  * (useful for logs/tails); otherwise keeps the HEAD.
  */
-export function fitUtf8(value, maxBytes, fromEnd = false) {
+function fitUtf8(value, maxBytes, fromEnd = false) {
     if (fromEnd) {
         const codepoints = Array.from(value);
         let bytes = 0;

package/dist/common/ttl-cache.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Generic TTL + bounded LRU cache.
+ *
+ * Consolidates the per-reader memory caches that previously hand-rolled the
+ * same "mtime/TTL + entry cap" Map pattern (kimi/pi/opencode session readers).
+ * Semantics follow the kimi implementation:
+ * - TTL is measured from the cache-write time (P1-17 defect 2), not key mtime.
+ *   Note: ttlMs = 0 effectively disables caching — `Date.now() - at >= 0` is
+ *   always true, so every entry expires immediately.
+ * - A hit refreshes recency (LRU); eviction removes the least recently
+ *   inserted/used entry past `maxEntries` (P1-17 defect 1: unbounded growth).
+ *   The old pi implementation did NOT re-insert on hit (FIFO eviction); the
+ *   eviction order for pi therefore changes from FIFO to LRU here.
+ */
+export declare class TtlCache<K, V> {
+    private readonly ttlMs;
+    private readonly maxEntries?;
+    private map;
+    constructor(ttlMs: number, maxEntries?: number | undefined);
+    /** Return the fresh value for `key` (refreshing LRU order), or undefined. */
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    clear(): void;
+}

package/dist/common/ttl-cache.js

@@ -0,0 +1,53 @@
+/**
+ * Generic TTL + bounded LRU cache.
+ *
+ * Consolidates the per-reader memory caches that previously hand-rolled the
+ * same "mtime/TTL + entry cap" Map pattern (kimi/pi/opencode session readers).
+ * Semantics follow the kimi implementation:
+ * - TTL is measured from the cache-write time (P1-17 defect 2), not key mtime.
+ *   Note: ttlMs = 0 effectively disables caching — `Date.now() - at >= 0` is
+ *   always true, so every entry expires immediately.
+ * - A hit refreshes recency (LRU); eviction removes the least recently
+ *   inserted/used entry past `maxEntries` (P1-17 defect 1: unbounded growth).
+ *   The old pi implementation did NOT re-insert on hit (FIFO eviction); the
+ *   eviction order for pi therefore changes from FIFO to LRU here.
+ */
+export class TtlCache {
+    ttlMs;
+    maxEntries;
+    map = new Map();
+    constructor(ttlMs, maxEntries) {
+        this.ttlMs = ttlMs;
+        this.maxEntries = maxEntries;
+    }
+    /** Return the fresh value for `key` (refreshing LRU order), or undefined. */
+    get(key) {
+        const entry = this.map.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() - entry.at >= this.ttlMs) {
+            this.map.delete(key);
+            return undefined;
+        }
+        // LRU refresh: re-insert to move to the tail of iteration order.
+        this.map.delete(key);
+        this.map.set(key, entry);
+        return entry.value;
+    }
+    set(key, value) {
+        this.map.delete(key);
+        this.map.set(key, { at: Date.now(), value });
+        if (this.maxEntries !== undefined) {
+            while (this.map.size > this.maxEntries) {
+                const oldest = this.map.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                this.map.delete(oldest);
+            }
+        }
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+//# sourceMappingURL=ttl-cache.js.map

package/dist/config/codex-config.js

@@ -31,16 +31,13 @@ export function resolveCodexHome(codexHome) {
  * 配置 [model_providers.anthropic] 才存在，fallback 阶段不得虚构。
  */
 const FALLBACK_PROVIDERS = ['openai'];
-const FALLBACK_MODELS = [
-    'o3',
-    'o4-mini',
-    'gpt-4o',
-    'gpt-4.1',
-    'gpt-4.1-mini',
-    'gpt-4.1-nano',
-    'claude-sonnet-4-20250514',
-    'claude-opus-4-20250115',
-];
+const FALLBACK_MODELS = ['o3', 'o4-mini', 'gpt-4o', 'gpt-4.1', 'gpt-4.1-mini', 'gpt-4.1-nano'];
+/**
+ * anthropic 的独立兜底模型表：anthropic 非内置 provider，仅在用户显式配置后使用。
+ * 不得混入 FALLBACK_MODELS——无 config.toml 时 openai 的模型列表会原样暴露这些
+ * claude 条目（claude 模型列在 openai provider 下是错的）。
+ */
+const ANTHROPIC_FALLBACK_MODELS = ['claude-sonnet-4-20250514', 'claude-opus-4-20250115'];
 /** Bundled models from codex binary, 1h TTL is enough (only change on binary upgrade) */
 const BUNDLED_CACHE_TTL_MS = 60 * 60 * 1000;
 /** 失败/空结果负缓存 TTL：避免每次卡片构建同步阻塞最长 8s（P3-5） */
@@ -179,6 +176,7 @@ export function getCodexCatalogModels(codexHome) {
             maxBuffer: 4 * 1024 * 1024,
             env: process.env,
             stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true, // codex 是 npm .cmd 垫片：不隐藏会闪 cmd.exe 控制台
         });
         const models = parseCodexModelsOutput(stdout);
         catalogCache = { key, models, ts: now, failed: models.length === 0 };
@@ -287,6 +285,7 @@ function execFileAsync(file, args) {
             timeout: 8_000,
             maxBuffer: 4 * 1024 * 1024,
             env: process.env,
+            windowsHide: true,
         }, (err, stdout) => {
             if (err)
                 reject(err);
@@ -351,7 +350,11 @@ export function loadCodexConfig(opts = {}) {
     // 否则 = bundled（与原行为一致）
     const catalogSlugs = getCodexCatalogModels(codexHome).map((m) => m.slug);
     const allModels = catalogSlugs.length > 0 ? catalogSlugs : FALLBACK_MODELS;
-    const anthropicModels = allModels.filter((m) => m.startsWith('claude-'));
+    // anthropic 模型列表仅在用户显式配置 anthropic 时使用：catalog 可用取 catalog 中的
+    // claude-*，否则用 ANTHROPIC_FALLBACK_MODELS（与 openai 兜底表隔离）
+    const anthropicModels = catalogSlugs.length > 0
+        ? catalogSlugs.filter((m) => m.startsWith('claude-'))
+        : ANTHROPIC_FALLBACK_MODELS;
     if (!fs.existsSync(configFile)) {
         // 无 config.toml：默认模型取目录首个可用模型（codex default_model_from_available），
         // 目录不可用时回退 'o3'（FALLBACK_MODELS 首项，非 catalog 默认）

package/dist/config/index.d.ts

@@ -237,18 +237,10 @@ export declare const AppConfigSchema: z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
             thinkingEffort: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
-        dsh: z.ZodOptional<z.ZodObject<{
-            host: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
     }, z.core.$strip>>;
     idle: z.ZodDefault<z.ZodObject<{
         watchdogMinutes: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
-    output: z.ZodDefault<z.ZodObject<{
-        showThinking: z.ZodDefault<z.ZodBoolean>;
-        showToolUse: z.ZodDefault<z.ZodBoolean>;
-        showToolResult: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
     logging: z.ZodDefault<z.ZodObject<{
         level: z.ZodDefault<z.ZodEnum<{
             debug: "debug";

package/dist/config/index.js

@@ -202,11 +202,6 @@ const IdleConfigSchema = z.object({
      */
     watchdogMinutes: z.number().int().min(0).default(DEFAULTS.IDLE_WATCHDOG_MINUTES),
 });
-const OutputConfigSchema = z.object({
-    showThinking: z.boolean().default(true),
-    showToolUse: z.boolean().default(true),
-    showToolResult: z.boolean().default(true),
-});
 const LoggingConfigSchema = z.object({
     level: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
 });
@@ -246,11 +241,6 @@ const AgentChoicesSchema = z.object({
         thinkingEffort: z.string().optional(),
     })
         .optional(),
-    dsh: z
-        .object({
-        host: z.string().optional(),
-    })
-        .optional(),
 });
 export const AppConfigSchema = z.object({
     feishu: FeishuConfigSchema,
@@ -261,7 +251,6 @@ export const AppConfigSchema = z.object({
     /** Agent-specific saved choices for quick switching. */
     agentChoices: AgentChoicesSchema.optional(),
     idle: IdleConfigSchema.default(IdleConfigSchema.parse({})),
-    output: OutputConfigSchema.default(OutputConfigSchema.parse({})),
     logging: LoggingConfigSchema.default(LoggingConfigSchema.parse({})),
     /** 入站媒体（图片/文件）落盘配置。 */
     inboundMedia: InboundMediaConfigSchema.default(InboundMediaConfigSchema.parse({})),
@@ -285,11 +274,6 @@ claude:
 idle:
   watchdogMinutes: ${DEFAULTS.IDLE_WATCHDOG_MINUTES}
 
-output:
-  showThinking: true
-  showToolUse: true
-  showToolResult: true
-
 logging:
   level: info
 

package/dist/config/kimi-config.d.ts

@@ -22,7 +22,7 @@ interface KimiConfigResult {
     /** Model -> default effort mapping */
     modelDefaultEfforts: Record<string, string>;
 }
-/** 清空缓存（测试与配置热更新用，与 codex/opencode 的 invalidate 对齐） */
+/** 清空缓存（仅供测试使用，生产代码无调用点） */
 export declare function invalidateKimiConfigCache(): void;
 /**
  * Load Kimi models from `kimi provider list --json`.

package/dist/config/kimi-config.js

@@ -10,7 +10,7 @@ import { getLogger } from '../logger/index.js';
 export const KIMI_THINKING_EFFORTS = ['low', 'high', 'max'];
 /** Fallback efforts when all values are filtered out */
 export const FALLBACK_EFFORTS = ['low', 'high', 'max'];
-/** 清空缓存（测试与配置热更新用，与 codex/opencode 的 invalidate 对齐） */
+/** 清空缓存（仅供测试使用，生产代码无调用点） */
 export function invalidateKimiConfigCache() {
     kimiConfigCache = null;
 }
@@ -34,6 +34,7 @@ export function loadKimiConfig() {
             stdio: ['ignore', 'pipe', 'ignore'],
             timeout: 10000,
             maxBuffer: 2 * 1024 * 1024,
+            windowsHide: true, // kimi 是 npm .cmd 垫片：不隐藏会闪 cmd.exe 控制台
         });
         const data = JSON.parse(output.toString());
         if (!data.models || Object.keys(data.models).length === 0) {

package/dist/config/opencode-config.d.ts

@@ -9,7 +9,7 @@ interface OpencodeConfigResult {
     /** 根据 provider 获取可用模型列表（返回纯 model ID，不带 provider 前缀） */
     modelOptions: (provider?: string) => string[];
 }
-/** 清空缓存（测试与配置热更新用，与 codex-config 的 invalidateCodexBundledCache 对齐） */
+/** 清空缓存（仅供测试使用，生产代码无调用点） */
 export declare function invalidateOpencodeConfigCache(): void;
 /**
  * 加载 opencode 配置，执行 opencode models --verbose 并解析

package/dist/config/opencode-config.js

@@ -3,25 +3,21 @@
  *
  * 从 opencode models --verbose 命令获取 provider 和 model 信息
  */
-import { execSync } from 'node:child_process';
+import { resolveExecutable } from '../platform/command.js';
+import { spawnProcessSync } from '../platform/spawn.js';
 import { getLogger } from '../logger/index.js';
 /**
  * 内置的 fallback 列表
  * 当 opencode 命令失败时使用
  * 格式：provider/model（内部用，modelOptions 返回时会去掉 provider 前缀）
  */
-const FALLBACK_PROVIDERS = [
-    'opencode',
-    'deepseek',
-    'minimax-cn-coding-plan',
-    'myprovider',
-    'volcengine-plan',
-];
 const FALLBACK_MODELS = {
     opencode: ['big-pickle'],
     deepseek: ['deepseek-chat'],
     'minimax-cn-coding-plan': ['MiniMax-M2.5'],
 };
+/** fallback provider 列表从模型表派生，保证不会出现空模型列表的 provider（历史曾混入无模型的 myprovider/volcengine-plan） */
+const FALLBACK_PROVIDERS = Object.keys(FALLBACK_MODELS);
 /** 正缓存 TTL：opencode models 列表短时间不变，1 分钟（与 kimi-config 对齐） */
 const OPENCODE_CONFIG_CACHE_TTL_MS = 60_000;
 /**
@@ -31,7 +27,7 @@ const OPENCODE_CONFIG_CACHE_TTL_MS = 60_000;
 const OPENCODE_NEGATIVE_CACHE_TTL_MS = 30_000;
 let opencodeConfigCache = null;
 let opencodeConfigFailedAt = null;
-/** 清空缓存（测试与配置热更新用，与 codex-config 的 invalidateCodexBundledCache 对齐） */
+/** 清空缓存（仅供测试使用，生产代码无调用点） */
 export function invalidateOpencodeConfigCache() {
     opencodeConfigCache = null;
     opencodeConfigFailedAt = null;
@@ -71,13 +67,23 @@ export function loadOpencodeConfig() {
         return buildFallbackResult();
     }
     try {
+        // 经 seam 解析真实可执行文件（win32 PATHEXT），cross-spawn 同步执行
+        const resolved = resolveExecutable('opencode');
+        if (!resolved)
+            throw new Error('opencode not found');
         // 执行 opencode models --verbose 获取所有模型信息
-        const output = execSync('opencode models --verbose', {
+        const res = spawnProcessSync(resolved.file, ['models', '--verbose'], {
             encoding: 'utf-8',
             // P1-8：30s → 10s，与 codex/kimi 对齐；maxBuffer 防模型清单 ENOBUFS 隐性截断
             timeout: 10000,
             maxBuffer: 64 * 1024 * 1024,
         });
+        if (res.error)
+            throw res.error;
+        if (res.status !== 0) {
+            throw new Error(`opencode models exited code=${res.status}: ${String(res.stderr).slice(-200)}`);
+        }
+        const output = String(res.stdout);
         // 按 provider 分组收集模型（只存 model ID，不存 provider/model 完整格式）
         const providerModels = new Map();
         // 解析输出：每个模型以 provider/model 格式开头，后面跟着 JSON 块

package/dist/config/qr.d.ts

@@ -0,0 +1,36 @@
+export type TerminalQrMode = 'full-block' | 'half-block';
+export interface TerminalQr {
+    mode: TerminalQrMode;
+    /** Columns the rendered symbol occupies — compare against the terminal width. */
+    columns: number;
+    /** Symbol rows, one text row per line, no trailing newline. */
+    text: string;
+}
+/**
+ * Render a scannable symbol for the current terminal.
+ *
+ * Prefers the Windows-safe full-block rendering; when it is too wide for the
+ * terminal, POSIX terminals fall back to the compact half-block rendering
+ * (macOS/Linux terminals draw its glyphs correctly). Windows deliberately does
+ * not: half blocks are exactly what does not scan there, so the caller falls
+ * back to the image file instead. Returns `null` when nothing fits.
+ */
+export declare function renderTerminalQr(text: string, options?: {
+    columns?: number;
+    platform?: NodeJS.Platform;
+}): TerminalQr | null;
+/**
+ * Render the symbol as a GIF.
+ *
+ * The escape hatch for terminals where block rendering still does not scan
+ * (narrow window, missing glyphs): a real image file always scans.
+ */
+export declare function renderQrImage(text: string, cellSize?: number): Buffer;
+/**
+ * Whether the wizard should also write the QR image file.
+ *
+ * Windows always gets the file: its consoles are exactly where block glyphs
+ * render unreliably, so the image is the dependable path there. Elsewhere the
+ * file is only written when the terminal could not show a symbol at all.
+ */
+export declare function needsQrImage(terminalQr: TerminalQr | null, platform?: NodeJS.Platform): boolean;

package/dist/config/qr.js

@@ -0,0 +1,124 @@
+import qrcode from 'qrcode-generator';
+import { currentPlatform, isWin32 } from '../platform/select.js';
+/**
+ * Terminal rendering for the first-run wizard's QR symbol.
+ *
+ * Everything is drawn from one module matrix. Two renderers exist because
+ * terminals disagree about block glyphs:
+ *
+ * - `full-block` draws each module as two `█` columns. It only relies on the
+ *   full block glyph, which every console font has, and stays square in a
+ *   typical 1:2 terminal cell. This is the Windows-safe rendering.
+ * - `half-block` packs two QR rows into one text row with `▀`/`▄`. It is half
+ *   as tall, but needs a font that draws those glyphs as exact half-height
+ *   blocks — Windows consoles (raster/CJK fonts, extra line spacing) often
+ *   don't, which is why the symbol printed there often cannot be scanned.
+ *
+ * Both renderers emit the 4-module light quiet zone the QR spec requires;
+ * `qrcode-terminal`'s half-block output had none, and a missing quiet zone
+ * alone can make scanners fail.
+ *
+ * Polarity follows `qrcode-terminal`: glyphs are painted in the foreground
+ * colour and stand for the *light* modules, so the terminal's dark background
+ * supplies the dark modules (the common default theme).
+ */
+/** Light modules that must surround a symbol for scanners to lock on (QR spec). */
+const QUIET_ZONE = 4;
+const LIGHT_FULL = '██';
+const DARK_FULL = '  ';
+const LIGHT_HALF_BOTH = '█';
+const LIGHT_HALF_TOP = '▀';
+const LIGHT_HALF_BOTTOM = '▄';
+const DARK_HALF_BOTH = ' ';
+/** Used when stdout reports no width — non-TTY pipes, and consoles that report 0. */
+const DEFAULT_COLUMNS = 80;
+function buildSymbol(text) {
+    const symbol = qrcode(0, 'L');
+    symbol.addData(text);
+    symbol.make();
+    return symbol;
+}
+function renderFullBlock(symbol) {
+    const count = symbol.getModuleCount();
+    const lightRow = LIGHT_FULL.repeat(count + QUIET_ZONE * 2);
+    const pad = LIGHT_FULL.repeat(QUIET_ZONE);
+    const rows = new Array(count + QUIET_ZONE * 2).fill(lightRow);
+    for (let row = 0; row < count; row++) {
+        let line = pad;
+        for (let col = 0; col < count; col++) {
+            line += symbol.isDark(row, col) ? DARK_FULL : LIGHT_FULL;
+        }
+        rows[QUIET_ZONE + row] = line + pad;
+    }
+    return rows.join('\n');
+}
+function renderHalfBlock(symbol) {
+    const count = symbol.getModuleCount();
+    // Module counts are always odd (4 * version + 17), so the final row pairs
+    // with an implicit light row.
+    const textRows = Math.ceil(count / 2);
+    const quietRows = QUIET_ZONE / 2;
+    const lightRow = LIGHT_HALF_BOTH.repeat(count + QUIET_ZONE * 2);
+    const rows = new Array(textRows + quietRows * 2).fill(lightRow);
+    for (let pair = 0; pair < count; pair += 2) {
+        let line = LIGHT_HALF_BOTH.repeat(QUIET_ZONE);
+        for (let col = 0; col < count; col++) {
+            const top = symbol.isDark(pair, col);
+            const bottom = pair + 1 < count && symbol.isDark(pair + 1, col);
+            if (!top && !bottom)
+                line += LIGHT_HALF_BOTH;
+            else if (!top)
+                line += LIGHT_HALF_TOP;
+            else if (!bottom)
+                line += LIGHT_HALF_BOTTOM;
+            else
+                line += DARK_HALF_BOTH;
+        }
+        rows[quietRows + pair / 2] = line + LIGHT_HALF_BOTH.repeat(QUIET_ZONE);
+    }
+    return rows.join('\n');
+}
+/**
+ * Render a scannable symbol for the current terminal.
+ *
+ * Prefers the Windows-safe full-block rendering; when it is too wide for the
+ * terminal, POSIX terminals fall back to the compact half-block rendering
+ * (macOS/Linux terminals draw its glyphs correctly). Windows deliberately does
+ * not: half blocks are exactly what does not scan there, so the caller falls
+ * back to the image file instead. Returns `null` when nothing fits.
+ */
+export function renderTerminalQr(text, options = {}) {
+    const columns = options.columns && options.columns > 0 ? options.columns : DEFAULT_COLUMNS;
+    const platform = options.platform ?? currentPlatform;
+    const symbol = buildSymbol(text);
+    const width = symbol.getModuleCount() + QUIET_ZONE * 2;
+    if (width * 2 <= columns) {
+        return { mode: 'full-block', columns: width * 2, text: renderFullBlock(symbol) };
+    }
+    if (!isWin32(platform) && width <= columns) {
+        return { mode: 'half-block', columns: width, text: renderHalfBlock(symbol) };
+    }
+    return null;
+}
+/**
+ * Render the symbol as a GIF.
+ *
+ * The escape hatch for terminals where block rendering still does not scan
+ * (narrow window, missing glyphs): a real image file always scans.
+ */
+export function renderQrImage(text, cellSize = 8) {
+    const symbol = buildSymbol(text);
+    const dataUrl = symbol.createDataURL(cellSize);
+    return Buffer.from(dataUrl.slice(dataUrl.indexOf(',') + 1), 'base64');
+}
+/**
+ * Whether the wizard should also write the QR image file.
+ *
+ * Windows always gets the file: its consoles are exactly where block glyphs
+ * render unreliably, so the image is the dependable path there. Elsewhere the
+ * file is only written when the terminal could not show a symbol at all.
+ */
+export function needsQrImage(terminalQr, platform = currentPlatform) {
+    return terminalQr === null || isWin32(platform);
+}
+//# sourceMappingURL=qr.js.map