feishu-codex-console 1.0.0-beta.6

package/dist/task-center-card.js

@@ -0,0 +1,176 @@
+import { hasTaskValidation } from "./task-card.js";
+import { taskModeLabel, taskModeOf } from "./task-intent.js";
+export function renderTaskCenterCard(snapshot) {
+    return {
+        schema: "2.0",
+        config: {
+            update_multi: true,
+            width_mode: "default",
+            enable_forward: false,
+            summary: { content: `Codex 任务中心 · 运行 ${snapshot.running} · 排队 ${snapshot.queued}` },
+        },
+        header: {
+            title: { tag: "plain_text", content: "Codex 任务中心" },
+            subtitle: { tag: "plain_text", content: snapshot.scopeLabel },
+            template: snapshot.running > 0 ? "blue" : "green",
+            icon: { tag: "standard_icon", token: "tasklist_colorful" },
+            text_tag_list: [
+                { tag: "text_tag", text: { tag: "plain_text", content: `运行 ${snapshot.running}` }, color: "blue" },
+                { tag: "text_tag", text: { tag: "plain_text", content: `排队 ${snapshot.queued}` }, color: "neutral" },
+            ],
+        },
+        body: {
+            direction: "vertical",
+            padding: "12px 12px 18px 12px",
+            vertical_spacing: "10px",
+            elements: [
+                ...(snapshot.tasks.length > 0
+                    ? snapshot.tasks
+                        .slice(0, 8)
+                        .map((task, index) => taskRow(task, index, snapshot.canOperate, snapshot.people?.[task.id]))
+                    : [
+                        {
+                            tag: "markdown",
+                            element_id: "tasks_empty",
+                            content: "**暂无任务**\n<font color='grey'>直接发送问题、分析要求、文档需求或代码任务即可开始。</font>",
+                        },
+                    ]),
+                actionGrid("task_actions", snapshot.canOperate
+                    ? [
+                        button("停止本会话", "tasks_stop", "danger", undefined, {
+                            title: "停止本会话任务？",
+                            text: "当前会话的运行和排队任务都会停止，已写入文件的修改不会撤销。",
+                        }),
+                        button("本会话重置", "tasks_new", "primary"),
+                        button("控制中心", "tasks_settings", "default"),
+                        button("刷新", "tasks_refresh", "default"),
+                    ]
+                    : [
+                        button("控制中心", "tasks_settings", "default"),
+                        button("刷新", "tasks_refresh", "default"),
+                    ]),
+            ],
+        },
+    };
+}
+function taskRow(task, index, canOperate, people) {
+    const final = task.progress.finalResponse || task.progress.error || task.progress.activity;
+    const active = task.status === "running" || task.status === "queued";
+    return {
+        tag: "column_set",
+        element_id: `task_row_${index}`,
+        flex_mode: "none",
+        columns: [
+            {
+                tag: "column",
+                width: "weighted",
+                weight: 1,
+                background_style: task.status === "running" ? "blue-50" : "grey-50",
+                padding: "10px 12px 10px 12px",
+                vertical_spacing: "4px",
+                elements: [
+                    {
+                        tag: "markdown",
+                        element_id: `task_title_${index}`,
+                        content: `**${safe(task.prompt).slice(0, 90)}**  ${statusTag(task.status)}  <text_tag color='turquoise'>${taskModeLabel(taskModeOf(task.progress))}</text_tag>\n<font color='grey'>#${safe(task.id).slice(0, 12)} · ${safe(task.project.name)} · ${relativeTime(task.updatedAt)}</font>${people ? `\n<font color='grey'>发起 ${safe(people.initiator)} · 控制 ${safe(people.controller)}</font>` : ""}\n${safe(final).slice(0, 160)}`,
+                    },
+                ],
+            },
+            ...(active && canOperate
+                ? [
+                    {
+                        tag: "column",
+                        width: "auto",
+                        vertical_align: "center",
+                        elements: [
+                            button("停止", "tasks_cancel_one", "danger", task.id, {
+                                title: "停止这个任务？",
+                                text: "已写入文件的修改不会自动撤销。",
+                            }, `task_cancel_${index}`),
+                        ],
+                    },
+                ]
+                : !active && hasTaskValidation(task.progress)
+                    ? [
+                        {
+                            tag: "column",
+                            width: "auto",
+                            vertical_align: "center",
+                            elements: [
+                                button("审阅", "tasks_review", "primary", task.id, undefined, `task_review_${index}`),
+                            ],
+                        },
+                    ]
+                    : []),
+        ],
+    };
+}
+function button(text, action, type, taskId, confirm, elementId = action.slice(0, 20)) {
+    const result = {
+        tag: "button",
+        element_id: elementId,
+        text: { tag: "plain_text", content: text },
+        type: type === "danger" ? "danger_filled" : type === "primary" ? "primary_filled" : "default",
+        width: "fill",
+        behaviors: [
+            {
+                type: "callback",
+                value: {
+                    bridge: "feishu-codex-v5",
+                    action,
+                    ...(taskId ? { task_id: taskId } : {}),
+                },
+            },
+        ],
+    };
+    if (confirm) {
+        result.confirm = {
+            title: { tag: "plain_text", content: confirm.title },
+            text: { tag: "plain_text", content: confirm.text },
+        };
+    }
+    return result;
+}
+function actionGrid(id, actions) {
+    return {
+        tag: "column_set",
+        element_id: id,
+        flex_mode: "none",
+        horizontal_spacing: "8px",
+        columns: actions.map((action) => ({
+            tag: "column",
+            width: "weighted",
+            weight: 1,
+            elements: [action],
+        })),
+    };
+}
+function statusTag(status) {
+    if (status === "running")
+        return "<text_tag color='blue'>运行中</text_tag>";
+    if (status === "queued")
+        return "<text_tag color='neutral'>排队中</text_tag>";
+    if (status === "succeeded")
+        return "<text_tag color='green'>已完成</text_tag>";
+    if (status === "failed")
+        return "<text_tag color='red'>失败</text_tag>";
+    if (status === "interrupted")
+        return "<text_tag color='neutral'>已中断</text_tag>";
+    return "<text_tag color='neutral'>已停止</text_tag>";
+}
+function relativeTime(value) {
+    const timestamp = Date.parse(value);
+    if (!Number.isFinite(timestamp))
+        return "未知时间";
+    const seconds = Math.max(0, Math.floor((Date.now() - timestamp) / 1_000));
+    if (seconds < 60)
+        return "刚刚";
+    if (seconds < 3_600)
+        return `${Math.floor(seconds / 60)} 分钟前`;
+    if (seconds < 86_400)
+        return `${Math.floor(seconds / 3_600)} 小时前`;
+    return `${Math.floor(seconds / 86_400)} 天前`;
+}
+function safe(value) {
+    return value.replaceAll("<", "＜").replaceAll(">", "＞").replaceAll("*", "＊").replaceAll("`", "｀");
+}

package/dist/task-failure.js

@@ -0,0 +1,43 @@
+export function taskFailurePresentation(message) {
+    const normalized = message.toLocaleLowerCase();
+    if (/timeout|timed out|超时/.test(normalized)) {
+        return {
+            kind: "timeout",
+            title: "任务超过运行时限",
+            nextAction: "先查看已经写入的文件变更，再缩小任务范围或调整 CODEX_TIMEOUT_MS 后重试。",
+        };
+    }
+    if (/安全闸门|policy|not allowed|blocked command|禁止/.test(normalized)) {
+        return {
+            kind: "policy",
+            title: "安全策略已停止任务",
+            nextAction: "修改任务要求；如果确实需要提交、推送、部署或 PR，请通过确认卡单独授权。",
+        };
+    }
+    if (/permission denied|eacces|operation not permitted|权限不足|无权/.test(normalized)) {
+        return {
+            kind: "permission",
+            title: "当前权限不足",
+            nextAction: "检查成员角色、项目 ACL 和本轮任务权限；不要直接扩大到完全访问。",
+        };
+    }
+    if (/app-server|connection|socket|econn|broken pipe|连接|断开|closed/.test(normalized)) {
+        return {
+            kind: "connection",
+            title: "Codex 连接中断",
+            nextAction: "先在设备控制台重连 Codex，确认在线后再重试；已写入的文件不会自动回滚。",
+        };
+    }
+    if (/queue|队列/.test(normalized)) {
+        return {
+            kind: "queue",
+            title: "任务未能进入队列",
+            nextAction: "等待当前任务结束，或停止不再需要的排队任务后重试。",
+        };
+    }
+    return {
+        kind: "unknown",
+        title: "任务执行失败",
+        nextAction: "先查看文件变更和错误原因；可以重试，仍失败时运行 doctor 并查看本地日志。",
+    };
+}

package/dist/task-intent.js

@@ -0,0 +1,76 @@
+const QUESTION_OPENING = /^(?:请问|问[:：]?|为什么|为何|什么是|是什么|怎么|如何|能否|能不能|是否|有没有|解释(?:一下)?|说明(?:一下)?|告诉我|帮我解释)/i;
+const FOLLOWED_BY_MUTATION = /(?:[,，:：；;。]|并|然后|同时|顺便|接着).{0,16}(?:修复|修改|实现|开发|新增|添加|删除|重构|升级|接入|迁移|替换|改成|写入|优化|调整)/i;
+const DOCUMENT_TARGET = /(?:文档|说明(?:书)?|报告|方案|总结|纪要|教程|指南|README|CHANGELOG|markdown|\.md\b)/i;
+const DOCUMENT_ACTION = /(?:写|撰写|起草|生成|创建|整理|补充|更新|修改|完善|优化|润色|改写|翻译|输出)/i;
+const GENERIC_WRITING = /(?:写(?:入|一个|一份)?(?:文件|内容)|保存为文件|落到文件)/i;
+const CODE_MUTATION = /(?:修复|修改|改一下|改成|实现|开发|新增|添加|删除|移除|重构|升级|接入|迁移|替换|调整|优化|配置|部署|发布|编写.{0,12}(?:代码|脚本|组件|接口|测试)|补(?:齐|充)?.{0,8}(?:代码|测试)|运行.{0,8}(?:测试|lint|build|构建))/i;
+const ANALYSIS_OPENING = /^(?:读取|阅读|查看|看看|看一下|分析|检查|审查|评审|诊断|定位|梳理|总结|评估|调研|研究|搜索|查找|找出|列出|统计|了解|解释这个项目)/i;
+const ANALYSIS_PHRASE = /(?:原因是什么|有哪些问题|有没有问题|项目结构|代码结构|现状|差异|风险|可行性|给出建议)/i;
+/**
+ * Local presentation/safety routing only. Codex still receives the original
+ * prompt unchanged, so a heuristic miss cannot alter the requested content.
+ */
+export function inferTaskMode(prompt) {
+    const normalized = prompt.trim().replace(/\s+/g, " ");
+    if (!normalized)
+        return "code";
+    if (QUESTION_OPENING.test(normalized) && !FOLLOWED_BY_MUTATION.test(normalized)) {
+        return "answer";
+    }
+    if ((DOCUMENT_TARGET.test(normalized) && DOCUMENT_ACTION.test(normalized)) ||
+        GENERIC_WRITING.test(normalized)) {
+        return "write";
+    }
+    // “看看/分析有没有可以优化的地方” is a request for findings, not
+    // authorization to modify the workspace. Only an explicit follow-up
+    // mutation (“然后修复”) promotes an analysis opening into a write task.
+    if (ANALYSIS_OPENING.test(normalized) && !FOLLOWED_BY_MUTATION.test(normalized)) {
+        return "analyze";
+    }
+    if (CODE_MUTATION.test(normalized))
+        return "code";
+    if (ANALYSIS_PHRASE.test(normalized))
+        return "analyze";
+    if (/[?？]\s*$/.test(normalized))
+        return "answer";
+    return "code";
+}
+export function taskModeOf(value) {
+    return value.taskMode ?? inferTaskMode(value.prompt);
+}
+export function taskModeLabel(mode) {
+    return {
+        answer: "问答",
+        analyze: "分析",
+        write: "内容",
+        code: "代码",
+    }[mode];
+}
+export function taskModeAllowsWrites(mode) {
+    return mode === "write" || mode === "code";
+}
+export function taskModeCapturesReview(mode) {
+    return taskModeAllowsWrites(mode);
+}
+export function taskModeExpectsTests(mode) {
+    return mode === "code";
+}
+export function sandboxForTaskMode(mode, requested) {
+    return taskModeAllowsWrites(mode) ? requested : "read-only";
+}
+export function runningActivity(mode) {
+    return {
+        answer: "Codex 正在回答",
+        analyze: "Codex 正在分析",
+        write: "Codex 正在生成内容",
+        code: "Codex 正在执行任务",
+    }[mode];
+}
+export function completedActivity(mode) {
+    return {
+        answer: "回答完成",
+        analyze: "分析完成",
+        write: "内容已生成",
+        code: "任务完成",
+    }[mode];
+}

package/dist/task-queue.js

@@ -0,0 +1,187 @@
+export class QueueCapacityError extends Error {
+    conversationKey;
+    constructor(conversationKey) {
+        super("This conversation already has the maximum number of queued tasks");
+        this.conversationKey = conversationKey;
+        this.name = "QueueCapacityError";
+    }
+}
+export class TaskQueue {
+    maxConcurrency;
+    maxQueuedPerConversation;
+    pending = [];
+    activeJobs = new Map();
+    activeConversations = new Set();
+    activeResources = new Set();
+    idleWaiters = new Set();
+    paused = false;
+    constructor(maxConcurrency = 2, maxQueuedPerConversation = 5) {
+        this.maxConcurrency = maxConcurrency;
+        this.maxQueuedPerConversation = maxQueuedPerConversation;
+        if (!Number.isSafeInteger(maxConcurrency) || maxConcurrency <= 0) {
+            throw new Error("maxConcurrency must be a positive integer");
+        }
+        if (!Number.isSafeInteger(maxQueuedPerConversation) || maxQueuedPerConversation <= 0) {
+            throw new Error("maxQueuedPerConversation must be a positive integer");
+        }
+    }
+    enqueue(job) {
+        if (this.paused)
+            throw new Error("Task queue is paused");
+        if (this.queuedForConversation(job.conversationKey) >= this.maxQueuedPerConversation) {
+            throw new QueueCapacityError(job.conversationKey);
+        }
+        this.pending.push(job);
+        const position = this.positionForTask(job.id, job.conversationKey);
+        this.notifyPositions();
+        void this.drain();
+        return position;
+    }
+    nextPosition(conversationKey) {
+        return (this.queuedForConversation(conversationKey) +
+            (this.activeConversations.has(conversationKey) ? 1 : 0) +
+            1);
+    }
+    canEnqueue(conversationKey) {
+        return this.queuedForConversation(conversationKey) < this.maxQueuedPerConversation;
+    }
+    cancelPending(conversationKey) {
+        let removed = 0;
+        for (let index = this.pending.length - 1; index >= 0; index -= 1) {
+            if (this.pending[index]?.conversationKey === conversationKey) {
+                const [job] = this.pending.splice(index, 1);
+                if (job)
+                    this.notifyCancelled(job);
+                removed += 1;
+            }
+        }
+        if (removed > 0)
+            this.notifyPositions();
+        return removed;
+    }
+    cancelAllPending() {
+        const count = this.pending.length;
+        const jobs = this.pending.splice(0);
+        for (const job of jobs)
+            this.notifyCancelled(job);
+        if (count > 0)
+            this.notifyPositions();
+        return count;
+    }
+    cancelTask(taskId) {
+        const index = this.pending.findIndex((job) => job.id === taskId);
+        if (index < 0)
+            return false;
+        const [job] = this.pending.splice(index, 1);
+        if (job)
+            this.notifyCancelled(job);
+        this.notifyPositions();
+        return true;
+    }
+    get pendingCount() {
+        return this.pending.length;
+    }
+    get active() {
+        return this.activeJobs.values().next().value ?? null;
+    }
+    get activeCount() {
+        return this.activeJobs.size;
+    }
+    getActiveTask(conversationKey) {
+        for (const job of this.activeJobs.values()) {
+            if (job.conversationKey === conversationKey)
+                return job.id;
+        }
+        return undefined;
+    }
+    pause() {
+        this.paused = true;
+    }
+    waitForIdle() {
+        if (this.activeJobs.size === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => this.idleWaiters.add(resolve));
+    }
+    queuedForConversation(conversationKey) {
+        return this.pending.filter((job) => job.conversationKey === conversationKey).length;
+    }
+    async drain() {
+        if (this.paused)
+            return;
+        while (this.activeJobs.size < this.maxConcurrency) {
+            const index = this.pending.findIndex((job) => !this.activeConversations.has(job.conversationKey) &&
+                !this.activeResources.has(this.resourceKey(job)));
+            if (index < 0)
+                return;
+            const [next] = this.pending.splice(index, 1);
+            if (!next)
+                return;
+            this.activeJobs.set(next.id, next);
+            this.activeConversations.add(next.conversationKey);
+            this.activeResources.add(this.resourceKey(next));
+            this.notifyPositions();
+            void this.runJob(next);
+        }
+    }
+    async runJob(job) {
+        try {
+            await job.run();
+        }
+        catch (error) {
+            console.error(`[queue] unhandled task error id=${job.id}`, error);
+        }
+        finally {
+            this.activeJobs.delete(job.id);
+            this.activeConversations.delete(job.conversationKey);
+            this.activeResources.delete(this.resourceKey(job));
+            this.notifyPositions();
+            if (this.activeJobs.size === 0) {
+                for (const resolve of this.idleWaiters)
+                    resolve();
+                this.idleWaiters.clear();
+            }
+            void this.drain();
+        }
+    }
+    resourceKey(job) {
+        return job.resourceKey ?? `conversation:${job.conversationKey}`;
+    }
+    positionForTask(taskId, conversationKey) {
+        let position = this.activeConversations.has(conversationKey) ? 1 : 0;
+        for (const job of this.pending) {
+            if (job.conversationKey !== conversationKey)
+                continue;
+            position += 1;
+            if (job.id === taskId)
+                return position;
+        }
+        return Math.max(1, position);
+    }
+    notifyCancelled(job) {
+        try {
+            void Promise.resolve(job.onCancel?.()).catch((error) => {
+                console.error(`[queue] cancellation hook failed id=${job.id}`, error);
+            });
+        }
+        catch (error) {
+            console.error(`[queue] cancellation hook failed id=${job.id}`, error);
+        }
+    }
+    notifyPositions() {
+        const positions = new Map();
+        for (const conversationKey of this.activeConversations)
+            positions.set(conversationKey, 1);
+        for (const job of this.pending) {
+            const position = (positions.get(job.conversationKey) ?? 0) + 1;
+            positions.set(job.conversationKey, position);
+            try {
+                void Promise.resolve(job.onPositionChange?.(position)).catch((error) => {
+                    console.error(`[queue] position hook failed id=${job.id}`, error);
+                });
+            }
+            catch (error) {
+                console.error(`[queue] position hook failed id=${job.id}`, error);
+            }
+        }
+    }
+}

package/dist/task-reconciliation.js

@@ -0,0 +1,80 @@
+const TERMINAL = new Set([
+    "succeeded",
+    "failed",
+    "cancelled",
+    "interrupted",
+]);
+/**
+ * Reconciles the independently persisted task status and CardKit progress state.
+ * The result deliberately prefers "do not replay" over convenience: any evidence
+ * that a task started or reached a terminal state prevents it from being treated
+ * as a fresh queued task after a crash.
+ */
+export function reconcilePersistedTask(task) {
+    const recordStatus = task.status;
+    const cardStatus = task.progress.phase;
+    const canonical = canonicalStatus(task);
+    const changed = recordStatus !== canonical || cardStatus !== canonical;
+    if (!changed)
+        return { task, changed: false };
+    const reason = `状态对账：任务记录 ${recordStatus}、卡片 ${cardStatus}，统一为 ${canonical}`;
+    return {
+        changed: true,
+        reason,
+        task: {
+            ...task,
+            status: canonical,
+            progress: reconcileProgress(task.progress, canonical, reason, task.updatedAt),
+            updatedAt: new Date().toISOString(),
+        },
+    };
+}
+function canonicalStatus(task) {
+    if (TERMINAL.has(task.status))
+        return task.status;
+    if (TERMINAL.has(task.progress.phase))
+        return task.progress.phase;
+    if (task.status === "running" ||
+        task.progress.phase === "running" ||
+        (task.progress.startedAt !== null && task.progress.finishedAt === null) ||
+        Boolean(task.progress.threadId)) {
+        return "running";
+    }
+    return "queued";
+}
+function reconcileProgress(progress, status, reason, updatedAt) {
+    const terminal = TERMINAL.has(status);
+    const finishedAt = terminal
+        ? progress.finishedAt ?? validTime(updatedAt) ?? Date.now()
+        : null;
+    return {
+        ...progress,
+        phase: status,
+        activity: activityFor(status),
+        startedAt: status === "running" && progress.startedAt === null
+            ? validTime(updatedAt) ?? progress.createdAt
+            : progress.startedAt,
+        finishedAt,
+        actionNote: [progress.actionNote, reason].filter(Boolean).join(" · ").slice(0, 1_000),
+    };
+}
+function activityFor(status) {
+    switch (status) {
+        case "queued":
+            return "等待恢复队列";
+        case "running":
+            return "检测到已启动任务，等待安全中断处理";
+        case "succeeded":
+            return "任务已完成";
+        case "failed":
+            return "任务执行失败";
+        case "cancelled":
+            return "任务已取消";
+        case "interrupted":
+            return "任务被服务中断";
+    }
+}
+function validTime(value) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}