lark-remote 0.1.0

package/dist/card/tool-render.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Structured tool rendering for collapsible panels.
+ *
+ * Adapted to lark-remote's `ToolEntry` type (which uses `status: 'running' | 'ok' | 'error'`
+ * and stores `input` as an already-stringified value in some paths).
+ *
+ * Why this exists: the old renderer dumped `JSON.stringify(input, null, 2)`
+ * which is verbose and buries the useful signal (command, file path, pattern)
+ * under formatting noise. `toolHeaderText` produces a compact one-liner header
+ * like `✅ **Bash** — pwd` so collapsed panels stay informative.
+ */
+import type { ToolEntry } from './run-state.js';
+/**
+ * One-line header for a tool call:
+ *   `⏳ **Bash** — pwd`
+ *   `✅ **Read** — /repo/a.ts`
+ *   `❌ **Grep** — pattern in path`
+ */
+export declare function toolHeaderText(tool: ToolEntry): string;
+/**
+ * Structured body markdown for a tool call. Renders input fields by tool name
+ * (Bash → command, Read/Edit/Write → file_path, etc.) and output in a code
+ * block. Falls back to a raw JSON dump for unknown tools.
+ */
+export declare function toolBodyMd(tool: ToolEntry): string;

package/dist/card/tool-render.js

@@ -0,0 +1,176 @@
+/**
+ * Structured tool rendering for collapsible panels.
+ *
+ * Adapted to lark-remote's `ToolEntry` type (which uses `status: 'running' | 'ok' | 'error'`
+ * and stores `input` as an already-stringified value in some paths).
+ *
+ * Why this exists: the old renderer dumped `JSON.stringify(input, null, 2)`
+ * which is verbose and buries the useful signal (command, file path, pattern)
+ * under formatting noise. `toolHeaderText` produces a compact one-liner header
+ * like `✅ **Bash** — pwd` so collapsed panels stay informative.
+ */
+const HEADER_SUMMARY_MAX = 80;
+const BODY_FIELD_MAX = 600;
+const OUTPUT_MAX = 1200;
+/**
+ * Cumulative cap on a tool's full body markdown (input + output + code fences
+ * + headers). Even with per-field caps, pathological tools (many input fields
+ * + maxed-out output) can stack to multi-KB bodies which, multiplied across
+ * panels, push the card past Feishu's per-element size limit. This is the last
+ * belt across the whole rendered body string.
+ */
+const BODY_TOTAL_MAX = 2500;
+/**
+ * One-line header for a tool call:
+ *   `⏳ **Bash** — pwd`
+ *   `✅ **Read** — /repo/a.ts`
+ *   `❌ **Grep** — pattern in path`
+ */
+export function toolHeaderText(tool) {
+    const icon = tool.status === 'ok' ? '✅' : tool.status === 'error' ? '❌' : '⏳';
+    // P3-6: use the cached parsed record when available (avoids per-render parse).
+    const input = tool.parsedInput !== undefined ? tool.parsedInput : tool.input;
+    const summary = summarizeInput(tool.name, input);
+    return summary ? `${icon} **${tool.name}** — ${summary}` : `${icon} **${tool.name}**`;
+}
+/**
+ * Structured body markdown for a tool call. Renders input fields by tool name
+ * (Bash → command, Read/Edit/Write → file_path, etc.) and output in a code
+ * block. Falls back to a raw JSON dump for unknown tools.
+ */
+export function toolBodyMd(tool) {
+    const parts = [];
+    const inputMd = renderInput(tool);
+    if (inputMd)
+        parts.push(inputMd);
+    if (tool.output) {
+        const truncated = truncate(tool.output, OUTPUT_MAX);
+        if (tool.status === 'error') {
+            parts.push(`**Error**\n\`\`\`\n${truncated}\n\`\`\``);
+        }
+        else {
+            parts.push(`**Output**\n\`\`\`\n${truncated}\n\`\`\``);
+        }
+    }
+    else if (tool.status === 'running') {
+        parts.push('_运行中…_');
+    }
+    const body = parts.join('\n\n');
+    if (body.length <= BODY_TOTAL_MAX)
+        return body;
+    return `${body.slice(0, BODY_TOTAL_MAX)}…\n\n_（body 已截断，完整内容查日志）_`;
+}
+function summarizeInput(name, input) {
+    const rec = asRecord(input);
+    if (!rec)
+        return '';
+    const pick = (key, max = HEADER_SUMMARY_MAX) => {
+        const v = rec[key];
+        if (typeof v !== 'string')
+            return '';
+        const oneLine = v.replace(/\s+/g, ' ').trim();
+        return oneLine.length > max ? `${oneLine.slice(0, max)}…` : oneLine;
+    };
+    switch (name) {
+        case 'Bash':
+        case 'bash':
+            return pick('command');
+        case 'Read':
+        case 'Edit':
+        case 'Write':
+        case 'NotebookEdit':
+        case 'read':
+        case 'edit':
+        case 'write':
+            return pick('file_path') || pick('path');
+        case 'Grep':
+        case 'grep': {
+            const pat = pick('pattern', 40);
+            const p = pick('path', 30);
+            return p ? `${pat} in ${p}` : pat;
+        }
+        case 'Glob':
+        case 'find':
+            return pick('pattern');
+        case 'ls':
+            return pick('path');
+        case 'WebFetch':
+            return pick('url');
+        case 'WebSearch':
+            return pick('query', 60);
+        case 'Agent':
+        case 'Task':
+            return pick('description') || pick('subagent_type');
+        default:
+            return pick('command') || pick('file_path') || pick('path') || pick('query');
+    }
+}
+function renderInput(tool) {
+    // P3-6: use the cached parsed record when available (avoids per-render parse).
+    const input = tool.parsedInput !== undefined ? tool.parsedInput : tool.input;
+    const rec = asRecord(input);
+    if (!rec)
+        return '';
+    const str = (k) => (typeof rec[k] === 'string' ? rec[k] : '');
+    switch (tool.name) {
+        case 'Bash':
+        case 'bash': {
+            const cmd = str('command');
+            return cmd ? `**Command**\n\`\`\`bash\n${truncate(cmd, BODY_FIELD_MAX)}\n\`\`\`` : '';
+        }
+        case 'Read':
+        case 'Edit':
+        case 'Write':
+        case 'NotebookEdit':
+        case 'read':
+        case 'edit':
+        case 'write': {
+            const fp = str('file_path') || str('path');
+            return fp ? `**File** \`${fp}\`` : '';
+        }
+        case 'Grep':
+        case 'grep': {
+            const lines = [];
+            if (str('pattern'))
+                lines.push(`**Pattern** \`${str('pattern')}\``);
+            if (str('path'))
+                lines.push(`**Path** \`${str('path')}\``);
+            return lines.join('\n');
+        }
+        case 'Glob':
+        case 'find': {
+            const p = str('pattern');
+            return p ? `**Pattern** \`${truncate(p, BODY_FIELD_MAX)}\`` : '';
+        }
+        case 'ls': {
+            const p = str('path');
+            return p ? `**Path** \`${p}\`` : '';
+        }
+        case 'WebFetch':
+            return str('url') ? `**URL** ${str('url')}` : '';
+        case 'WebSearch':
+            return str('query') ? `**Query** \`${truncate(str('query'), BODY_FIELD_MAX)}\`` : '';
+        default:
+            return '';
+    }
+}
+function asRecord(input) {
+    if (!input)
+        return null;
+    if (typeof input === 'object')
+        return input;
+    if (typeof input === 'string') {
+        try {
+            const p = JSON.parse(input);
+            return p && typeof p === 'object' ? p : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function truncate(s, max) {
+    return s.length > max ? `${s.slice(0, max)}…` : s;
+}
+//# sourceMappingURL=tool-render.js.map

package/dist/cli.d.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+type RuntimeChoice = 'bun' | 'node';
+interface BunProbe {
+    error: boolean;
+    status: number | null;
+}
+/** Prefer bun unless we are already under bun or bun is not usable. */
+export declare function decideRuntime(isBun: boolean, probe: BunProbe): RuntimeChoice;
+interface ChildLike {
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+    kill(signal?: NodeJS.Signals): boolean;
+}
+interface BootstrapDeps {
+    entry: string;
+    args: string[];
+    isBun: boolean;
+    probe: BunProbe;
+    platform?: string;
+    importEntry: () => Promise<unknown>;
+    spawnBun: (entry: string, args: string[]) => ChildLike;
+    onSignal: (signal: NodeJS.Signals, handler: () => void) => void;
+    offSignal: (signal: NodeJS.Signals, handler: () => void) => void;
+    killSelf: (signal: NodeJS.Signals) => void;
+    exit: (code: number) => void;
+}
+export declare function bootstrap(deps: BootstrapDeps): Promise<void>;
+export {};

package/dist/cli.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const entryUrl = new URL('./index.js', import.meta.url);
+const entry = fileURLToPath(entryUrl);
+/** Prefer bun unless we are already under bun or bun is not usable. */
+export function decideRuntime(isBun, probe) {
+    if (!isBun && !probe.error && probe.status === 0)
+        return 'bun';
+    return 'node';
+}
+/** Check whether `bun` is present and runs `--version` successfully. */
+function probeBun() {
+    try {
+        const res = spawnSync('bun', ['--version'], { stdio: 'ignore' });
+        return { error: res.error !== undefined, status: res.status };
+    }
+    catch {
+        return { error: true, status: null };
+    }
+}
+export async function bootstrap(deps) {
+    const { entry, args, isBun, probe, platform = process.platform, importEntry, spawnBun, onSignal, offSignal, killSelf, exit, } = deps;
+    if (decideRuntime(isBun, probe) === 'node') {
+        await importEntry();
+        return;
+    }
+    const child = spawnBun(entry, args);
+    const signals = platform === 'win32' ? ['SIGINT', 'SIGTERM', 'SIGBREAK'] : ['SIGINT', 'SIGTERM', 'SIGHUP'];
+    const forwarders = new Map();
+    for (const sig of signals) {
+        const forwarder = () => child.kill(sig);
+        forwarders.set(sig, forwarder);
+        onSignal(sig, forwarder);
+    }
+    child.on('error', () => {
+        for (const [sig, forwarder] of forwarders)
+            offSignal(sig, forwarder);
+        void importEntry().catch(() => exit(1));
+    });
+    child.on('exit', (code, signal) => {
+        if (signal) {
+            for (const [sig, forwarder] of forwarders)
+                offSignal(sig, forwarder);
+            try {
+                killSelf(signal);
+            }
+            catch {
+                exit(1);
+            }
+        }
+        else {
+            exit(code ?? 1);
+        }
+    });
+}
+function isDirectEntry() {
+    const argv1 = process.argv[1];
+    if (!argv1)
+        return false;
+    const candidates = [];
+    try {
+        candidates.push(fs.realpathSync(argv1));
+    }
+    catch { }
+    candidates.push(path.resolve(argv1));
+    return candidates.some((p) => pathToFileURL(p).href === import.meta.url);
+}
+function main() {
+    const deps = {
+        entry,
+        args: process.argv.slice(2),
+        isBun: process.isBun ?? false,
+        probe: probeBun(),
+        importEntry: () => import(entryUrl.href),
+        spawnBun: (e, a) => spawn('bun', [e, ...a], { stdio: 'inherit' }),
+        onSignal: (sig, handler) => process.on(sig, handler),
+        offSignal: (sig, handler) => process.off(sig, handler),
+        killSelf: (sig) => process.kill(process.pid, sig),
+        exit: (code) => process.exit(code),
+    };
+    void bootstrap(deps).catch(() => process.exit(1));
+}
+if (isDirectEntry()) {
+    main();
+}
+//# sourceMappingURL=cli.js.map

package/dist/common/guards.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Type guards and safe value extractors for untyped (usually JSON-parsed)
+ * data coming from external sources such as LSP messages, API responses,
+ * or child-process stdout.
+ *
+ * Every function is intentionally tiny and side-effect-free so it can be
+ * inlined by the bundler and reasoned about at a glance.
+ */
+/**
+ * Returns `true` when `v` is a non-null object (including arrays).
+ * Used as a prerequisite before accessing string-keyed properties.
+ */
+export declare function isRecord(v: unknown): v is Record<string, unknown>;
+/**
+ * Narrows `v` to `Record<string, unknown>` when it is a non-null object,
+ * otherwise returns `undefined`.
+ */
+export declare function recordValue(v: unknown): Record<string, unknown> | undefined;
+/**
+ * Returns the string value when `v` is a `string`, otherwise `undefined`.
+ */
+export declare function stringValue(v: unknown): string | undefined;
+/**
+ * Returns the number value when `v` is a `number`, otherwise `undefined`.
+ */
+export declare function numberValue(v: unknown): number | undefined;
+/**
+ * Extracts a human-readable error message from an opaque error object.
+ *
+ * Priority:
+ *  1. `raw.message`  (string)
+ *  2. `raw.error.message`  (string, when `raw.error` is a record)
+ *  3. `raw.error.data.message`  (string, AI SDK wraps provider errors as {error:{data:{message}}})
+ *  4. `raw.error` itself  (when it is a string)
+ *  5. `fallback`
+ */
+export declare function extractErrorMessage(raw: Record<string, unknown>, fallback: string): string;

package/dist/common/guards.js

@@ -0,0 +1,65 @@
+/**
+ * Type guards and safe value extractors for untyped (usually JSON-parsed)
+ * data coming from external sources such as LSP messages, API responses,
+ * or child-process stdout.
+ *
+ * Every function is intentionally tiny and side-effect-free so it can be
+ * inlined by the bundler and reasoned about at a glance.
+ */
+/**
+ * Returns `true` when `v` is a non-null object (including arrays).
+ * Used as a prerequisite before accessing string-keyed properties.
+ */
+export function isRecord(v) {
+    return typeof v === 'object' && v !== null;
+}
+/**
+ * Narrows `v` to `Record<string, unknown>` when it is a non-null object,
+ * otherwise returns `undefined`.
+ */
+export function recordValue(v) {
+    return isRecord(v) ? v : undefined;
+}
+/**
+ * Returns the string value when `v` is a `string`, otherwise `undefined`.
+ */
+export function stringValue(v) {
+    return typeof v === 'string' ? v : undefined;
+}
+/**
+ * Returns the number value when `v` is a `number`, otherwise `undefined`.
+ */
+export function numberValue(v) {
+    return typeof v === 'number' ? v : undefined;
+}
+/**
+ * Extracts a human-readable error message from an opaque error object.
+ *
+ * Priority:
+ *  1. `raw.message`  (string)
+ *  2. `raw.error.message`  (string, when `raw.error` is a record)
+ *  3. `raw.error.data.message`  (string, AI SDK wraps provider errors as {error:{data:{message}}})
+ *  4. `raw.error` itself  (when it is a string)
+ *  5. `fallback`
+ */
+export function extractErrorMessage(raw, fallback) {
+    const msg = stringValue(raw.message);
+    if (msg !== undefined)
+        return msg;
+    const err = raw.error;
+    if (isRecord(err)) {
+        const subMsg = stringValue(err.message);
+        if (subMsg !== undefined)
+            return subMsg;
+        const data = recordValue(err.data);
+        if (data) {
+            const dataMsg = stringValue(data.message);
+            if (dataMsg !== undefined)
+                return dataMsg;
+        }
+    }
+    if (typeof err === 'string')
+        return err;
+    return fallback;
+}
+//# sourceMappingURL=guards.js.map

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

@@ -0,0 +1,113 @@
+/**
+ * Codex config loader
+ *
+ * Reads model_provider and model from ~/.codex/config.toml,
+ * provides dynamic dropdown options for /config card.
+ *
+ * Model filtering strategy:
+ * - catalog 模式（config.toml 声明 model_catalog_json）：模型列表/档位来自活动目录
+ * - 非 catalog 模式：openai 用 bundled 全量；anthropic 仅在用户显式配置时存在
+ */
+/**
+ * Resolve codex home directory.
+ * Priority: explicit codexHome param > $CODEX_HOME env > ~/.codex
+ */
+export declare function resolveCodexHome(codexHome?: string): string;
+/** loadCodexConfig() return type */
+interface CodexConfigResult {
+    /** current selected model */
+    currentModel: string;
+    /** current selected model_provider */
+    currentProvider: string;
+    /** provider name list */
+    providerNames: string[];
+    /** provider -> env_key mapping (e.g., openai -> OPENAI_API_KEY) */
+    providerEnvKeys: Record<string, string>;
+    /** provider -> model list mapping.
+     *  - custom provider: model from config.toml
+     *  - openai: all bundled models
+     *  - anthropic: bundled models with 'claude-*' prefix */
+    providerModels: Record<string, string[]>;
+    /** Get available model list by provider */
+    modelOptions: (provider?: string) => string[];
+}
+/** Enhanced bundled model info interface */
+export interface BundledModelInfo {
+    /** model slug (e.g., gpt-5.6-sol) */
+    slug: string;
+    /** display name (e.g., GPT-5.6-Sol) */
+    displayName: string;
+    /** priority, lower number = first in list */
+    priority: number;
+    /** supported reasoning effort levels */
+    supportedReasoningLevels: string[];
+    /** default reasoning effort；未声明时为 undefined（codex 语义：不传 effort） */
+    defaultReasoningLevel: string | undefined;
+}
+/**
+ * Catalog mode = config.toml **声明了** model_catalog_json（键存在即算，不要求文件存在）。
+ * 依据：codex 运行时对"已配置但文件缺失/不可解析"的目录是硬错误
+ * （core/src/config/mod.rs load_model_catalog ?），绝不会回退内置目录；因此键存在即
+ * catalog 模式，文件缺失自然落入 `codex debug models` 失败路径 → 模型列表回退
+ * [currentModel]（P1-1）。
+ */
+export declare function isCodexCatalogMode(codexHome?: string): boolean;
+/**
+ * 单一解析器：把 `codex debug models`（活动目录）或 `--bundled`（内置目录）的原始 JSON
+ * 输出解析为模型列表（P2-4 去重）。过滤/排序镜像 codex：
+ * - show_in_picker = visibility == List（openai_models.rs ModelPreset::from）；
+ * - API 模式（lark 用 API key 认证）下 codex filter_by_auth 过滤 supported_in_api=false；
+ * - 按 priority 升序（build_available_models）。
+ * 档位按目录声明**原样透传**（含 custom/none，P2-5），不按标准枚举过滤、不虚构兜底：
+ * 未声明档位 → 空列表（codex with_model 语义：len=0 时用声明 default，都没有则不发
+ * effort；P1）。空串档位/空串 default 被过滤（P3-9：codex ReasoningEffort::from_str
+ * 对 "" 硬错误）。supported_in_api===true 过滤等价于 codex 的 chatgpt_mode ||
+ * supported_in_api：本项目以 API-key 模式运行 codex，chatgpt_mode 恒 false（P3-3）。
+ */
+export declare function parseCodexModelsOutput(stdout: string): BundledModelInfo[];
+/**
+ * 统一目录入口：catalog 模式（model_catalog_json 已声明，含声明退化 ''）跑
+ * `debug models`（无 --bundled），否则（未声明或 config.toml 解析失败）跑
+ * `debug models --bundled`。注（P3-4）：codex 无参 `debug models` 在
+ * uses_codex_backend()/has_command_auth() 时会请求远端 /models（models-manager
+ * manager.rs / models_endpoint.rs）；本项目以 API-key 模式运行（无 ChatGPT/命令
+ * 认证），结果与 bundled 一致，故非 catalog 用 --bundled（已文档化）。
+ * 缓存：键含 binary/home/mode/models.json mtime:size + config.toml mtime:size
+ * （P3-4/P3-15/P3-5）；成功结果 TTL 1h，失败/空结果短 TTL 负缓存；stat 异常时
+ * 指纹为空（P1-1/P3-10）。
+ */
+export declare function getCodexCatalogModels(binary: string, codexHome?: string): BundledModelInfo[];
+/**
+ * Test utility: clear the catalog cache. Tests that exercise the bundled
+ * command path (`--bundled`) directly use `invalidateCodexBundledTestCache`
+ * from `codex-bundled-test-helpers.ts`.
+ */
+export declare function invalidateCodexBundledCache(): void;
+/**
+ * Get supported reasoning effort options for a model.
+ * @param codexHome 可选 codex 配置目录覆盖（与 loadCodexConfig 的 codexHome 对齐，
+ *   与 loadCodexConfig 的 codexHome 对齐）；省略时走 $CODEX_HOME → ~/.codex。
+ */
+export declare function getReasoningEffortOptions(model: string, binary?: string, codexHome?: string): readonly string[];
+/**
+ * Get default reasoning effort for a model.
+ * 未声明/未知模型 → undefined（codex 语义：ModelPreset.default_reasoning_effort
+ * unwrap_or(ReasoningEffort::None)，即不传 effort；P3-12）。
+ */
+export declare function getDefaultReasoningEffort(model: string, binary?: string, codexHome?: string): string | undefined;
+interface LoadCodexConfigOpts {
+    /** Explicit codex home override. Default: $CODEX_HOME -> ~/.codex */
+    codexHome?: string;
+    /** codex binary path, for `debug models --bundled`. Default: 'codex' */
+    binary?: string;
+}
+/**
+ * Read codex config.toml, extract provider and model info
+ *
+ * Model filtering strategy:
+ * - Custom provider: model from config.toml (single model)
+ * - openai: all bundled models
+ * - anthropic: bundled models with 'claude-*' prefix
+ */
+export declare function loadCodexConfig(opts?: LoadCodexConfigOpts): CodexConfigResult;
+export {};