maoyuanyang/curriculum-project-hub
1
0
Fork 0
forked from bai/curriculum-project-hub
Code Pull Requests Activity

feat: redesign Feishu project console

Browse Source
This commit is contained in:
洪佳荣
2026-07-13 16:52:45 +08:00
parent 82f57317df
commit 69837bd50c
34 changed files with 1738 additions and 978 deletions
Download Patch File Download Diff File Expand all files Collapse all files
hub/src/feishu/messageBatcher.ts
+6 -4
View File
@@ -47,8 +47,8 @@ export class MessageBatcher {
this.extendedDebounceMs = options.extendedDebounceMs ?? DEFAULT_OPTIONS.extendedDebounceMs;
}
async enqueue(chatId: string, senderOpenId: string, text: string): Promise<void> {
const key = messageBatchKey(chatId, senderOpenId);
async enqueue(chatId: string, senderOpenId: string, text: string, discriminator?: string): Promise<void> {
const key = messageBatchKey(chatId, senderOpenId, discriminator);
await this.runSerial(key, async () => {
const existing = this.pending.get(key);
const batch =
@@ -120,6 +120,8 @@ export class MessageBatcher {
}
}
export function messageBatchKey(chatId: string, senderOpenId: string): string {
return `${chatId}:${senderOpenId}`;
export function messageBatchKey(chatId: string, senderOpenId: string, discriminator?: string): string {
return discriminator === undefined
? `${chatId}:${senderOpenId}`
: `${chatId}:${senderOpenId}:${discriminator}`;
}
hub/src/feishu/projectConsole.ts
+322
View File
@@ -0,0 +1,322 @@
import { Prisma, type PrismaClient } from "@prisma/client";
import { lockActiveProjectOrganization } from "../org/status.js";
export interface ProjectConsoleState {
readonly organizationId: string;
readonly projectId: string;
readonly projectName: string;
readonly folderId: string | null;
readonly breadcrumb: string;
readonly selectedRole: { readonly id: string; readonly roleId: string; readonly label: string };
readonly roles: readonly { readonly id: string; readonly roleId: string; readonly label: string }[];
readonly currentSession: {
readonly id: string;
readonly title: string | null;
readonly updatedAt: Date;
readonly runCount: number;
readonly sdkSessionReady: boolean;
} | null;
}
export interface FolderDestinationPage {
readonly folderId: string | null;
readonly parentFolderId: string | null;
readonly breadcrumb: string;
readonly childFolders: readonly { readonly id: string; readonly name: string }[];
}
export async function browseFolderDestinations(
prisma: PrismaClient,
input: { readonly organizationId: string; readonly folderId: string | null },
): Promise<FolderDestinationPage> {
const folder = input.folderId === null ? null : await prisma.folder.findFirst({
where: { id: input.folderId, organizationId: input.organizationId, archivedAt: null },
select: { id: true, parentId: true },
});
if (input.folderId !== null && folder === null) throw new Error(`active folder not found: ${input.folderId}`);
const childFolders = await prisma.folder.findMany({
where: {
organizationId: input.organizationId,
parentId: input.folderId,
archivedAt: null,
kind: { not: "SYSTEM_INBOX" },
},
orderBy: [{ sortKey: "asc" }, { name: "asc" }, { id: "asc" }],
select: { id: true, name: true },
});
return {
folderId: input.folderId,
parentFolderId: folder?.parentId ?? null,
breadcrumb: input.folderId === null ? "根目录" : await folderBreadcrumb(prisma, input.folderId),
childFolders,
};
}
export async function loadProjectConsole(
prisma: PrismaClient,
input: { readonly projectId: string; readonly chatId: string },
): Promise<ProjectConsoleState> {
const binding = await prisma.projectGroupBinding.findFirst({
where: { projectId: input.projectId, chatId: input.chatId, archivedAt: null },
select: {
selectedRole: { select: { id: true, roleId: true, label: true, disabledAt: true, organizationId: true } },
project: {
select: {
id: true,
name: true,
folderId: true,
organizationId: true,
archivedAt: true,
organization: {
select: {
status: true,
agentRoles: {
where: { disabledAt: null },
orderBy: [{ sortOrder: "asc" }, { roleId: "asc" }],
select: { id: true, roleId: true, label: true },
},
},
},
},
},
},
});
if (binding === null) throw new Error("project console requires an active binding to this chat");
const { project, selectedRole } = binding;
if (project.archivedAt !== null) throw new Error(`project ${project.id} is archived`);
if (project.organization.status !== "ACTIVE") {
throw new Error(`organization ${project.organizationId} is ${project.organization.status}`);
}
if (selectedRole.disabledAt !== null || selectedRole.organizationId !== project.organizationId) {
throw new Error("project group selected role is unavailable or cross-Organization");
}
const model = await selectedRoleModel(prisma, project.organizationId, selectedRole.id);
const currentSession = await prisma.agentSession.findFirst({
where: {
projectId: project.id,
roleId: selectedRole.roleId,
...(model === null ? {} : { model }),
archivedAt: null,
},
orderBy: { updatedAt: "desc" },
select: { id: true, title: true, updatedAt: true, metadata: true, _count: { select: { runs: true } } },
});
return {
organizationId: project.organizationId,
projectId: project.id,
projectName: project.name,
folderId: project.folderId,
breadcrumb: project.folderId === null ? "根目录" : await folderBreadcrumb(prisma, project.folderId),
selectedRole: { id: selectedRole.id, roleId: selectedRole.roleId, label: selectedRole.label },
roles: project.organization.agentRoles,
currentSession: currentSession === null ? null : {
id: currentSession.id,
title: currentSession.title,
updatedAt: currentSession.updatedAt,
runCount: currentSession._count.runs,
sdkSessionReady: hasClaudeSessionId(currentSession.metadata),
},
};
}
function hasClaudeSessionId(metadata: unknown): boolean {
if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) return false;
const value = (metadata as Record<string, unknown>)["claudeSessionId"];
return typeof value === "string" && value !== "";
}
function isUserResumable(metadata: unknown): boolean {
return typeof metadata === "object" && metadata !== null && !Array.isArray(metadata) &&
(metadata as Record<string, unknown>)["userResumable"] === true;
}
function userResumableMetadata(metadata: unknown, value: boolean): Prisma.InputJsonObject {
const base = typeof metadata === "object" && metadata !== null && !Array.isArray(metadata)
? metadata as Prisma.JsonObject
: {};
return { ...base, userResumable: value };
}
export async function selectProjectGroupRole(
prisma: PrismaClient,
input: {
readonly projectId: string;
readonly chatId: string;
readonly agentRoleId: string;
readonly actorUserId: string;
},
): Promise<void> {
await prisma.$transaction(async (tx) => {
await lockActiveProjectOrganization(tx, input.projectId);
const binding = await tx.projectGroupBinding.findFirst({
where: { projectId: input.projectId, chatId: input.chatId, archivedAt: null },
select: { id: true, project: { select: { organizationId: true } } },
});
if (binding === null) throw new Error("role selection requires an active binding to this chat");
const role = await tx.organizationAgentRole.findFirst({
where: {
id: input.agentRoleId,
organizationId: binding.project.organizationId,
disabledAt: null,
},
select: { id: true, roleId: true },
});
if (role === null) throw new Error(`active role not found: ${input.agentRoleId}`);
await tx.projectGroupBinding.update({
where: { id: binding.id },
data: { selectedAgentRoleId: role.id },
});
await tx.auditEntry.create({
data: {
projectId: input.projectId,
actorUserId: input.actorUserId,
action: "project_group.role_selected",
metadata: { chatId: input.chatId, roleId: role.roleId },
},
});
});
}
export async function archiveCurrentRoleSession(
prisma: PrismaClient,
input: { readonly projectId: string; readonly chatId: string; readonly actorUserId: string },
): Promise<boolean> {
return prisma.$transaction(async (tx) => {
await lockActiveProjectOrganization(tx, input.projectId);
const activeRun = await tx.agentRun.findFirst({
where: { projectId: input.projectId, status: { in: ["ACTIVE", "WAITING_FOR_USER"] } },
select: { id: true },
});
if (activeRun !== null) throw new Error(`cannot archive a session while run ${activeRun.id} is active`);
const binding = await tx.projectGroupBinding.findFirst({
where: { projectId: input.projectId, chatId: input.chatId, archivedAt: null },
select: { selectedRole: { select: { roleId: true } } },
});
if (binding === null) throw new Error("session operation requires an active binding to this chat");
const session = await tx.agentSession.findFirst({
where: { projectId: input.projectId, roleId: binding.selectedRole.roleId, archivedAt: null },
orderBy: { updatedAt: "desc" },
select: { id: true, metadata: true },
});
if (session !== null) {
await tx.agentSession.update({
where: { id: session.id },
data: { archivedAt: new Date(), metadata: userResumableMetadata(session.metadata, true) },
});
}
await tx.auditEntry.create({
data: {
projectId: input.projectId,
actorUserId: input.actorUserId,
action: "agent_session.new_requested",
metadata: { chatId: input.chatId, roleId: binding.selectedRole.roleId, archivedSessionId: session?.id ?? null },
},
});
return session !== null;
});
}
export async function listRoleSessionHistory(
prisma: PrismaClient,
input: { readonly projectId: string; readonly chatId: string },
): Promise<readonly { readonly id: string; readonly title: string | null; readonly updatedAt: Date; readonly runCount: number }[]> {
const binding = await prisma.projectGroupBinding.findFirst({
where: { projectId: input.projectId, chatId: input.chatId, archivedAt: null },
select: { selectedRole: { select: { roleId: true } } },
});
if (binding === null) throw new Error("session history requires an active binding to this chat");
const sessions = await prisma.agentSession.findMany({
where: { projectId: input.projectId, roleId: binding.selectedRole.roleId, archivedAt: { not: null } },
orderBy: { updatedAt: "desc" },
take: 10,
select: { id: true, title: true, updatedAt: true, metadata: true, _count: { select: { runs: true } } },
});
return sessions.filter((session) => isUserResumable(session.metadata)).map((session) => ({
id: session.id,
title: session.title,
updatedAt: session.updatedAt,
runCount: session._count.runs,
}));
}
export async function resumeRoleSession(
prisma: PrismaClient,
input: {
readonly projectId: string;
readonly chatId: string;
readonly sessionId: string;
readonly actorUserId: string;
},
): Promise<void> {
await prisma.$transaction(async (tx) => {
await lockActiveProjectOrganization(tx, input.projectId);
const activeRun = await tx.agentRun.findFirst({
where: { projectId: input.projectId, status: { in: ["ACTIVE", "WAITING_FOR_USER"] } },
select: { id: true },
});
if (activeRun !== null) throw new Error(`cannot resume a session while run ${activeRun.id} is active`);
const binding = await tx.projectGroupBinding.findFirst({
where: { projectId: input.projectId, chatId: input.chatId, archivedAt: null },
select: { selectedRole: { select: { roleId: true } } },
});
if (binding === null) throw new Error("session resume requires an active binding to this chat");
const target = await tx.agentSession.findFirst({
where: { id: input.sessionId, projectId: input.projectId, roleId: binding.selectedRole.roleId, archivedAt: { not: null } },
select: { id: true, provider: true, model: true, metadata: true },
});
if (target === null || !isUserResumable(target.metadata)) {
throw new Error("user-resumable archived session not found for the selected role");
}
const activeSessions = await tx.agentSession.findMany({
where: {
projectId: input.projectId,
roleId: binding.selectedRole.roleId,
provider: target.provider,
model: target.model,
archivedAt: null,
},
select: { id: true, metadata: true },
});
const archivedAt = new Date();
for (const session of activeSessions) {
await tx.agentSession.update({
where: { id: session.id },
data: { archivedAt, metadata: userResumableMetadata(session.metadata, true) },
});
}
await tx.agentSession.update({
where: { id: target.id },
data: { archivedAt: null, metadata: userResumableMetadata(target.metadata, false) },
});
await tx.auditEntry.create({
data: {
projectId: input.projectId,
actorUserId: input.actorUserId,
action: "agent_session.resumed",
metadata: { chatId: input.chatId, roleId: binding.selectedRole.roleId, sessionId: target.id },
},
});
});
}
async function selectedRoleModel(
prisma: PrismaClient,
organizationId: string,
roleId: string,
): Promise<string | null> {
const role = await prisma.organizationAgentRole.findFirst({
where: { id: roleId, organizationId, disabledAt: null },
select: { defaultModel: true },
});
if (role === null) throw new Error(`selected role not found: ${roleId}`);
return role.defaultModel;
}
async function folderBreadcrumb(prisma: PrismaClient, folderId: string): Promise<string> {
const rows = await prisma.$queryRaw<Array<{ breadcrumb: string }>>(Prisma.sql`
SELECT cph_folder_breadcrumb(${folderId}) AS breadcrumb
`);
const breadcrumb = rows[0]?.breadcrumb;
if (breadcrumb === undefined) throw new Error(`failed to resolve folder breadcrumb: ${folderId}`);
return breadcrumb;
}
hub/src/feishu/projectOnboardingCard.ts
+264 -36
View File
@@ -5,12 +5,27 @@ export type ProjectOnboardingView =
| { readonly mode: "browse"; readonly result: ProjectFolderPage };
export interface ProjectOnboardingActionValue {
readonly action: "create_project_from_chat" | "bind_project" | "browse_folder" | "search_page" | "rename_project";
readonly action:
| "create_project_from_chat"
| "bind_project"
| "browse_folder"
| "search_page"
| "rename_project"
| "select_agent_role"
| "new_agent_session"
| "show_session_history"
| "resume_agent_session"
| "compact_agent_session"
| "browse_move_destination"
| "move_project"
| "create_folder";
readonly organization_id: string;
readonly project_id?: string | undefined;
readonly folder_id?: string | undefined;
readonly search_query?: string | undefined;
readonly page?: number | undefined;
readonly agent_role_id?: string | undefined;
readonly session_id?: string | undefined;
}
export function buildUnboundChatOnboardingCard(params: {
@@ -62,49 +77,165 @@ export function buildProjectManagementCard(params: {
readonly projectId: string;
readonly projectName: string;
readonly title?: string | undefined;
readonly breadcrumb?: string | undefined;
readonly selectedRole?: { readonly id: string; readonly roleId: string; readonly label: string } | undefined;
readonly roles?: readonly { readonly id: string; readonly roleId: string; readonly label: string }[] | undefined;
readonly currentSession?: {
readonly id: string;
readonly title: string | null;
readonly updatedAt: Date;
readonly runCount: number;
readonly sdkSessionReady: boolean;
} | null | undefined;
readonly canManageProject?: boolean | undefined;
readonly canCreateFolder?: boolean | undefined;
}): Record<string, unknown> {
const elements: unknown[] = [{
tag: "markdown",
content: [
`当前项目: **${escapeMarkdown(params.projectName)}**`,
`所在目录: **${escapeMarkdown(params.breadcrumb ?? "根目录")}**`,
params.selectedRole === undefined
? "当前角色: **未配置**"
: `当前角色: **${escapeMarkdown(params.selectedRole.label)}**`,
sessionSummary(params.currentSession),
].join("\n"),
}];
const roles = params.roles ?? [];
if (roles.length > 0) {
elements.push({ tag: "markdown", content: "**切换角色**" });
for (let index = 0; index < roles.length; index += 5) {
elements.push({
tag: "action",
actions: roles.slice(index, index + 5).map((role) => actionButton(
role.id === params.selectedRole?.id ? `✓ ${role.label}` : role.label,
{
action: "select_agent_role",
organization_id: params.organizationId,
project_id: params.projectId,
agent_role_id: role.id,
},
role.id === params.selectedRole?.id ? "primary" : "default",
)),
});
}
}
const sessionActions = [
actionButton("新开会话", {
action: "new_agent_session", organization_id: params.organizationId, project_id: params.projectId,
}),
actionButton("历史会话", {
action: "show_session_history", organization_id: params.organizationId, project_id: params.projectId,
}),
];
if (params.currentSession?.sdkSessionReady === true) {
sessionActions.push(actionButton("压缩上下文", {
action: "compact_agent_session", organization_id: params.organizationId, project_id: params.projectId,
}));
}
elements.push(
{ tag: "markdown", content: "**当前角色会话**" },
{ tag: "action", actions: sessionActions },
);
if (params.canManageProject === true) {
elements.push(
{ tag: "markdown", content: "**项目管理**" },
{ tag: "action", actions: [actionButton("移动项目", {
action: "browse_move_destination",
organization_id: params.organizationId,
project_id: params.projectId,
page: 1,
})] },
renameProjectForm(params),
);
}
if (params.canCreateFolder === true) elements.push(createFolderForm(params));
return {
config: { wide_screen_mode: true },
header: {
title: { tag: "plain_text", content: params.title ?? "项目管理" },
template: "green",
},
elements: [
{ tag: "markdown", content: `当前项目: **${escapeMarkdown(params.projectName)}**` },
elements,
};
}
export function buildSessionHistoryCard(params: {
readonly organizationId: string;
readonly projectId: string;
readonly roleLabel: string;
readonly sessions: readonly {
readonly id: string;
readonly title: string | null;
readonly updatedAt: Date;
readonly runCount: number;
}[];
}): Record<string, unknown> {
const elements: unknown[] = [{ tag: "markdown", content: `角色: **${escapeMarkdown(params.roleLabel)}**` }];
if (params.sessions.length === 0) elements.push({ tag: "markdown", content: "没有可恢复的历史会话。" });
for (const session of params.sessions) {
elements.push(
{
tag: "form",
name: "project_rename_form",
fallback: {
tag: "fallback_text",
text: { tag: "plain_text", content: "请升级飞书客户端后修改项目名称。" },
},
elements: [
{
tag: "input",
name: "project_name",
required: true,
max_length: 100,
default_value: params.projectName,
placeholder: { tag: "plain_text", content: "请输入项目名称" },
},
{
tag: "button",
name: "project_rename_submit",
text: { tag: "plain_text", content: "保存项目名称" },
type: "primary",
complex_interaction: true,
action_type: "form_submit",
value: {
project_onboarding: {
action: "rename_project",
organization_id: params.organizationId,
project_id: params.projectId,
},
},
},
],
tag: "markdown",
content: `**${escapeMarkdown(session.title ?? "未命名会话")}**\n${session.runCount} runs · ${formatDate(session.updatedAt)}`,
},
],
{ tag: "action", actions: [actionButton("恢复此会话", {
action: "resume_agent_session",
organization_id: params.organizationId,
project_id: params.projectId,
session_id: session.id,
}, "primary")] },
);
}
return {
config: { wide_screen_mode: true },
header: { title: { tag: "plain_text", content: "历史会话" }, template: "blue" },
elements,
};
}
export function buildMoveProjectCard(params: {
readonly organizationId: string;
readonly projectId: string;
readonly projectName: string;
readonly folderId: string | null;
readonly parentFolderId: string | null;
readonly breadcrumb: string;
readonly childFolders: readonly { readonly id: string; readonly name: string }[];
}): Record<string, unknown> {
const navigation: unknown[] = [];
if (params.folderId !== null) {
navigation.push(actionButton("⬆ 上一级", {
action: "browse_move_destination",
organization_id: params.organizationId,
project_id: params.projectId,
...(params.parentFolderId !== null ? { folder_id: params.parentFolderId } : {}),
}));
}
for (const folder of params.childFolders) {
navigation.push(actionButton(`📁 ${buttonLabel(folder.name, 22)}`, {
action: "browse_move_destination",
organization_id: params.organizationId,
project_id: params.projectId,
folder_id: folder.id,
}));
}
const elements: unknown[] = [
{ tag: "markdown", content: `移动 **${escapeMarkdown(params.projectName)}**\n当前位置: **${escapeMarkdown(params.breadcrumb)}**` },
];
for (let index = 0; index < navigation.length; index += 5) {
elements.push({ tag: "action", actions: navigation.slice(index, index + 5) });
}
elements.push({ tag: "action", actions: [actionButton("移动到这里", {
action: "move_project",
organization_id: params.organizationId,
project_id: params.projectId,
...(params.folderId !== null ? { folder_id: params.folderId } : {}),
}, "primary")] });
return {
config: { wide_screen_mode: true },
header: { title: { tag: "plain_text", content: "移动项目" }, template: "blue" },
elements,
};
}
@@ -120,11 +251,15 @@ export function projectOnboardingActionFromValue(value: unknown): ProjectOnboard
const folderId = fields.folder_id;
const searchQuery = fields.search_query;
const page = fields.page;
const agentRoleId = fields.agent_role_id;
const sessionId = fields.session_id;
if (!isAction(rawAction) || typeof organizationId !== "string" || organizationId === "") return null;
if ((rawAction === "bind_project" || rawAction === "rename_project") && (typeof projectId !== "string" || projectId === "")) return null;
if (rawAction === "search_page" && (typeof searchQuery !== "string" || !validPage(page))) return null;
if (folderId !== undefined && (typeof folderId !== "string" || folderId === "")) return null;
if (page !== undefined && !validPage(page)) return null;
if (rawAction === "select_agent_role" && (typeof agentRoleId !== "string" || agentRoleId === "")) return null;
if (rawAction === "resume_agent_session" && (typeof sessionId !== "string" || sessionId === "")) return null;
return {
action: rawAction,
organization_id: organizationId,
@@ -132,6 +267,8 @@ export function projectOnboardingActionFromValue(value: unknown): ProjectOnboard
...(typeof folderId === "string" && folderId !== "" ? { folder_id: folderId } : {}),
...(typeof searchQuery === "string" ? { search_query: searchQuery.slice(0, 100) } : {}),
...(typeof page === "number" ? { page } : {}),
...(typeof agentRoleId === "string" && agentRoleId !== "" ? { agent_role_id: agentRoleId } : {}),
...(typeof sessionId === "string" && sessionId !== "" ? { session_id: sessionId } : {}),
};
}
@@ -258,6 +395,93 @@ function projectPage(view: ProjectOnboardingView): ProjectDiscoveryPage {
};
}
function renameProjectForm(params: {
readonly organizationId: string;
readonly projectId: string;
readonly projectName: string;
}): unknown {
return {
tag: "form",
name: "project_rename_form",
fallback: {
tag: "fallback_text",
text: { tag: "plain_text", content: "请升级飞书客户端后修改项目名称。" },
},
elements: [
{
tag: "input",
name: "project_name",
required: true,
max_length: 100,
default_value: params.projectName,
placeholder: { tag: "plain_text", content: "请输入项目名称" },
},
{
tag: "button",
name: "project_rename_submit",
text: { tag: "plain_text", content: "保存项目名称" },
type: "primary",
complex_interaction: true,
action_type: "form_submit",
value: { project_onboarding: {
action: "rename_project",
organization_id: params.organizationId,
project_id: params.projectId,
} },
},
],
};
}
function createFolderForm(params: { readonly organizationId: string; readonly projectId: string }): unknown {
return {
tag: "form",
name: "folder_create_form",
elements: [
{
tag: "input",
name: "folder_name",
required: true,
max_length: 100,
placeholder: { tag: "plain_text", content: "在当前目录下新建 Folder" },
},
{
tag: "button",
name: "folder_create_submit",
text: { tag: "plain_text", content: "新建目录" },
type: "default",
complex_interaction: true,
action_type: "form_submit",
value: { project_onboarding: {
action: "create_folder",
organization_id: params.organizationId,
project_id: params.projectId,
} },
},
],
};
}
function sessionSummary(session: {
readonly title: string | null;
readonly updatedAt: Date;
readonly runCount: number;
} | null | undefined): string {
if (session === null || session === undefined) return "当前会话: **尚未开始**";
return `当前会话: **${escapeMarkdown(session.title ?? "未命名会话")}** · ${session.runCount} runs · ${formatDate(session.updatedAt)}`;
}
function formatDate(value: Date): string {
return new Intl.DateTimeFormat("zh-CN", {
timeZone: "Asia/Shanghai",
month: "2-digit",
day: "2-digit",
hour: "2-digit",
minute: "2-digit",
hour12: false,
}).format(value);
}
function actionButton(
label: string,
value: ProjectOnboardingActionValue,
@@ -273,7 +497,11 @@ function actionButton(
function isAction(value: unknown): value is ProjectOnboardingActionValue["action"] {
return value === "create_project_from_chat" || value === "bind_project"
|| value === "browse_folder" || value === "search_page" || value === "rename_project";
|| value === "browse_folder" || value === "search_page" || value === "rename_project"
|| value === "select_agent_role" || value === "new_agent_session"
|| value === "show_session_history" || value === "resume_agent_session"
|| value === "compact_agent_session" || value === "browse_move_destination"
|| value === "move_project" || value === "create_folder";
}
function validPage(value: unknown): value is number {
hub/src/feishu/slashCommands.ts
+80 -336
View File
@@ -1,11 +1,6 @@
import type { PrismaClient } from "@prisma/client";
import type { FastifyBaseLogger } from "fastify";
import { decimalToNumberOrNull, formatInteger, formatUsd } from "../agent/cost.js";
import type { ModelRegistry, RoleEntry } from "../agent/models.js";
import type { RuntimeSettings } from "../settings/runtime.js";
import { lockActiveProjectOrganization } from "../org/status.js";
import { sendText, type FeishuRuntime, type SendMessageOptions } from "./client.js";
import type { TriggerQueue } from "./triggerQueue.js";
export interface SlashInvocation {
readonly name: string;
@@ -21,20 +16,13 @@ export interface SlashCommandRunContext {
}
export interface SlashCommandDefinition {
readonly name: string;
readonly name: "help" | "project" | "usage";
readonly usage: string;
readonly summary: string;
readonly details: readonly string[];
run(context: SlashCommandRunContext): Promise<void>;
}
export interface SlashCommandRegistryDeps {
readonly prisma: PrismaClient;
readonly settings: RuntimeSettings;
readonly logger: FastifyBaseLogger;
readonly triggerQueue: TriggerQueue;
}
const TERMINAL_RUN_STATUSES = ["COMPLETED", "FAILED", "TIMED_OUT", "CANCELED"] as const;
export function parseSlashInvocation(prompt: string): SlashInvocation | null {
@@ -43,179 +31,94 @@ export function parseSlashInvocation(prompt: string): SlashInvocation | null {
const tokens = trimmed.split(/\s+/);
const rawCommand = tokens[0];
if (rawCommand === undefined || rawCommand.length <= 1) return null;
return {
name: rawCommand.slice(1),
args: tokens.slice(1),
};
return { name: rawCommand.slice(1), args: tokens.slice(1) };
}
export function parseSlashHelpSubcommand(invocation: SlashInvocation): string | null {
if (invocation.name === "help") return null;
return invocation.args.length === 1 && invocation.args[0] === "help"
? invocation.name
: null;
}
export function createSlashCommandRegistry(deps: SlashCommandRegistryDeps): ReadonlyMap<string, SlashCommandDefinition> {
export function createSlashCommandRegistry(
deps: { readonly prisma: PrismaClient },
): ReadonlyMap<string, SlashCommandDefinition> {
const commands = new Map<string, SlashCommandDefinition>();
const add = (command: SlashCommandDefinition): void => {
if (commands.has(command.name)) {
throw new Error(`duplicate slash command definition: /${command.name}`);
}
if (commands.has(command.name)) throw new Error(`duplicate slash command definition: /${command.name}`);
commands.set(command.name, command);
};
add({
name: "help",
usage: "/help [command]",
summary: "查看可用 slash 命令或单个命令说明。",
details: [
"不创建 agent run,也不改变当前会话。",
"支持 /help new 和 /new help 两种写法。",
],
run: async ({ invocation, projectId, chatId, rt, sendOptions }) => {
const registry = await deps.settings.modelRegistry({ projectId });
await sendText(rt, chatId, formatHelpCommandInvocation(invocation, registry, commands), sendOptions);
},
});
add({
name: "new",
usage: "/new",
summary: "开新会话,下次 @bot 将从头开始。",
details: [
"归档当前未归档的 agent session。",
"不会清空当前项目的等待队列。",
],
run: async ({ projectId, chatId, rt, sendOptions }) => {
await deps.prisma.$transaction(async (tx) => {
await lockActiveProjectOrganization(tx, projectId);
await tx.agentSession.updateMany({
where: { projectId, archivedAt: null },
data: { archivedAt: new Date() },
});
});
await sendText(rt, chatId, "已开新会话,下次 @bot 将从头开始。", sendOptions);
usage: "/help [project|usage]",
summary: "查看 Hub 命令。",
details: ["未知 slash 命令会明确报错，不会发送给 Agent。"],
run: async ({ invocation, chatId, rt, sendOptions }) => {
if (invocation.args.length > 1) {
await sendText(rt, chatId, "用法: /help [project|usage]", sendOptions);
return;
}
const target = invocation.args[0];
await sendText(rt, chatId, target === undefined
? formatSlashOverview(commands)
: formatSlashHelpTarget(target, commands), sendOptions);
},
});
add({
name: "project",
usage: "/project",
summary: "打开当前项目管理卡片，可修改项目名称。",
details: [
"要求操作者拥有当前项目的 MANAGE 权限。",
"实际卡片由飞书 trigger adapter 渲染，不创建 agent run。",
],
summary: "打开当前项目控制台，切换角色、管理会话和项目。",
details: ["不同区域按当前操作者的项目与组织权限显示。"],
run: async ({ chatId, rt, sendOptions }) => {
await sendText(rt, chatId, "请在飞书项目群中使用 @bot /project 打开项目管理卡片。", sendOptions);
await sendText(rt, chatId, "请在绑定的项目群中使用 /project。", sendOptions);
},
});
add({
name: "resume",
usage: "/resume",
summary: "恢复最近一次已归档的会话。",
details: [
"只恢复当前项目最近归档的 agent session。",
"没有可恢复会话时只回复提示,不会创建 agent run。",
],
run: async ({ projectId, chatId, rt, sendOptions }) => {
const resumed = await deps.prisma.$transaction(async (tx) => {
await lockActiveProjectOrganization(tx, projectId);
const latest = await tx.agentSession.findFirst({
where: { projectId, archivedAt: { not: null } },
orderBy: { archivedAt: "desc" },
select: { id: true },
});
if (latest === null) return false;
await tx.agentSession.update({
where: { id: latest.id },
data: { archivedAt: null },
});
return true;
});
if (!resumed) {
await sendText(rt, chatId, "没有可恢复的会话。", sendOptions);
return;
}
await sendText(rt, chatId, "已恢复上一个会话。", sendOptions);
},
});
add({
name: "cost",
usage: "/cost",
summary: "查看当前会话已记录的 agent 成本。",
details: [
"只读取当前项目未归档 agent session 下已经结束的 run,不创建 agent run。",
"只统计运行时真实记录到 AgentRun.costUsd 的成本;未记录成本的 run 会单独列出。",
],
name: "usage",
usage: "/usage [current|project]",
summary: "查看 Hub 记录的真实 Agent 用量与成本。",
details: ["current 只统计当前角色的活跃会话；project 统计整个项目。"],
run: async ({ invocation, projectId, chatId, rt, sendOptions }) => {
if (invocation.args.length > 0) {
await sendText(rt, chatId, ["用法错误: /cost 暂不接受参数。", "", formatBuiltinSlashCommandHelp(commands.get("cost")!)].join("\n"), sendOptions);
const scope = invocation.args[0] ?? "current";
if (invocation.args.length > 1 || (scope !== "current" && scope !== "project")) {
await sendText(rt, chatId, "用法: /usage [current|project]", sendOptions);
return;
}
const sessions = await deps.prisma.agentSession.findMany({
where: { projectId, archivedAt: null },
orderBy: { updatedAt: "asc" },
select: { id: true },
});
if (sessions.length === 0) {
await sendText(rt, chatId, "当前会话还没有 agent session。", sendOptions);
return;
}
const sessionIds = scope === "project"
? undefined
: await currentRoleSessionIds(deps.prisma, projectId, chatId);
const runs = await deps.prisma.agentRun.findMany({
where: {
projectId,
sessionId: { in: sessions.map((session) => session.id) },
...(sessionIds === undefined ? {} : { sessionId: { in: sessionIds } }),
status: { in: [...TERMINAL_RUN_STATUSES] },
finishedAt: { not: null },
},
orderBy: { finishedAt: "asc" },
select: {
model: true,
provider: true,
inputTokens: true,
outputTokens: true,
costUsd: true,
},
select: { model: true, provider: true, inputTokens: true, outputTokens: true, costUsd: true },
});
await sendText(rt, chatId, formatCostReport(runs), sendOptions);
},
});
add({
name: "reset",
usage: "/reset",
summary: "重置当前会话并清空等待队列。",
details: [
"归档当前未归档的 agent session。",
"清空当前项目已经排队、尚未开始的触发请求。",
],
run: async ({ projectId, chatId, rt, sendOptions }) => {
await deps.prisma.$transaction(async (tx) => {
await lockActiveProjectOrganization(tx, projectId);
await tx.agentSession.updateMany({
where: { projectId, archivedAt: null },
data: { archivedAt: new Date() },
});
});
const cleared = deps.triggerQueue.clear(projectId);
if (cleared > 0) {
deps.logger.info({ projectId, cleared }, "feishu trigger: cleared queued triggers on reset");
}
await sendText(rt, chatId, "已重置,下次 @bot 将从头开始。", sendOptions);
await sendText(rt, chatId, formatUsageReport(runs, scope), sendOptions);
},
});
return commands;
}
interface CostReportRun {
async function currentRoleSessionIds(
prisma: PrismaClient,
projectId: string,
chatId: string,
): Promise<string[]> {
const binding = await prisma.projectGroupBinding.findFirst({
where: { projectId, chatId, archivedAt: null },
select: { selectedRole: { select: { roleId: true } } },
});
if (binding === null) throw new Error("active project-group binding not found");
const sessions = await prisma.agentSession.findMany({
where: { projectId, roleId: binding.selectedRole.roleId, archivedAt: null },
select: { id: true },
});
return sessions.map((session) => session.id);
}
interface UsageRun {
readonly model: string;
readonly provider: string;
readonly inputTokens: number | null;
@@ -223,225 +126,66 @@ interface CostReportRun {
readonly costUsd: unknown;
}
interface CostReportBucket {
readonly provider: string;
readonly model: string;
runs: number;
inputTokens: number;
outputTokens: number;
costUsd: number;
}
function formatCostReport(runs: readonly CostReportRun[]): string {
if (runs.length === 0) {
return "当前会话还没有已结束的 agent run。";
}
const buckets = new Map<string, CostReportBucket>();
function formatUsageReport(runs: readonly UsageRun[], scope: "current" | "project"): string {
if (runs.length === 0) return `${scope === "current" ? "当前角色会话" : "当前项目"}还没有已结束的 Agent run。`;
const buckets = new Map<string, {
provider: string; model: string; runs: number; inputTokens: number; outputTokens: number; costUsd: number;
}>();
let recordedRuns = 0;
let unrecordedRuns = 0;
let totalInputTokens = 0;
let totalOutputTokens = 0;
let totalCostUsd = 0;
for (const run of runs) {
const costUsd = decimalToNumberOrNull(run.costUsd);
if (costUsd === null) {
unrecordedRuns++;
continue;
}
if (costUsd === null) { unrecordedRuns++; continue; }
recordedRuns++;
const inputTokens = run.inputTokens ?? 0;
const outputTokens = run.outputTokens ?? 0;
totalInputTokens += inputTokens;
totalOutputTokens += outputTokens;
totalCostUsd += costUsd;
const key = `${run.provider}\u0000${run.model}`;
let bucket = buckets.get(key);
if (bucket === undefined) {
bucket = {
provider: run.provider,
model: run.model,
runs: 0,
inputTokens: 0,
outputTokens: 0,
costUsd: 0,
};
buckets.set(key, bucket);
}
const bucket = buckets.get(key) ?? {
provider: run.provider, model: run.model, runs: 0, inputTokens: 0, outputTokens: 0, costUsd: 0,
};
bucket.runs++;
bucket.inputTokens += inputTokens;
bucket.outputTokens += outputTokens;
bucket.inputTokens += run.inputTokens ?? 0;
bucket.outputTokens += run.outputTokens ?? 0;
bucket.costUsd += costUsd;
buckets.set(key, bucket);
totalInputTokens += run.inputTokens ?? 0;
totalOutputTokens += run.outputTokens ?? 0;
totalCostUsd += costUsd;
}
if (recordedRuns === 0) {
return [
"当前会话已有已结束 agent run,但还没有任何 run 记录到真实成本。",
`未记录成本: ${formatInteger(unrecordedRuns)} runs。`,
"后续 run 需要 SDK 返回 total_cost_usd 才会进入 /cost 合计。",
].join("\n");
}
const lines = [
"当前会话已记录 agent 成本:",
`总计: ${formatUsd(totalCostUsd)}`,
`Runs: ${formatInteger(recordedRuns)} 已记录${unrecordedRuns > 0 ? ` / ${formatInteger(unrecordedRuns)} 未记录` : ""}`,
`${scope === "current" ? "当前角色会话" : "当前项目"}用量`,
`已记录成本: ${formatInteger(recordedRuns)} runs · ${formatUsd(totalCostUsd)}`,
`Tokens: input ${formatInteger(totalInputTokens)} / output ${formatInteger(totalOutputTokens)}`,
"",
"按模型:",
];
const sortedBuckets = [...buckets.values()].sort((a, b) => b.costUsd - a.costUsd);
for (const bucket of sortedBuckets) {
lines.push(
`- ${bucket.provider} / ${bucket.model}: ${formatInteger(bucket.runs)} runs, ${formatUsd(bucket.costUsd)}, input ${formatInteger(bucket.inputTokens)} / output ${formatInteger(bucket.outputTokens)}`,
);
if (unrecordedRuns > 0) lines.push(`另有 ${formatInteger(unrecordedRuns)} 个 run 未记录成本。`);
for (const bucket of buckets.values()) {
lines.push(`- ${bucket.provider} / ${bucket.model}: ${formatInteger(bucket.runs)} runs, ${formatUsd(bucket.costUsd)}`);
}
return lines.join("\n");
}
function formatHelpCommandInvocation(
invocation: SlashInvocation,
registry: ModelRegistry,
slashCommands: ReadonlyMap<string, SlashCommandDefinition>,
): string {
if (invocation.args.length > 1) {
const helpCommand = slashCommands.get("help");
if (helpCommand === undefined) {
throw new Error("slash command registry is missing /help");
}
return [
"用法错误: /help 只接受一个命令名。",
"",
formatBuiltinSlashCommandHelp(helpCommand),
].join("\n");
}
const target = invocation.args[0];
if (target === undefined) return formatSlashOverview(registry, slashCommands);
const normalizedTarget = normalizeHelpTarget(target);
if (normalizedTarget === "") return formatSlashOverview(registry, slashCommands);
return formatSlashHelpTarget(normalizedTarget, registry, slashCommands);
}
export function formatSlashHelpTarget(
target: string,
registry: ModelRegistry,
slashCommands: ReadonlyMap<string, SlashCommandDefinition>,
commands: ReadonlyMap<string, SlashCommandDefinition>,
): string {
const normalizedTarget = normalizeHelpTarget(target);
if (normalizedTarget === "") return formatSlashOverview(registry, slashCommands);
return formatSlashCommandHelp(normalizedTarget, registry, slashCommands) ?? formatUnknownSlashHelp(normalizedTarget, registry, slashCommands);
}
function normalizeHelpTarget(target: string): string {
return target.trim().replace(/^\/+/, "");
}
function formatSlashOverview(
registry: ModelRegistry,
slashCommands: ReadonlyMap<string, SlashCommandDefinition>,
): string {
const lines = [
"可用 slash 命令:",
...[...slashCommands.values()].map((command) => `/${command.name} - ${command.summary}`),
];
const roles = visibleRoleCommands(registry, slashCommands);
if (roles.length > 0) {
lines.push("", "角色命令:");
for (const role of roles) {
lines.push(`/${role.id} <需求> - 使用“${role.label}”角色发起请求。`);
}
} else {
lines.push("", "当前没有配置角色命令。");
}
lines.push("", "查看单个命令: /help new 或 /new help。");
return lines.join("\n");
}
function formatSlashCommandHelp(
commandName: string,
registry: ModelRegistry,
slashCommands: ReadonlyMap<string, SlashCommandDefinition>,
): string | null {
const normalizedName = normalizeHelpTarget(commandName);
const slashCommand = slashCommands.get(normalizedName);
if (slashCommand !== undefined) return formatBuiltinSlashCommandHelp(slashCommand);
const role = registry.role(normalizedName);
if (role === undefined) return null;
if (slashCommands.has(role.id)) return null;
return formatRoleSlashCommandHelp(role);
}
function formatBuiltinSlashCommandHelp(command: SlashCommandDefinition): string {
const helpUsage = command.name === "help"
? "帮助: /help help"
: `帮助: /help ${command.name} 或 /${command.name} help`;
const normalized = target.trim().replace(/^\/+/, "");
const command = commands.get(normalized);
if (command === undefined) return [`未知 slash 命令 /${normalized}。`, "", formatSlashOverview(commands)].join("\n");
return [
`/${command.name}`,
command.summary,
"",
`用法: ${command.usage}`,
...command.details.map((detail) => `- ${detail}`),
"",
helpUsage,
].join("\n");
}
function formatRoleSlashCommandHelp(role: RoleEntry): string {
const lines = [
`/${role.id}`,
`使用“${role.label}”角色发起一次 agent run。`,
"",
`用法: /${role.id} <需求>`,
"- 真正运行时仍会按当前项目的 role.trigger 授权检查。",
];
if (role.defaultModel !== undefined) {
lines.push(`- 默认模型: ${role.defaultModel}`);
}
lines.push(
`- 工具范围: ${roleToolsDescription(role)}`,
`- Skills: ${roleSkillsDescription(role)}`,
"",
`帮助: /help ${role.id} 或 /${role.id} help`,
);
return lines.join("\n");
}
function roleSkillsDescription(role: RoleEntry): string {
if (role.skills === undefined || role.skills.length === 0) return "无";
return role.skills.map((skill) => `${skill.name}@${skill.version}`).join(", ");
}
function roleToolsDescription(role: RoleEntry): string {
if (role.tools === undefined) return "全部已注册工具";
if (role.tools.length === 0) return "无";
return role.tools.join(", ");
}
function formatUnknownSlashHelp(
commandName: string,
registry: ModelRegistry,
slashCommands: ReadonlyMap<string, SlashCommandDefinition>,
): string {
const normalizedName = normalizeHelpTarget(commandName);
function formatSlashOverview(commands: ReadonlyMap<string, SlashCommandDefinition>): string {
return [
`未知 slash 命令 /${normalizedName}。`,
"可用 slash 命令:",
...[...commands.values()].map((command) => `/${command.name} - ${command.summary}`),
"",
formatSlashOverview(registry, slashCommands),
"普通消息会使用 /project 中选定的当前角色。",
].join("\n");
}
function visibleRoleCommands(
registry: ModelRegistry,
slashCommands: ReadonlyMap<string, SlashCommandDefinition>,
): readonly RoleEntry[] {
return registry
.listRoles()
.filter((role) => !slashCommands.has(role.id));
}
hub/src/feishu/trigger.ts
+281 -108
View File
@@ -52,22 +52,34 @@ import {
type StagedMessageResourceBatch,
} from "./resourceStaging.js";
import { TriggerQueue, triggerQueue as defaultTriggerQueue, type QueuedTrigger } from "./triggerQueue.js";
import { createSlashCommandRegistry, formatSlashHelpTarget, parseSlashHelpSubcommand, parseSlashInvocation } from "./slashCommands.js";
import { createSlashCommandRegistry, parseSlashInvocation } from "./slashCommands.js";
import { cphHubMcpToolsForRole, roleToolsAllow } from "../agent/roleTools.js";
import {
bindFeishuChatToProject,
createFolder,
createProjectFromFeishuChat,
ensureOrganizationProjectSettings,
moveProjectToFolder,
renameProjectForActor,
} from "../projectOnboarding.js";
import {
buildProjectManagementCard,
buildMoveProjectCard,
buildSessionHistoryCard,
buildProjectOnboardingResolvedCard,
buildUnboundChatOnboardingCard,
projectOnboardingActionFromValue,
type ProjectOnboardingActionValue,
type ProjectOnboardingView,
} from "./projectOnboardingCard.js";
import {
archiveCurrentRoleSession,
browseFolderDestinations,
listRoleSessionHistory,
loadProjectConsole,
resumeRoleSession,
selectProjectGroupRole,
} from "./projectConsole.js";
import { SiloFixedWindowRateLimiter } from "../deployment/siloRateLimit.js";
import { browseBindableFolder, discoverBindableProjects } from "../projectDiscovery.js";
@@ -113,6 +125,7 @@ interface TriggerRunContext {
readonly projectId: string;
readonly senderOpenId: string;
readonly actor: TriggerActor;
readonly roleId: string;
}
type StartAgentRunOutcome = "started" | "queued" | "rejected" | "locked" | "skipped";
@@ -150,9 +163,6 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
: new SiloFixedWindowRateLimiter(deps.maxFeishuEventsPerMinute, 60_000);
const slashCommands = createSlashCommandRegistry({
prisma: deps.prisma,
settings: deps.settings,
logger: deps.logger,
triggerQueue,
});
const batchContexts = new Map<string, TriggerRunContext>();
// runId → AbortController for live runs. Registered when a run starts,
@@ -178,10 +188,48 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
}
}, deps.messageBatcherOptions);
async function projectConsoleCard(
projectId: string,
chatId: string,
actorOpenId: string,
title?: string,
): Promise<Record<string, unknown>> {
const state = await loadProjectConsole(deps.prisma, { projectId, chatId });
const actor = { feishuOpenId: actorOpenId, chatId };
const [manageDecision, organization, roleDecisions] = await Promise.all([
authorizer.can({ actor, action: "collaborator.manage", resource: { type: "PROJECT", id: projectId } }),
resolveSingleActiveOrganizationForFeishuUser(actorOpenId),
Promise.all(state.roles.map(async (role) => ({
role,
decision: await authorizer.can({
actor,
action: "role.trigger",
resource: { type: "PROJECT", id: projectId },
roleId: role.roleId,
}),
}))),
]);
const visibleRoles = roleDecisions.filter(({ decision }) => decision.allowed).map(({ role }) => role);
const isOrgAdmin = organization.status === "ok" &&
organization.organizationId === state.organizationId && isOrgAdminRole(organization.role);
return buildProjectManagementCard({
organizationId: state.organizationId,
projectId: state.projectId,
projectName: state.projectName,
breadcrumb: state.breadcrumb,
selectedRole: state.selectedRole,
roles: visibleRoles,
currentSession: state.currentSession,
canManageProject: manageDecision.allowed || isOrgAdmin,
canCreateFolder: isOrgAdmin,
...(title !== undefined ? { title } : {}),
});
}
async function startAgentRun(
context: TriggerRunContext,
cleanPrompt: string,
options: { readonly queueIfLocked?: boolean } = {},
options: { readonly queueIfLocked?: boolean; readonly nativeSlash?: boolean } = {},
): Promise<StartAgentRunOutcome> {
const { msg, rt, chatId, projectId, senderOpenId, actor } = context;
const sendOptions = sendOptionsForTriggerMessage(msg);
@@ -195,7 +243,7 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
return "rejected";
}
if (!queueIfLocked) return "locked";
return enqueueLockedTrigger(context, cleanPrompt);
return enqueueLockedTrigger(context, cleanPrompt, options.nativeSlash === true ? "native_compact" : "conversation");
}
const project = await deps.prisma.project.findUnique({
@@ -207,15 +255,11 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
return "skipped";
}
// ADR-0017: role-as-data. Parse a leading `/<role>` command; unknown
// slashes are left as literal text (extractRole returns null). Falls back
// to "draft" when no role is named — the registry degrades gracefully.
const models = await deps.settings.modelRegistry({ projectId });
const { roleId: parsedRole, prompt: parsedAgentPrompt } = extractRole(cleanPrompt, models);
const roleId = parsedRole ?? "draft";
const roleId = context.roleId;
// ADR-0019: role trigger is the second gate after project agent.trigger.
// Unconfigured roles remain open for back-compat; configured roles require
// a matching active RoleTriggerGrant for any resolved principal.
// Configured roles require a matching active RoleTriggerGrant for any
// resolved principal; otherwise the role remains open within the project.
const roleDecision = await authorizer.can({
actor,
action: "role.trigger",
@@ -262,8 +306,10 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
projectWorkspaceRoot,
deps.resourceLimits,
);
const agentPrompt = appendStagedResourcePaths(parsedAgentPrompt, stagedResources, project.workspaceDir);
const promptForAgent = withFeishuTriggerContext(agentPrompt, feishuTriggerContext);
const agentPrompt = appendStagedResourcePaths(cleanPrompt, stagedResources, project.workspaceDir);
const promptForAgent = options.nativeSlash === true
? cleanPrompt
: withFeishuTriggerContext(agentPrompt, feishuTriggerContext);
// Linearization point for org lifecycle + session/run/lock admission.
// FOR SHARE on the Organization row conflicts with a concurrent status
@@ -623,10 +669,16 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
return "started";
}
async function enqueueLockedTrigger(context: TriggerRunContext, cleanPrompt: string): Promise<StartAgentRunOutcome> {
async function enqueueLockedTrigger(
context: TriggerRunContext,
cleanPrompt: string,
executionKind: QueuedTrigger["executionKind"] = "conversation",
): Promise<StartAgentRunOutcome> {
const position = triggerQueue.enqueue(context.projectId, {
chatId: context.chatId,
prompt: cleanPrompt,
roleId: context.roleId,
executionKind,
msg: context.msg,
senderOpenId: context.senderOpenId,
actor: context.actor,
@@ -664,7 +716,10 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
const next = triggerQueue.dequeue(projectId);
if (next === null) return;
const outcome = await startAgentRun(contextFromQueuedTrigger(next, rt), next.prompt, { queueIfLocked: false });
const outcome = await startAgentRun(contextFromQueuedTrigger(next, rt), next.prompt, {
queueIfLocked: false,
nativeSlash: next.executionKind === "native_compact",
});
if (outcome === "started") return;
if (outcome === "locked") {
requeueTrigger(next);
@@ -681,6 +736,7 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
projectId: trigger.projectId,
senderOpenId: trigger.senderOpenId,
actor: trigger.actor,
roleId: trigger.roleId,
};
}
@@ -688,6 +744,8 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
const position = triggerQueue.enqueue(trigger.projectId, {
chatId: trigger.chatId,
prompt: trigger.prompt,
roleId: trigger.roleId,
executionKind: trigger.executionKind,
msg: trigger.msg,
senderOpenId: trigger.senderOpenId,
actor: trigger.actor,
@@ -761,6 +819,169 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
if (organization.organizationId !== action.organization_id) {
throw new Error("project onboarding organization mismatch");
}
if (
action.action === "select_agent_role" ||
action.action === "new_agent_session" ||
action.action === "show_session_history" ||
action.action === "resume_agent_session" ||
action.action === "compact_agent_session"
) {
const projectId = action.project_id;
if (projectId === undefined) throw new Error(`${action.action} requires project_id`);
const binding = await deps.prisma.projectGroupBinding.findFirst({
where: { projectId, chatId, archivedAt: null },
select: { id: true },
});
if (binding === null) throw new Error("project console action requires the project to be bound to this chat");
const state = await loadProjectConsole(deps.prisma, { projectId, chatId });
const targetRole = action.action === "select_agent_role"
? state.roles.find((role) => role.id === action.agent_role_id)
: state.selectedRole;
if (targetRole === undefined) throw new Error("selected Agent role is unavailable");
const actor = { feishuOpenId: operatorOpenId, chatId };
const [triggerDecision, roleDecision] = await Promise.all([
authorizer.can({ actor, action: "agent.trigger", resource: { type: "PROJECT", id: projectId } }),
authorizer.can({
actor,
action: "role.trigger",
resource: { type: "PROJECT", id: projectId },
roleId: targetRole.roleId,
}),
]);
if (!triggerDecision.allowed || !roleDecision.allowed || roleDecision.actorUserId === undefined) {
throw new Error(`not authorized for Agent role ${targetRole.roleId}`);
}
if (action.action === "select_agent_role") {
await selectProjectGroupRole(deps.prisma, {
projectId,
chatId,
agentRoleId: targetRole.id,
actorUserId: roleDecision.actorUserId,
});
if (messageId === undefined) throw new Error("role selection requires message id");
await patchCard(rt, messageId, await projectConsoleCard(
projectId,
chatId,
operatorOpenId,
`已切换至 ${targetRole.label}`,
));
return;
}
if (action.action === "new_agent_session") {
await archiveCurrentRoleSession(deps.prisma, {
projectId,
chatId,
actorUserId: roleDecision.actorUserId,
});
if (messageId === undefined) throw new Error("new session requires message id");
await patchCard(rt, messageId, await projectConsoleCard(projectId, chatId, operatorOpenId, "已新开会话"));
return;
}
if (action.action === "show_session_history") {
const sessions = await listRoleSessionHistory(deps.prisma, { projectId, chatId });
if (messageId === undefined) throw new Error("session history requires message id");
await patchCard(rt, messageId, buildSessionHistoryCard({
organizationId: state.organizationId,
projectId,
roleLabel: state.selectedRole.label,
sessions,
}));
return;
}
if (action.action === "resume_agent_session") {
if (action.session_id === undefined) throw new Error("resume_agent_session requires session_id");
await resumeRoleSession(deps.prisma, {
projectId,
chatId,
sessionId: action.session_id,
actorUserId: roleDecision.actorUserId,
});
if (messageId === undefined) throw new Error("session resume requires message id");
await patchCard(rt, messageId, await projectConsoleCard(projectId, chatId, operatorOpenId, "已恢复历史会话"));
return;
}
if (state.currentSession === null || !state.currentSession.sdkSessionReady) {
throw new Error("当前角色还没有可压缩的 Claude 会话");
}
const commandMessage: MessageReceiveEvent["message"] = {
message_id: messageId ?? randomUUID(),
chat_id: chatId,
chat_type: "group",
message_type: "text",
content: JSON.stringify({ text: "/compact" }),
mentions: [],
};
await startAgentRun({
msg: commandMessage,
rt,
chatId,
projectId,
senderOpenId: operatorOpenId,
actor,
roleId: state.selectedRole.roleId,
}, "/compact", { nativeSlash: true });
return;
}
if (
action.action === "browse_move_destination" ||
action.action === "move_project" ||
action.action === "create_folder"
) {
const projectId = action.project_id;
if (projectId === undefined) throw new Error(`${action.action} requires project_id`);
const state = await loadProjectConsole(deps.prisma, { projectId, chatId });
const isOrgAdmin = isOrgAdminRole(organization.role);
const manageDecision = await authorizer.can({
actor: { feishuOpenId: operatorOpenId, chatId },
action: "collaborator.manage",
resource: { type: "PROJECT", id: projectId },
});
if (!isOrgAdmin && !manageDecision.allowed) throw new Error("project MANAGE permission is required");
if (action.action === "browse_move_destination") {
const page = await browseFolderDestinations(deps.prisma, {
organizationId: state.organizationId,
folderId: action.folder_id ?? null,
});
if (messageId === undefined) throw new Error("folder navigation requires message id");
await patchCard(rt, messageId, buildMoveProjectCard({
organizationId: state.organizationId,
projectId,
projectName: state.projectName,
...page,
}));
return;
}
if (action.action === "move_project") {
await moveProjectToFolder(deps.prisma, { projectId, folderId: action.folder_id ?? null });
await writeAudit(deps.prisma, {
projectId,
...(manageDecision.actorUserId !== undefined ? { actorUserId: manageDecision.actorUserId } : {}),
action: "project.moved_from_feishu",
metadata: { folderId: action.folder_id ?? null },
});
if (messageId === undefined) throw new Error("project move requires message id");
await patchCard(rt, messageId, await projectConsoleCard(projectId, chatId, operatorOpenId, "项目已移动"));
return;
}
if (!isOrgAdmin) throw new Error("creating an Organization folder requires OWNER or ADMIN");
const folderName = event.action.form_value?.["folder_name"];
if (typeof folderName !== "string") throw new Error("create folder form is missing folder_name");
const folder = await createFolder(deps.prisma, {
organizationId: state.organizationId,
name: folderName.slice(0, 100),
...(state.folderId !== null ? { parentId: state.folderId } : {}),
});
await writeAudit(deps.prisma, {
projectId,
action: "folder.created_from_feishu",
metadata: { folderId: folder.id, parentId: state.folderId, name: folder.name },
});
if (messageId === undefined) throw new Error("folder creation requires message id");
await patchCard(rt, messageId, await projectConsoleCard(projectId, chatId, operatorOpenId, "目录已创建"));
return;
}
if (action.action === "rename_project") {
const projectId = action.project_id;
if (projectId === undefined) throw new Error("rename_project action requires project_id");
@@ -778,12 +999,12 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
name: submittedName.slice(0, 100),
});
if (messageId === undefined) throw new Error("project rename requires message id");
await patchCard(rt, messageId, buildProjectManagementCard({
organizationId: organization.organizationId,
projectId: renamed.projectId,
projectName: renamed.name,
title: "项目名称已更新",
}));
await patchCard(rt, messageId, await projectConsoleCard(
renamed.projectId,
chatId,
operatorOpenId,
"项目名称已更新",
));
deps.logger.info({ chatId, projectId, operatorOpenId }, "project onboarding: project renamed");
return;
}
@@ -834,12 +1055,12 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
folderId: action.folder_id,
});
if (messageId !== undefined) {
await patchCard(rt, messageId, buildProjectManagementCard({
organizationId: organization.organizationId,
projectId: project.projectId,
projectName: name,
title: "已创建并绑定项目",
}));
await patchCard(rt, messageId, await projectConsoleCard(
project.projectId,
chatId,
operatorOpenId,
"已创建并绑定项目",
));
}
deps.logger.info({ chatId, projectId: project.projectId, operatorOpenId }, "project onboarding: created project from chat");
return;
@@ -863,16 +1084,12 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
chatId,
});
if (messageId !== undefined) {
const boundProject = await deps.prisma.project.findUniqueOrThrow({
where: { id: project.projectId },
select: { name: true },
});
await patchCard(rt, messageId, buildProjectManagementCard({
organizationId: organization.organizationId,
projectId: project.projectId,
projectName: boundProject.name,
title: "已绑定项目",
}));
await patchCard(rt, messageId, await projectConsoleCard(
project.projectId,
chatId,
operatorOpenId,
"已绑定项目",
));
}
deps.logger.info({ chatId, projectId: project.projectId, operatorOpenId }, "project onboarding: bound existing project");
} catch (e) {
@@ -905,7 +1122,7 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
}
const binding = await deps.prisma.projectGroupBinding.findFirst({
where: { chatId, archivedAt: null },
select: { projectId: true },
select: { projectId: true, selectedRole: { select: { roleId: true } } },
});
if (binding === null) {
deps.logger.debug({ chatId }, "feishu interrupt: chat not bound to any project");
@@ -1010,7 +1227,7 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
// ADR-0001: resolve chat → project. Unknown chat ⇒ not a project group.
const binding = await deps.prisma.projectGroupBinding.findFirst({
where: { chatId, archivedAt: null },
select: { projectId: true },
select: { projectId: true, selectedRole: { select: { roleId: true } } },
});
if (binding === null) {
deps.logger.debug({ chatId }, "feishu trigger: chat not bound to any project");
@@ -1082,53 +1299,33 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
}
}
if (cleanPrompt === null) return;
const runContext: TriggerRunContext = { msg, rt, chatId, projectId, senderOpenId, actor };
const runContext: TriggerRunContext = {
msg,
rt,
chatId,
projectId,
senderOpenId,
actor,
roleId: binding.selectedRole.roleId,
};
// Slash commands: session management, not agent runs. These bypass the
// batcher. Session commands bypass the lock because they don't create runs;
// role/unknown slash prompts still use the normal run path and queue if locked.
// Hub owns a closed slash-command protocol. Unknown commands fail visibly;
// they are never downgraded to Agent text or forwarded to the SDK.
if (cleanPrompt.startsWith("/")) {
const invocation = parseSlashInvocation(cleanPrompt);
const helpSubcommandTarget = invocation === null ? null : parseSlashHelpSubcommand(invocation);
if (helpSubcommandTarget !== null) {
// Help is generated on demand because role/tool configuration is runtime data.
const models = await deps.settings.modelRegistry({ projectId });
await sendText(rt, chatId, formatSlashHelpTarget(helpSubcommandTarget, models, slashCommands), sendOptionsForTriggerMessage(msg));
return;
}
if (invocation !== null) {
if (invocation.name === "project") {
if (invocation.args.length > 0) {
await sendText(rt, chatId, "用法: /project（打开当前项目管理卡片）", sendOptionsForTriggerMessage(msg));
await sendText(rt, chatId, "用法: /project", sendOptionsForTriggerMessage(msg));
return;
}
const project = await deps.prisma.project.findUniqueOrThrow({
where: { id: projectId },
select: { id: true, name: true, organizationId: true },
});
const organization = await resolveSingleActiveOrganizationForFeishuUser(senderOpenId);
if (organization.status !== "ok" || organization.organizationId !== project.organizationId) {
await sendText(rt, chatId, "当前身份不属于该项目组织。", sendOptionsForTriggerMessage(msg));
return;
}
if (!isOrgAdminRole(organization.role)) {
const decision = await authorizer.can({
actor,
action: "collaborator.manage",
resource: { type: "PROJECT", id: projectId },
});
if (!decision.allowed) {
await sendText(rt, chatId, "你没有管理当前项目的权限。", sendOptionsForTriggerMessage(msg));
return;
}
}
await sendCard(rt, chatId, buildProjectManagementCard({
organizationId: project.organizationId,
projectId: project.id,
projectName: project.name,
}), sendOptionsForTriggerMessage(msg));
deps.logger.info({ chatId, projectId, senderOpenId }, "feishu project management card opened");
await sendCard(
rt,
chatId,
await projectConsoleCard(projectId, chatId, senderOpenId),
sendOptionsForTriggerMessage(msg),
);
deps.logger.info({ chatId, projectId, senderOpenId }, "feishu project console opened");
return;
}
const slashCommand = slashCommands.get(invocation.name);
@@ -1146,8 +1343,8 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
return;
}
}
await startAgentRun(runContext, cleanPrompt);
const name = invocation?.name ?? cleanPrompt.slice(1).trim();
await sendText(rt, chatId, `未知 slash 命令 /${name}。使用 /help 查看可用命令。`, sendOptionsForTriggerMessage(msg));
return;
}
@@ -1161,11 +1358,11 @@ export function makeTriggerHandler(deps: TriggerDeps): TriggerHandler {
await enqueueLockedTrigger(runContext, cleanPrompt);
return;
}
const key = messageBatchKey(chatId, senderOpenId);
const key = messageBatchKey(chatId, senderOpenId, runContext.roleId);
if (!batchContexts.has(key)) {
batchContexts.set(key, runContext);
}
await messageBatcher.enqueue(chatId, senderOpenId, cleanPrompt);
await messageBatcher.enqueue(chatId, senderOpenId, cleanPrompt, runContext.roleId);
return;
}
@@ -1750,27 +1947,3 @@ async function compensateFailedResourceAdmission(
);
}
}
/**
* Parse a leading `/<role>` command from a prompt (e.g. `/draft 帮我写教案`).
* Returns the role id and the remaining prompt with the command stripped.
* Control/help commands already handled upstream are ignored here — they never
* reach this function.
*
* Unknown `/foo` that isn't a registered role: returns `null` role and the
* original prompt unchanged (the slash is treated as literal text). Role
* resolution still happens via the registry's fallback.
*/
export function extractRole(
prompt: string,
registry: { role(id: string): unknown },
): { roleId: string | null; prompt: string } {
const m = /^\/(\S+)\s*/.exec(prompt);
if (m === null || m[1] === undefined) return { roleId: null, prompt };
const roleId = m[1];
if (registry.role(roleId) === undefined) {
// Unknown slash command — leave the prompt as-is (no silent role switch).
return { roleId: null, prompt };
}
return { roleId, prompt: prompt.slice(m[0].length) };
}
hub/src/feishu/triggerQueue.ts
+3
View File
@@ -4,6 +4,9 @@ export interface QueuedTrigger {
readonly projectId: string;
readonly chatId: string;
readonly prompt: string;
/** Role frozen when the message was accepted; later group switches cannot change it. */
readonly roleId: string;
readonly executionKind: "conversation" | "native_compact";
readonly msg: MessageReceiveEvent["message"];
readonly senderOpenId: string;
readonly actor: { readonly feishuOpenId: string; readonly chatId: string };