feishu-codex-console 1.0.0-beta.6

package/dist/account-quota-card.js

@@ -0,0 +1,233 @@
+export function renderAccountQuotaSummary(snapshot, prefix, detailsAction) {
+    const elements = [];
+    if (snapshot.status === "unavailable") {
+        elements.push(markdown(`${prefix}_sum_title`, "**账户额度**  <text_tag color='neutral'>暂不可用</text_tag>"), markdown(`${prefix}_sum_body`, `<font color='grey'>${safe(snapshot.message)}</font>`, "notation"));
+    }
+    else {
+        const visible = snapshot.limits.slice(0, 3);
+        const plan = visible.map((limit) => limit.planType).find(Boolean);
+        const summary = visible.map((limit) => {
+            const window = limit.primary ?? limit.secondary;
+            return window
+                ? `**${safe(shortLimitName(limit))} ${percent(window.remainingPercent)}**`
+                : `**${safe(shortLimitName(limit))} 暂无数据**`;
+        }).join("  ·  ");
+        const nearestReset = visible
+            .flatMap((limit) => [limit.primary, limit.secondary])
+            .filter((window) => Boolean(window?.resetsAt))
+            .sort((left, right) => Date.parse(left.resetsAt ?? "") - Date.parse(right.resetsAt ?? ""))[0];
+        const note = [
+            nearestReset?.resetsAt ? `最近 ${formatResetTime(nearestReset.resetsAt)} 重置` : "",
+            snapshot.resetCredits > 0 ? `${snapshot.resetCredits} 次可用重置` : "",
+        ].filter(Boolean).join(" · ");
+        elements.push(markdown(`${prefix}_sum_title`, `**账户额度**${plan ? `  <text_tag color='neutral'>${safe(planLabel(plan))}</text_tag>` : ""}`), markdown(`${prefix}_sum_body`, summary || "<font color='grey'>暂未返回额度窗口</font>"), ...(note
+            ? [markdown(`${prefix}_sum_note`, `<font color='grey'>${safe(note)}</font>`, "notation")]
+            : []));
+    }
+    if (detailsAction) {
+        elements.push({
+            tag: "button",
+            element_id: `${prefix}_quota_more`,
+            text: { tag: "plain_text", content: "查看额度详情" },
+            type: "default",
+            width: "fill",
+            behaviors: [
+                {
+                    type: "callback",
+                    value: detailsAction,
+                },
+            ],
+        });
+    }
+    return panel(`${prefix}_sum`, "grey-50", elements);
+}
+export function renderAccountQuotaPanel(snapshot, prefix) {
+    if (snapshot.status === "unavailable") {
+        return panel(prefix, "grey-50", [
+            markdown(`${prefix}_title`, "**账户额度**  <text_tag color='neutral'>暂不可用</text_tag>"),
+            markdown(`${prefix}_body`, `<font color='grey'>${safe(snapshot.message)}\n采样 ${safe(formatSampleTime(snapshot.sampledAt))}</font>`, "notation"),
+        ]);
+    }
+    const visible = snapshot.limits.slice(0, 4);
+    const remaining = visible.flatMap((limit) => [limit.primary, limit.secondary]
+        .filter((window) => Boolean(window))
+        .map((window) => window.remainingPercent));
+    const minimumRemaining = remaining.length > 0 ? Math.min(...remaining) : 100;
+    const reached = visible.some((limit) => Boolean(limit.reachedType));
+    const tone = reached || minimumRemaining <= 10
+        ? { background: "red-50", color: "red" }
+        : minimumRemaining <= 25
+            ? { background: "orange-50", color: "orange" }
+            : { background: "blue-50", color: "blue" };
+    const plan = visible.map((limit) => limit.planType).find(Boolean);
+    const body = visible.length > 0
+        ? visible.map(renderLimit).join("\n\n")
+        : "<font color='grey'>当前账户没有返回可展示的额度窗口。</font>";
+    const footer = [
+        snapshot.resetCredits > 0 ? `可用重置次数 ${snapshot.resetCredits}` : "",
+        `采样 ${formatSampleTime(snapshot.sampledAt)}`,
+    ].filter(Boolean).join(" · ");
+    return panel(prefix, tone.background, [
+        markdown(`${prefix}_title`, `**<font color='${tone.color}'>账户额度</font>**${plan ? `  <text_tag color='neutral'>${safe(planLabel(plan))}</text_tag>` : ""}`),
+        markdown(`${prefix}_body`, body),
+        markdown(`${prefix}_foot`, `<font color='grey'>${safe(footer)}</font>`, "notation"),
+    ]);
+}
+export function formatAccountQuotaText(snapshot) {
+    if (snapshot.status === "unavailable")
+        return [`- 账户额度：${snapshot.message}`];
+    const lines = snapshot.limits.flatMap((limit) => {
+        const windows = [limit.primary, limit.secondary]
+            .filter((window) => Boolean(window))
+            .map((window) => `${windowLabel(window)}剩余 ${percent(window.remainingPercent)}${resetLabel(window)}`);
+        return [`- ${limit.name}：${windows.join("；") || "未返回额度窗口"}`];
+    });
+    if (snapshot.resetCredits > 0)
+        lines.push(`- 可用额度重置次数：${snapshot.resetCredits}`);
+    return lines;
+}
+function renderLimit(limit) {
+    const windows = [limit.primary, limit.secondary]
+        .filter((window) => Boolean(window))
+        .map((window) => renderWindow(window));
+    const details = [
+        ...windows,
+        creditsLabel(limit),
+        spendLimitLabel(limit),
+        reachedLabel(limit.reachedType),
+    ].filter(Boolean);
+    return `**${safe(limit.name)}**${limit.id === "codex" ? "" : "  <text_tag color='neutral'>独立额度</text_tag>"}\n${details.join("\n") || "<font color='grey'>暂未返回额度窗口</font>"}`;
+}
+function shortLimitName(limit) {
+    if (limit.id === "codex")
+        return "Codex";
+    if (/spark/i.test(limit.name))
+        return "Spark";
+    return limit.name.length > 18 ? `${limit.name.slice(0, 17)}…` : limit.name;
+}
+function renderWindow(window) {
+    const color = window.remainingPercent <= 10 ? "red" : window.remainingPercent <= 25 ? "orange" : "green";
+    return `${quotaBar(window.remainingPercent)}  **<font color='${color}'>剩余 ${percent(window.remainingPercent)}</font>**\n<font color='grey'>${safe(windowLabel(window))}${safe(resetLabel(window))}</font>`;
+}
+function creditsLabel(limit) {
+    if (limit.credits?.unlimited)
+        return "<font color='grey'>积分额度不限</font>";
+    if (limit.credits?.hasCredits && limit.credits.balance) {
+        return `<font color='grey'>积分余额 ${safe(limit.credits.balance)}</font>`;
+    }
+    return "";
+}
+function spendLimitLabel(limit) {
+    const spend = limit.individualLimit;
+    if (!spend)
+        return "";
+    const reset = spend.resetsAt ? ` · ${formatResetTime(spend.resetsAt)} 重置` : "";
+    return `<font color='grey'>个人用量上限剩余 ${percent(spend.remainingPercent)} · ${safe(spend.used)} / ${safe(spend.limit)}${safe(reset)}</font>`;
+}
+function reachedLabel(reachedType) {
+    if (!reachedType)
+        return "";
+    return `<font color='red'>当前额度已受限：${safe(reachedTypeLabel(reachedType))}</font>`;
+}
+function quotaBar(remainingPercent) {
+    const filled = Math.max(0, Math.min(10, Math.round(remainingPercent / 10)));
+    return `${"■".repeat(filled)}${"□".repeat(10 - filled)}`;
+}
+function windowLabel(window) {
+    const minutes = window.windowDurationMins;
+    if (!minutes)
+        return "滚动窗口";
+    if (minutes % (24 * 60) === 0)
+        return `${minutes / (24 * 60)} 天窗口`;
+    if (minutes % 60 === 0)
+        return `${minutes / 60} 小时窗口`;
+    return `${minutes} 分钟窗口`;
+}
+function resetLabel(window) {
+    return window.resetsAt ? ` · ${formatResetTime(window.resetsAt)} 重置` : "";
+}
+function formatResetTime(value) {
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()))
+        return "时间未知";
+    return date.toLocaleString("zh-CN", {
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    });
+}
+function formatSampleTime(value) {
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()))
+        return "时间未知";
+    return date.toLocaleTimeString("zh-CN", {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    });
+}
+function percent(value) {
+    return `${Number.isInteger(value) ? value : value.toFixed(1)}%`;
+}
+function planLabel(value) {
+    return {
+        free: "Free",
+        go: "Go",
+        plus: "Plus",
+        pro: "Pro",
+        prolite: "Pro Lite",
+        team: "Team",
+        self_serve_business_usage_based: "Business",
+        business: "Business",
+        enterprise_cbp_usage_based: "Enterprise",
+        enterprise: "Enterprise",
+        edu: "Edu",
+        unknown: "Codex",
+    }[value] ?? value;
+}
+function reachedTypeLabel(value) {
+    return {
+        rate_limit_reached: "滚动额度已用尽",
+        workspace_owner_credits_depleted: "工作区积分已用尽",
+        workspace_member_credits_depleted: "成员积分已用尽",
+        workspace_owner_usage_limit_reached: "工作区用量上限已达到",
+        workspace_member_usage_limit_reached: "成员用量上限已达到",
+    }[value] ?? value;
+}
+function panel(prefix, background, elements) {
+    return {
+        tag: "column_set",
+        element_id: `${prefix}_panel`,
+        flex_mode: "none",
+        columns: [
+            {
+                tag: "column",
+                width: "weighted",
+                weight: 1,
+                background_style: background,
+                padding: "12px 12px 12px 12px",
+                vertical_spacing: "6px",
+                elements,
+            },
+        ],
+    };
+}
+function markdown(elementId, content, textSize) {
+    return {
+        tag: "markdown",
+        element_id: elementId,
+        ...(textSize ? { text_size: textSize } : {}),
+        content,
+    };
+}
+function safe(value) {
+    return value
+        .replaceAll("&", "＆")
+        .replaceAll("<", "＜")
+        .replaceAll(">", "＞")
+        .replaceAll("*", "＊")
+        .replaceAll("_", "＿")
+        .replaceAll("`", "｀");
+}

package/dist/account-quota.js

@@ -0,0 +1,125 @@
+export function normalizeAccountQuotaResponse(value, sampledAt = new Date().toISOString()) {
+    const response = asRecord(value);
+    const byLimitId = asRecord(response.rateLimitsByLimitId);
+    const candidates = [
+        { value: response.rateLimits },
+        ...Object.entries(byLimitId).map(([fallbackId, entry]) => ({ value: entry, fallbackId })),
+    ];
+    const limits = new Map();
+    for (const candidate of candidates) {
+        const limit = normalizeLimit(candidate.value, candidate.fallbackId);
+        if (limit && !limits.has(limit.id))
+            limits.set(limit.id, limit);
+    }
+    return {
+        status: "available",
+        sampledAt,
+        limits: [...limits.values()],
+        resetCredits: nonNegativeInteger(asRecord(response.rateLimitResetCredits).availableCount),
+    };
+}
+export function unavailableAccountQuota(sampledAt = new Date().toISOString()) {
+    return {
+        status: "unavailable",
+        sampledAt,
+        message: "Codex 暂未返回账户额度，请确认登录状态后刷新。",
+    };
+}
+function normalizeLimit(value, fallbackId) {
+    const raw = asRecord(value);
+    if (Object.keys(raw).length === 0)
+        return null;
+    const id = stringValue(raw.limitId) ?? fallbackId ?? "codex";
+    const name = stringValue(raw.limitName) ?? (id === "codex" ? "Codex" : id);
+    const primary = normalizeWindow(raw.primary);
+    const secondary = normalizeWindow(raw.secondary);
+    const credits = normalizeCredits(raw.credits);
+    const individualLimit = normalizeSpendLimit(raw.individualLimit);
+    const planType = stringValue(raw.planType);
+    const reachedType = stringValue(raw.rateLimitReachedType);
+    return {
+        id,
+        name,
+        ...(planType ? { planType } : {}),
+        ...(primary ? { primary } : {}),
+        ...(secondary ? { secondary } : {}),
+        ...(credits ? { credits } : {}),
+        ...(individualLimit ? { individualLimit } : {}),
+        ...(reachedType ? { reachedType } : {}),
+    };
+}
+function normalizeWindow(value) {
+    const raw = asRecord(value);
+    const used = finiteNumber(raw.usedPercent);
+    if (used === undefined)
+        return undefined;
+    const usedPercent = clamp(used, 0, 100);
+    const duration = finiteNumber(raw.windowDurationMins);
+    const resetsAt = timestampIso(raw.resetsAt);
+    return {
+        usedPercent,
+        remainingPercent: clamp(100 - usedPercent, 0, 100),
+        ...(duration !== undefined && duration > 0 ? { windowDurationMins: duration } : {}),
+        ...(resetsAt ? { resetsAt } : {}),
+    };
+}
+function normalizeCredits(value) {
+    const raw = asRecord(value);
+    if (Object.keys(raw).length === 0)
+        return undefined;
+    const balance = stringValue(raw.balance);
+    return {
+        hasCredits: raw.hasCredits === true,
+        unlimited: raw.unlimited === true,
+        ...(balance !== undefined ? { balance } : {}),
+    };
+}
+function normalizeSpendLimit(value) {
+    const raw = asRecord(value);
+    const limit = stringValue(raw.limit);
+    const used = stringValue(raw.used);
+    const remaining = finiteNumber(raw.remainingPercent);
+    if (!limit || !used || remaining === undefined)
+        return undefined;
+    const resetsAt = timestampIso(raw.resetsAt);
+    return {
+        limit,
+        used,
+        remainingPercent: clamp(remaining, 0, 100),
+        ...(resetsAt ? { resetsAt } : {}),
+    };
+}
+function timestampIso(value) {
+    const timestamp = finiteNumber(value);
+    if (timestamp === undefined || timestamp <= 0)
+        return undefined;
+    const date = new Date(timestamp < 1_000_000_000_000 ? timestamp * 1_000 : timestamp);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : undefined;
+}
+function finiteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function nonNegativeInteger(value) {
+    if (typeof value === "bigint")
+        return Number(value > 0n ? value : 0n);
+    const parsed = finiteNumber(value);
+    return parsed === undefined ? 0 : Math.max(0, Math.trunc(parsed));
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+function clamp(value, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, value));
+}

package/dist/app-server-client.js

@@ -0,0 +1,281 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import path from "node:path";
+import readline from "node:readline";
+import { redactSensitiveText, safeErrorText } from "./redaction.js";
+export class AppServerRpcError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "AppServerRpcError";
+    }
+}
+export class CodexAppServerClient {
+    options;
+    child = null;
+    lines = null;
+    nextId = 1;
+    pending = new Map();
+    startPromise = null;
+    closing = false;
+    health = { ready: false, restartCount: 0 };
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        if (this.health.ready && this.child)
+            return;
+        if (this.startPromise)
+            return this.startPromise;
+        this.startPromise = this.startInternal().finally(() => {
+            this.startPromise = null;
+        });
+        return this.startPromise;
+    }
+    async request(method, params, timeoutMs) {
+        await this.start();
+        return this.sendRequest(method, params, timeoutMs);
+    }
+    notify(method, params) {
+        if (!this.child || !this.child.stdin.writable) {
+            throw new Error("Codex app-server is not connected");
+        }
+        this.write({ method, ...(params === undefined ? {} : { params }) });
+    }
+    getHealth() {
+        return { ...this.health };
+    }
+    async close() {
+        this.closing = true;
+        this.health.ready = false;
+        const child = this.child;
+        if (!child)
+            return;
+        this.child = null;
+        this.lines?.close();
+        this.lines = null;
+        rejectPending(this.pending, new Error("Codex app-server closed"));
+        if (child.exitCode !== null || child.signalCode !== null)
+            return;
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                if (!child.killed)
+                    child.kill("SIGKILL");
+                resolve();
+            }, 2_000);
+            timer.unref();
+            child.once("exit", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            child.kill("SIGTERM");
+        });
+    }
+    async startInternal() {
+        this.closing = false;
+        const command = this.options.command ?? resolveBundledCodexCommand();
+        const child = spawn(command.command, command.args, {
+            env: this.options.env,
+            shell: false,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child = child;
+        this.health.ready = false;
+        this.health.startedAt = Date.now();
+        if (child.pid !== undefined)
+            this.health.pid = child.pid;
+        else
+            delete this.health.pid;
+        delete this.health.lastError;
+        let stderrTail = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderrTail = `${stderrTail}${chunk}`.slice(-4_000);
+            for (const line of chunk.split(/\r?\n/).filter(Boolean)) {
+                console.error(`[codex-app-server] ${redactSensitiveText(line, 1_000)}`);
+            }
+        });
+        const spawned = new Promise((resolve, reject) => {
+            child.once("spawn", resolve);
+            child.once("error", reject);
+        });
+        child.once("exit", (code, signal) => {
+            this.handleExit(child, code, signal, stderrTail);
+        });
+        this.lines = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+        this.lines.on("line", (line) => this.handleLine(line));
+        try {
+            await spawned;
+            await this.sendRequest("initialize", {
+                clientInfo: {
+                    name: "feishu_codex_bridge",
+                    title: "Feishu Remote for Codex",
+                    version: "1.0.0-beta.2",
+                },
+                capabilities: {
+                    experimentalApi: true,
+                    requestAttestation: false,
+                },
+            }, 20_000);
+            this.notify("initialized", {});
+            this.health.ready = true;
+        }
+        catch (error) {
+            this.health.lastError = safeErrorText(error);
+            if (!child.killed)
+                child.kill("SIGTERM");
+            throw error;
+        }
+    }
+    sendRequest(method, params, timeoutMs) {
+        if (!this.child || !this.child.stdin.writable) {
+            return Promise.reject(new Error("Codex app-server is not connected"));
+        }
+        const id = this.nextId++;
+        const timeout = setTimeout(() => {
+            const pending = this.pending.get(String(id));
+            if (!pending)
+                return;
+            this.pending.delete(String(id));
+            pending.reject(new Error(`Codex app-server request timed out: ${method}`));
+        }, timeoutMs ?? this.options.requestTimeoutMs ?? 30_000);
+        timeout.unref();
+        const result = new Promise((resolve, reject) => {
+            this.pending.set(String(id), {
+                method,
+                resolve: (value) => resolve(value),
+                reject,
+                timeout,
+            });
+        });
+        try {
+            this.write({ method, id, ...(params === undefined ? {} : { params }) });
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            this.pending.delete(String(id));
+            return Promise.reject(error);
+        }
+        return result;
+    }
+    write(message) {
+        const child = this.child;
+        if (!child || !child.stdin.writable)
+            throw new Error("Codex app-server stdin is unavailable");
+        child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            console.error(`[codex-app-server] ignored non-JSON output: ${redactSensitiveText(line, 500)}`);
+            return;
+        }
+        if (!isRecord(message))
+            return;
+        if ((typeof message.id === "string" || typeof message.id === "number") && !message.method) {
+            this.handleResponse(message);
+            return;
+        }
+        if (typeof message.method !== "string")
+            return;
+        if (typeof message.id === "string" || typeof message.id === "number") {
+            void this.handleServerRequest({
+                id: message.id,
+                method: message.method,
+                ...(message.params === undefined ? {} : { params: message.params }),
+            });
+            return;
+        }
+        try {
+            this.options.onNotification?.({
+                method: message.method,
+                ...(message.params === undefined ? {} : { params: message.params }),
+            });
+        }
+        catch (error) {
+            console.error(`[codex-app-server] notification handler failed method=${message.method}`, error);
+        }
+    }
+    handleResponse(response) {
+        const pending = this.pending.get(String(response.id));
+        if (!pending)
+            return;
+        this.pending.delete(String(response.id));
+        clearTimeout(pending.timeout);
+        if (response.error) {
+            pending.reject(new AppServerRpcError(response.error.message ?? `Codex app-server request failed: ${pending.method}`, response.error.code, response.error.data));
+            return;
+        }
+        pending.resolve(response.result);
+    }
+    async handleServerRequest(request) {
+        try {
+            if (!this.options.onRequest) {
+                throw new AppServerRpcError(`Unsupported server request: ${request.method}`, -32601);
+            }
+            const result = await this.options.onRequest(request);
+            this.write({ id: request.id, result });
+        }
+        catch (error) {
+            const rpcError = error instanceof AppServerRpcError ? error : null;
+            try {
+                this.write({
+                    id: request.id,
+                    error: {
+                        code: rpcError?.code ?? -32000,
+                        message: safeErrorText(error),
+                        ...(rpcError?.data === undefined ? {} : { data: rpcError.data }),
+                    },
+                });
+            }
+            catch (writeError) {
+                console.error(`[codex-app-server] unable to answer request method=${request.method}`, writeError);
+            }
+        }
+    }
+    handleExit(child, code, signal, stderrTail) {
+        if (this.child !== child)
+            return;
+        this.child = null;
+        this.lines?.close();
+        this.lines = null;
+        this.health.ready = false;
+        delete this.health.pid;
+        this.health.lastExitAt = Date.now();
+        if (!this.closing)
+            this.health.restartCount += 1;
+        const detail = signal ? `signal ${signal}` : `code ${code ?? 1}`;
+        const suffix = stderrTail.trim()
+            ? `: ${redactSensitiveText(stderrTail.trim().slice(-1_000))}`
+            : "";
+        const error = new Error(`Codex app-server exited with ${detail}${suffix}`);
+        this.health.lastError = error.message;
+        rejectPending(this.pending, error);
+        if (!this.closing)
+            this.options.onExit?.(error);
+    }
+}
+export function resolveBundledCodexCommand(extraArgs = []) {
+    const require = createRequire(import.meta.url);
+    const packageJson = require.resolve("@openai/codex/package.json");
+    return {
+        command: process.execPath,
+        args: [path.join(path.dirname(packageJson), "bin", "codex.js"), "app-server", ...extraArgs],
+    };
+}
+function rejectPending(pending, error) {
+    for (const call of pending.values()) {
+        clearTimeout(call.timeout);
+        call.reject(error);
+    }
+    pending.clear();
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}