@keyou007/agent-bot 0.1.15-alpha.4 → 0.1.15-alpha.6

package/src/config/schema.ts

@@ -3,6 +3,37 @@ import { DEFAULT_LOG_PATH, DEFAULT_SQLITE_PATH } from "./paths.js";
 
 const envRecordSchema = z.record(z.string(), z.string()).default({});
 
+export const DEFAULT_GROUP_NAME_FORMAT = {
+  project: "[{agent}] [{project}] {taskname}",
+  projectless: "[{agent}] {taskname}",
+  dateFormat: "MM-dd",
+} as const;
+
+const groupNameTemplateSchema = z.string().min(1).max(240).superRefine((template, context) => {
+  const tokens = [...template.matchAll(/\{([^{}]+)\}/gu)].map((match) => match[1]!);
+  const taskNameCount = tokens.filter((token) => token === "taskname").length;
+  if (taskNameCount !== 1) {
+    context.addIssue({
+      code: "custom",
+      message: "A group name format must contain exactly one {taskname} placeholder.",
+    });
+  }
+  for (const token of tokens) {
+    if (["os", "agent", "project", "taskname", "date"].includes(token)) continue;
+    if (token.startsWith("date:") && token.slice("date:".length).trim()) continue;
+    context.addIssue({
+      code: "custom",
+      message: `Unsupported group name placeholder: {${token}}.`,
+    });
+  }
+});
+
+const groupNameFormatSchema = z.object({
+  project: groupNameTemplateSchema.default(DEFAULT_GROUP_NAME_FORMAT.project),
+  projectless: groupNameTemplateSchema.default(DEFAULT_GROUP_NAME_FORMAT.projectless),
+  dateFormat: z.string().min(1).max(80).default(DEFAULT_GROUP_NAME_FORMAT.dateFormat),
+}).default(DEFAULT_GROUP_NAME_FORMAT);
+
 const agentKindSchema = z.union([
   z.literal("acp"),
   z.literal("app-server"),
@@ -30,6 +61,7 @@ export const appConfigSchema = z.object({
     userOpenId: z.string().optional(),
     respondToOwnerOnly: z.boolean().default(true),
     respondToAllGroupMessages: z.boolean().default(true),
+    groupNameFormat: groupNameFormatSchema,
     thinkingCardLayout: z.enum(["grouped", "timeline"]).default("grouped"),
     useConsoleWhenMissingCredentials: z.boolean().default(false),
   }),
@@ -53,4 +85,5 @@ export const appConfigSchema = z.object({
 });
 
 export type AgentConfig = z.infer<typeof agentConfigSchema>;
+export type GroupNameFormatConfig = z.infer<typeof groupNameFormatSchema>;
 export type AppConfig = z.infer<typeof appConfigSchema>;

package/src/feishu/CardRenderer.ts

@@ -240,11 +240,12 @@ export interface DismissGroupCardView {
 }
 
 export interface ShellCommandCardView {
+  jobId?: string;
+  contextKey?: string;
   command: string;
   cwd: string;
-  stdout: string;
-  stderr: string;
-  status: "running" | "completed" | "failed" | "timed_out";
+  output: string;
+  status: "running" | "cancelling" | "completed" | "failed" | "cancelled" | "timed_out";
   exitCode?: number | null;
   elapsedMs: number;
   outputTruncated: boolean;
@@ -258,12 +259,7 @@ export class CardRenderer {
   }
 
   renderShellCommandCard(view: ShellCommandCardView): Record<string, unknown> {
-    const stdout = normalizeTerminalOutput(view.stdout).trimEnd();
-    const stderr = normalizeTerminalOutput(view.stderr).trimEnd();
-    const rawOutput = [
-      stdout,
-      stderr ? `[stderr]\n${stderr}` : "",
-    ].filter(Boolean).join("\n");
+    const rawOutput = normalizeTerminalOutput(view.output).trimEnd();
     const displayOutput = truncateMiddle(
       rawOutput,
       6_000,
@@ -273,15 +269,32 @@ export class CardRenderer {
     const output = displayOutput || (view.status === "running" ? "等待输出..." : "（无输出）");
     const status = shellCommandStatus(view);
     const outputWasTruncated = view.outputTruncated || rawOutput.length > 6_000;
+    const elements = [
+      markdown(codeBlock(`$  ${command}\n${output}`, 6_700)),
+      markdown([
+        `${inlineCode(view.cwd)} · ${status.label} · ${formatTurnDuration(view.elapsedMs)}`,
+        ...(outputWasTruncated ? ["输出过长，已保留开头和结尾并截断中间内容。"] : []),
+      ].join("\n")),
+    ];
+    if (view.status === "running" && view.jobId && view.contextKey) {
+      elements.push({
+        tag: "button",
+        text: { tag: "plain_text", content: "Cancel" },
+        type: "danger",
+        size: "small",
+        behaviors: [{
+          type: "callback",
+          value: {
+            action: "shell_command_cancel",
+            jobId: view.jobId,
+            contextKey: view.contextKey,
+          },
+        }],
+      });
+    }
     return sectionCard(
       status.title,
-      [
-        markdown(codeBlock(`$  ${command}\n${output}`, 6_700)),
-        markdown([
-          `${inlineCode(view.cwd)} · ${status.label} · ${formatTurnDuration(view.elapsedMs)}`,
-          ...(outputWasTruncated ? ["输出过长，已保留开头和结尾并截断中间内容。"] : []),
-        ].join("\n")),
-      ],
+      elements,
       status.template,
     );
   }
@@ -2052,11 +2065,66 @@ function renderToolDetails(tool: ToolState, projectCwd?: string): string {
   const displayCommand = tool.kind === "command"
     ? unwrapShellCommand(normalizedCommand) ?? normalizedCommand
     : normalizedCommand;
-  const commandText = truncateText(displayCommand, 600);
+  const commandText = truncateText(
+    tool.kind === "command" ? formatShellCommandForDisplay(displayCommand) : displayCommand,
+    600,
+  );
   const resultText = result ? truncateToolResult(normalizeTerminalOutput(result).trim()) : undefined;
   return codeBlock([`$ ${commandText}`, resultText].filter((part): part is string => part !== undefined).join("\n"), 2_003);
 }
 
+function formatShellCommandForDisplay(command: string): string {
+  const normalized = command.replace(/\r\n/g, "\n");
+  let result = "";
+  let quote: "'" | "\"" | undefined;
+
+  for (let index = 0; index < normalized.length; index += 1) {
+    const character = normalized[index] ?? "";
+
+    if (quote) {
+      result += character;
+      if ((character === "\\" || character === "`") && quote === "\"") {
+        if (index + 1 < normalized.length) result += normalized[++index];
+      } else if (character === quote) {
+        quote = undefined;
+      }
+      continue;
+    }
+
+    if (character === "'" || character === "\"") {
+      quote = character;
+      result += character;
+      continue;
+    }
+
+    if (character === "\\" || character === "`" || character === "^") {
+      result += character;
+      if (index + 1 < normalized.length) result += normalized[++index];
+      continue;
+    }
+
+    const operator = readShellDisplayOperator(normalized, index);
+    if (!operator) {
+      result += character;
+      continue;
+    }
+
+    result += operator;
+    index += operator.length - 1;
+    while (index + 1 < normalized.length && /\s/.test(normalized[index + 1] ?? "")) index += 1;
+    if (index + 1 < normalized.length) result += " \\\n  ";
+  }
+
+  return result;
+}
+
+function readShellDisplayOperator(command: string, index: number): string | undefined {
+  for (const operator of ["&&", "||", "|&", ";", "|"]) {
+    if (command.startsWith(operator, index)) return operator;
+  }
+  return undefined;
+}
+
 function normalizeTerminalOutput(value: string): string {
   const clean = stripAnsi(value).replace(/\r\n/g, "\n");
   return clean
@@ -2167,6 +2235,12 @@ function shellCommandStatus(view: ShellCommandCardView): {
   if (view.status === "running") {
     return { title: "正在执行命令", label: "运行中", template: "blue" };
   }
+  if (view.status === "cancelling") {
+    return { title: "正在取消命令", label: "正在取消", template: "orange" };
+  }
+  if (view.status === "cancelled") {
+    return { title: "命令已取消", label: "已取消", template: "grey" };
+  }
   if (view.status === "timed_out") {
     return { title: "命令执行超时", label: "已超时（120s）", template: "orange" };
   }

package/src/feishu/FinalResponseBranding.ts

@@ -1,4 +1,5 @@
-export const FINAL_RESPONSE_BRANDING = "> Powered by [AgentBot](https://github.com/keyou/agent-bot)";
+export const FINAL_RESPONSE_BRANDING =
+  "> Powered by [AgentBot](https://keyou.github.io/agent-bot/)";
 export const FINAL_RESPONSE_BRANDING_BLOCK = `----\n\n${FINAL_RESPONSE_BRANDING}`;
 
 export function splitFinalResponseBranding(markdown: string): {

package/src/feishu/GroupNameFormatter.ts

@@ -0,0 +1,222 @@
+import os from "node:os";
+import path from "node:path";
+import {
+  DEFAULT_GROUP_NAME_FORMAT,
+  type GroupNameFormatConfig,
+} from "../config/schema.js";
+
+export const FEISHU_GROUP_NAME_MAX_LENGTH = 60;
+const GROUP_PROJECT_NAME_MAX_LENGTH = 15;
+const PLACEHOLDER_PATTERN = /\{([^{}]+)\}/gu;
+const TASK_NAME_PLACEHOLDER = "{taskname}";
+
+export interface GroupNameFormatInput {
+  agentName: string;
+  projectCwd?: string;
+  taskName: string;
+  date?: Date;
+  platform?: NodeJS.Platform;
+  format?: GroupNameFormatConfig;
+}
+
+export interface GroupNameParseInput {
+  agentName: string;
+  groupName: string;
+  projectCwd?: string;
+  platform?: NodeJS.Platform;
+  format?: GroupNameFormatConfig;
+}
+
+export function formatNewGroupName(input: GroupNameFormatInput): string {
+  const format = input.format ?? DEFAULT_GROUP_NAME_FORMAT;
+  const template = input.projectCwd ? format.project : format.projectless;
+  const taskNameIndex = template.indexOf(TASK_NAME_PLACEHOLDER);
+  const values = templateValues(input, format);
+  const prefix = renderTemplate(template.slice(0, taskNameIndex), values);
+  const suffix = renderTemplate(template.slice(taskNameIndex + TASK_NAME_PLACEHOLDER.length), values);
+  const availableTaskNameLength = FEISHU_GROUP_NAME_MAX_LENGTH
+    - Array.from(prefix).length
+    - Array.from(suffix).length;
+  const taskName = truncateTail(input.taskName, availableTaskNameLength);
+  return truncateTail(`${prefix}${taskName}${suffix}`.trim(), FEISHU_GROUP_NAME_MAX_LENGTH);
+}
+
+export function parseTaskNameFromGroupName(input: GroupNameParseInput): string | undefined {
+  const format = input.format ?? DEFAULT_GROUP_NAME_FORMAT;
+  const template = input.projectCwd ? format.project : format.projectless;
+  const values = templateValues(input, format);
+  let pattern = "^";
+  let cursor = 0;
+  let match: RegExpExecArray | null;
+  PLACEHOLDER_PATTERN.lastIndex = 0;
+  while ((match = PLACEHOLDER_PATTERN.exec(template)) !== null) {
+    pattern += escapeRegExp(template.slice(cursor, match.index));
+    const token = match[1]!;
+    if (token === "taskname") pattern += "(?<taskname>.+?)";
+    else if (token === "date" || token.startsWith("date:")) {
+      const dateFormat = token === "date" ? format.dateFormat : token.slice("date:".length);
+      pattern += dateFormatPattern(dateFormat);
+    } else {
+      pattern += escapeRegExp(placeholderValue(token, values));
+    }
+    cursor = match.index + match[0].length;
+  }
+  pattern += `${escapeRegExp(template.slice(cursor))}$`;
+  const parsed = new RegExp(pattern, "iu").exec(input.groupName.trim())?.groups?.taskname?.trim();
+  return parsed || undefined;
+}
+
+export function formatGroupNameDate(date: Date, format: string): string {
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1;
+  const day = date.getDate();
+  const hour = date.getHours();
+  const minute = date.getMinutes();
+  const second = date.getSeconds();
+  const values = new Map<string, string>([
+    ["yyyy", String(year).padStart(4, "0")],
+    ["YYYY", String(year).padStart(4, "0")],
+    ["yy", String(year % 100).padStart(2, "0")],
+    ["YY", String(year % 100).padStart(2, "0")],
+    ["MM", String(month).padStart(2, "0")],
+    ["M", String(month)],
+    ["dd", String(day).padStart(2, "0")],
+    ["DD", String(day).padStart(2, "0")],
+    ["d", String(day)],
+    ["D", String(day)],
+    ["HH", String(hour).padStart(2, "0")],
+    ["H", String(hour)],
+    ["mm", String(minute).padStart(2, "0")],
+    ["m", String(minute)],
+    ["ss", String(second).padStart(2, "0")],
+    ["s", String(second)],
+  ]);
+  return replaceDateTokens(format, (token) => values.get(token)!);
+}
+
+export function groupNameOs(platform: NodeJS.Platform = process.platform): string {
+  if (platform === "win32") return "win";
+  if (platform === "darwin") return "mac";
+  if (platform === "linux") return "linux";
+  return platform;
+}
+
+export function formatGroupProjectName(projectCwd: string): string {
+  const value = abbreviateHomeDirectory(projectCwd);
+  const levels = value
+    .replace(/[\\/]+$/, "")
+    .split(/[\\/]+/)
+    .filter(Boolean)
+    .slice(-2);
+  const separator = value.includes("\\") ? path.win32.sep : path.posix.sep;
+  return fitTrailingPathLevels(levels, GROUP_PROJECT_NAME_MAX_LENGTH, separator);
+}
+
+interface TemplateValues {
+  agent: string;
+  project: string;
+  os: string;
+  date: Date;
+  dateFormat: string;
+}
+
+function templateValues(
+  input: Pick<GroupNameFormatInput, "agentName" | "projectCwd" | "date" | "platform">,
+  format: GroupNameFormatConfig,
+): TemplateValues {
+  return {
+    agent: input.agentName,
+    project: input.projectCwd ? formatGroupProjectName(input.projectCwd) : "",
+    os: groupNameOs(input.platform),
+    date: input.date ?? new Date(),
+    dateFormat: format.dateFormat,
+  };
+}
+
+function renderTemplate(template: string, values: TemplateValues): string {
+  PLACEHOLDER_PATTERN.lastIndex = 0;
+  return template.replace(PLACEHOLDER_PATTERN, (_placeholder, token: string) => {
+    if (token === "date") return formatGroupNameDate(values.date, values.dateFormat);
+    if (token.startsWith("date:")) {
+      return formatGroupNameDate(values.date, token.slice("date:".length));
+    }
+    return placeholderValue(token, values);
+  });
+}
+
+function placeholderValue(token: string, values: TemplateValues): string {
+  if (token === "agent") return values.agent;
+  if (token === "project") return values.project;
+  if (token === "os") return values.os;
+  return "";
+}
+
+function dateFormatPattern(format: string): string {
+  return replaceDateTokens(format, (token) => {
+    if (["yyyy", "YYYY"].includes(token)) return "\\d{4}";
+    if (["yy", "YY", "MM", "dd", "DD", "HH", "mm", "ss"].includes(token)) return "\\d{2}";
+    return "\\d{1,2}";
+  }, escapeRegExp);
+}
+
+const DATE_TOKENS = [
+  "yyyy", "YYYY", "yy", "YY", "MM", "dd", "DD", "HH", "mm", "ss", "M", "d", "D", "H", "m", "s",
+];
+
+function replaceDateTokens(
+  format: string,
+  replaceToken: (token: string) => string,
+  replaceLiteral: (literal: string) => string = (literal) => literal,
+): string {
+  let result = "";
+  for (let index = 0; index < format.length;) {
+    const token = DATE_TOKENS.find((candidate) => format.startsWith(candidate, index));
+    if (token) {
+      result += replaceToken(token);
+      index += token.length;
+    } else {
+      result += replaceLiteral(format[index]!);
+      index += 1;
+    }
+  }
+  return result;
+}
+
+function abbreviateHomeDirectory(value: string): string {
+  const homeDirectory = os.homedir();
+  const valueIsWindows = isWindowsAbsolutePath(value);
+  const homeIsWindows = isWindowsAbsolutePath(homeDirectory);
+  if (valueIsWindows !== homeIsWindows && (valueIsWindows || path.posix.isAbsolute(value))) return value;
+  const pathApi = valueIsWindows ? path.win32 : path;
+  const relative = pathApi.relative(homeDirectory, value);
+  if (relative === "") return "~";
+  if (pathApi.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${pathApi.sep}`)) return value;
+  return `~${pathApi.sep}${relative}`;
+}
+
+function isWindowsAbsolutePath(value: string): boolean {
+  return /^[a-z]:[\\/]|^\\\\/iu.test(value);
+}
+
+function fitTrailingPathLevels(levels: string[], maxLength: number, separator: string): string {
+  if (levels.length === 0) return "";
+  if (levels.length === 1) return truncateTail(levels[0]!, maxLength);
+  const parent = levels[0]!;
+  const leaf = levels[1]!;
+  const joined = `${parent}${separator}${leaf}`;
+  if (Array.from(joined).length <= maxLength) return joined;
+  if (Array.from(leaf).length <= maxLength) return leaf;
+  return truncateTail(leaf, maxLength);
+}
+
+function truncateTail(value: string, maxLength: number): string {
+  const characters = Array.from(value);
+  if (characters.length <= maxLength) return value;
+  if (maxLength <= 0) return "";
+  if (maxLength <= 3) return ".".repeat(maxLength);
+  return `${characters.slice(0, maxLength - 3).join("")}...`;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}