@keyou007/agent-bot 0.1.10 → 0.1.12

package/src/commands/CommandRouter.ts

@@ -2,19 +2,16 @@ import type { Command } from "./commandTypes.js";
 
 const COMMAND_NAMES = [
   "agent",
-  "agents",
-  "ask",
   "fork",
   "forkgroup",
   "goal",
   "help",
-  "mode",
   "model",
-  "modes",
   "new",
   "newgroup",
   "nosteer",
   "permissions",
+  "provider",
   "queue",
   "restart",
   "sessions",
@@ -23,7 +20,6 @@ const COMMAND_NAMES = [
   "switch",
   "thinking",
   "title",
-  "use",
 ] as const;
 
 type CommandName = (typeof COMMAND_NAMES)[number];
@@ -34,6 +30,8 @@ const COMMAND_INITIALISMS: Partial<Record<CommandName, string>> = {
   nosteer: "ns",
 };
 
+const DISABLED_COMMAND_NAMES = new Set(["mode", "modes"]);
+
 export class CommandRouter {
   parse(text: string): Command {
     const trimmed = text.trim();
@@ -50,25 +48,17 @@ export class CommandRouter {
     const command = resolveCommandName(rawCommand);
 
     switch (command) {
-      case "agents":
-        return { type: "agent" };
       case "new":
         return parseNewCommand(args);
       case "newgroup":
         return parseNewGroupCommand(args);
       case "forkgroup":
-        return {
-          type: "forkgroup",
-          title: args.join(" ").trim() || undefined,
-        };
+        return parseForkGroupCommand(args);
       case "fork":
-        if (args.length > 1) throw new Error("/fork 只接受一个可选的任务序号或任务 ID。");
-        return args[0] ? { type: "fork", sessionId: args[0] } : { type: "fork" };
+        return parseForkCommand(args);
       case "title":
         if (args.length === 0) throw new Error("请输入新标题，例如：/title 修复会话列表。");
         return { type: "title", title: args.join(" ") };
-      case "ask":
-        return { type: "ask", text: trimmed.slice(rawCommand.length).trim() };
       case "queue":
       case "nosteer": {
         const prompt = trimmed.slice(rawCommand.length).trim();
@@ -81,8 +71,6 @@ export class CommandRouter {
         return args[0] ? { type: "switch", sessionId: args[0] } : { type: "switch" };
       case "agent":
         return args[0] ? { type: "agent", agent: args[0] } : { type: "agent" };
-      case "use":
-        return requireArg(args[0], "agent name", (agent) => ({ type: "use", agent, cwd: args[1] }));
       case "stop":
         return { type: "stop" };
       case "status":
@@ -102,22 +90,17 @@ export class CommandRouter {
         return { type: "goal", action: "set", objective: args.join(" ") };
       }
       case "restart":
-        return { type: "restart" };
-      case "modes":
-        return { type: "modes" };
-      case "mode":
-        return requireArg(args[0], "mode value", (value) => ({ type: "mode", value }));
+        if (args.length === 0) return { type: "restart" };
+        if (args.length === 1 && args[0] === "--force") return { type: "restart", force: true };
+        throw new Error("/restart 只接受一个可选的 --force 参数。");
       case "model":
-        return { type: "model", model: args[0] };
+        return settingsCommand("/model", args, { type: "model" });
+      case "provider":
+        return settingsCommand("/provider", args, { type: "provider" });
       case "thinking":
-        return { type: "thinking", effort: args[0] };
-      case "permissions": {
-        const mode = args[0];
-        if (mode !== undefined && mode !== "auto" && mode !== "confirm") {
-          throw new Error("权限模式只能是 auto 或 confirm。");
-        }
-        return { type: "permissions", mode };
-      }
+        return settingsCommand("/thinking", args, { type: "thinking" });
+      case "permissions":
+        return settingsCommand("/permissions", args, { type: "permissions" });
       case "help":
         return { type: "help" };
     }
@@ -127,6 +110,7 @@ export class CommandRouter {
 function resolveCommandName(rawCommand: string): CommandName {
   const input = rawCommand.slice(1).toLowerCase();
   if (!input) throw unknownCommand(rawCommand);
+  if (DISABLED_COMMAND_NAMES.has(input)) throw unknownCommand(rawCommand);
 
   const exact = COMMAND_NAMES.find((command) => command === input);
   if (exact) return exact;
@@ -147,23 +131,47 @@ function unknownCommand(rawCommand: string): Error {
   return new Error(`未知命令：${rawCommand}。发送 /help 查看可用命令。`);
 }
 
-function requireArg<T>(value: string | undefined, name: string, create: (value: string) => T): T {
-  if (!value) {
-    throw new Error(`Missing ${name}.`);
+function settingsCommand<T extends Command>(name: string, args: string[], command: T): T {
+  if (args.length > 0) {
+    throw new Error(`${name} 不接受参数，请在设置卡片中完成选择。`);
   }
-
-  return create(value);
+  return command;
 }
 
 function parseNewCommand(args: string[]): Extract<Command, { type: "new" }> {
+  const options = parseNewTaskOptions("/new", args, "工作目录", "D:\\dev\\project");
+  return {
+    type: "new",
+    title: options.title,
+    cwd: options.cwd,
+    ...(options.projectless ? { projectless: true } : {}),
+  };
+}
+
+function parseNewGroupCommand(args: string[]): Extract<Command, { type: "newgroup" }> {
+  const options = parseNewTaskOptions("/newgroup", args, "项目目录", "~/dev/project");
+  return {
+    type: "newgroup",
+    title: options.title,
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    ...(options.projectless ? { projectless: true } : {}),
+  };
+}
+
+function parseNewTaskOptions(
+  commandName: "/new" | "/newgroup",
+  args: string[],
+  directoryLabel: string,
+  exampleDirectory: string,
+): { title?: string; cwd?: string; projectless: boolean } {
   const titleParts: string[] = [];
   let cwd: string | undefined;
   let projectless = false;
   for (let index = 0; index < args.length; index += 1) {
     const argument = args[index]!;
     if (argument === "--nodir") {
-      if (projectless) throw new Error("/new 只能指定一次 --nodir。");
-      if (cwd !== undefined) throw new Error("/new 的 --dir 和 --nodir 不能同时使用。");
+      if (projectless) throw new Error(`${commandName} 只能指定一次 --nodir。`);
+      if (cwd !== undefined) throw new Error(`${commandName} 的 --dir 和 --nodir 不能同时使用。`);
       projectless = true;
       continue;
     }
@@ -171,33 +179,47 @@ function parseNewCommand(args: string[]): Extract<Command, { type: "new" }> {
       titleParts.push(argument);
       continue;
     }
-    if (projectless) throw new Error("/new 的 --dir 和 --nodir 不能同时使用。");
-    if (cwd !== undefined) throw new Error("/new 只能指定一次 --dir。");
+    if (projectless) throw new Error(`${commandName} 的 --dir 和 --nodir 不能同时使用。`);
+    if (cwd !== undefined) throw new Error(`${commandName} 只能指定一次 --dir。`);
     const directory = args[index + 1];
-    if (!directory || directory === "--dir") {
-      throw new Error("请在 --dir 后指定工作目录，例如：/new 修复会话列表 --dir D:\\dev\\project。");
+    if (!directory || directory === "--dir" || directory === "--nodir") {
+      throw new Error(
+        `请在 --dir 后指定${directoryLabel}，例如：${commandName} 修复会话列表 --dir ${exampleDirectory}。`,
+      );
     }
     cwd = directory;
     index += 1;
   }
   return {
-    type: "new",
     title: titleParts.join(" ").trim() || undefined,
     cwd,
-    ...(projectless ? { projectless: true } : {}),
+    projectless,
   };
 }
 
-function parseNewGroupCommand(args: string[]): Extract<Command, { type: "newgroup" }> {
-  if (args.includes("--dir")) {
-    throw new Error("/newgroup 只创建飞书群，不支持 --dir；请在新群中使用 /new --dir <cwd> 创建任务。");
-  }
+function parseForkCommand(args: string[]): Extract<Command, { type: "fork" }> {
+  rejectOptions("/fork", args);
+  if (args.length > 1) throw new Error("/fork 只接受一个可选的任务序号或任务 ID。");
   return {
-    type: "newgroup",
+    type: "fork",
+    ...(args[0] ? { sessionId: args[0] } : {}),
+  };
+}
+
+function parseForkGroupCommand(args: string[]): Extract<Command, { type: "forkgroup" }> {
+  rejectOptions("/forkgroup", args);
+  return {
+    type: "forkgroup",
     title: args.join(" ").trim() || undefined,
   };
 }
 
+function rejectOptions(command: string, args: string[]): void {
+  for (const argument of args) {
+    if (argument.startsWith("--")) throw new Error(`${command} 不支持参数：${argument}。`);
+  }
+}
+
 function splitArgs(input: string): string[] {
   const args: string[] = [];
   let current = "";

package/src/commands/commandTypes.ts

@@ -1,28 +1,23 @@
-import type { PermissionMode } from "../runtime/types.js";
-
 export type Command =
   | { type: "shell"; command: string }
   | { type: "new"; title?: string; cwd?: string; projectless?: boolean }
-  | { type: "newgroup"; title?: string }
+  | { type: "newgroup"; title?: string; cwd?: string; projectless?: boolean }
   | { type: "forkgroup"; title?: string }
   | { type: "fork"; sessionId?: string }
   | { type: "title"; title: string }
-  | { type: "ask"; text: string }
   | { type: "nosteer"; text: string }
   | { type: "sessions"; searchTerm?: string }
   | { type: "switch"; sessionId?: string }
   | { type: "agent"; agent?: string }
-  | { type: "use"; agent: string; cwd?: string }
   | { type: "stop" }
   | { type: "status"; sessionId?: string }
   | { type: "goal"; action: "show" }
   | { type: "goal"; action: "set" | "edit"; objective: string }
   | { type: "goal"; action: "pause" | "resume" | "clear" }
-  | { type: "restart" }
-  | { type: "modes" }
-  | { type: "mode"; value: string }
-  | { type: "model"; model?: string }
-  | { type: "thinking"; effort?: string }
-  | { type: "permissions"; mode?: PermissionMode }
+  | { type: "restart"; force?: boolean }
+  | { type: "model" }
+  | { type: "provider" }
+  | { type: "thinking" }
+  | { type: "permissions" }
   | { type: "help" }
   | { type: "prompt"; text: string };

package/src/config/loadConfig.ts

@@ -22,7 +22,7 @@ console:
 
 agents:
   codex:
-    kind: "codex"
+    kind: "app-server"
     title: "Codex"
     command: "codex"
     args:
@@ -33,6 +33,16 @@ agents:
       - "stdio://"
     env: {}
 
+  traex:
+    kind: "app-server"
+    title: "TraeX"
+    command: "traex"
+    args:
+      - "app-server"
+      - "--listen"
+      - "stdio://"
+    env: {}
+
   coco:
     title: "Coco"
     command: "coco"

package/src/config/schema.ts

@@ -3,8 +3,14 @@ import { DEFAULT_LOG_PATH, DEFAULT_SQLITE_PATH } from "./paths.js";
 
 const envRecordSchema = z.record(z.string(), z.string()).default({});
 
+const agentKindSchema = z.union([
+  z.literal("acp"),
+  z.literal("app-server"),
+  z.literal("codex").transform(() => "app-server" as const),
+]).default("acp");
+
 export const agentConfigSchema = z.object({
-  kind: z.enum(["acp", "codex"]).default("acp"),
+  kind: agentKindSchema,
   title: z.string().min(1),
   command: z.string().min(1),
   args: z.array(z.string()).default([]),

package/src/console/ConsoleConnector.ts

@@ -14,7 +14,7 @@ export class ConsoleConnector {
     if (this.reader) return;
     this.logger.info("Starting local Codex test console.");
     console.log("Codex console ready. Type /help or enter a prompt.");
-    const reader = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "agent-bot> " });
+    const reader = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "agentbot> " });
     this.reader = reader;
     reader.prompt();
     reader.on("line", (line) => {

package/src/console/ConsoleTurnPresenter.ts

@@ -4,27 +4,36 @@ import type { TurnPresenter } from "../presentation/OutboundRouter.js";
 
 export class ConsoleTurnPresenter implements TurnPresenter {
   private readonly contexts = new Map<string, string>();
+  private readonly agentLabels = new Map<string, string>();
   private readonly delivered = new Set<string>();
 
   constructor(private readonly outbound: FeishuOutbound) {}
 
-  registerSession(sessionId: string, contextKey: string): void {
+  registerSession(
+    sessionId: string,
+    contextKey: string,
+    _taskTitle?: string,
+    _projectCwd?: string,
+    agentLabel?: string,
+  ): void {
     this.contexts.set(sessionId, contextKey);
+    if (agentLabel) this.agentLabels.set(sessionId, agentLabel);
   }
 
   updateSessionTitle(): void {}
 
   unregisterSession(sessionId: string): void {
     this.contexts.delete(sessionId);
+    this.agentLabels.delete(sessionId);
   }
 
-  async startPendingTurn(_sessionId: string, contextKey: string): Promise<void> {
-    await this.outbound.sendText(contextKey, "Connecting to Codex...");
+  async startPendingTurn(sessionId: string, contextKey: string): Promise<void> {
+    await this.outbound.sendText(contextKey, `Connecting to ${this.agentLabel(sessionId)}...`);
   }
 
   async failPendingTurn(sessionId: string, message: string): Promise<void> {
     const contextKey = this.contexts.get(sessionId);
-    if (contextKey) await this.outbound.sendText(contextKey, `Codex failed to start: ${message}`);
+    if (contextKey) await this.outbound.sendText(contextKey, `${this.agentLabel(sessionId)} failed to start: ${message}`);
   }
 
   async appendSteerMessage(): Promise<void> {}
@@ -33,20 +42,20 @@ export class ConsoleTurnPresenter implements TurnPresenter {
     const contextKey = this.contexts.get(event.sessionId);
     if (!contextKey) return;
     if (event.type === "turn_started") {
-      await this.outbound.sendText(contextKey, `Codex started (${event.turnId})`);
+      await this.outbound.sendText(contextKey, `${this.agentLabel(event.sessionId)} started (${event.turnId})`);
     } else if (event.type === "progress") {
       await this.outbound.sendText(contextKey, event.text);
     } else if (event.type === "tool_started") {
       await this.outbound.sendText(contextKey, `> ${event.tool.title}`);
     } else if (event.type === "approval_requested") {
-      await this.outbound.sendText(contextKey, `Approval required: ${event.request.title}. Use Feishu or /permissions auto.`);
+      await this.outbound.sendText(contextKey, `Approval required: ${event.request.title}. Use Feishu's Permission settings card.`);
     } else if (event.type === "turn_completed" && !this.delivered.has(event.turnId)) {
       this.delivered.add(event.turnId);
       await this.outbound.sendMarkdown(contextKey, event.finalResponse || "(completed without text)");
     } else if (event.type === "turn_failed") {
-      await this.outbound.sendText(contextKey, `Codex failed: ${event.message}`);
+      await this.outbound.sendText(contextKey, `${this.agentLabel(event.sessionId)} failed: ${event.message}`);
     } else if (event.type === "turn_cancelled") {
-      await this.outbound.sendText(contextKey, "Codex stopped.");
+      await this.outbound.sendText(contextKey, `${this.agentLabel(event.sessionId)} stopped.`);
     }
   }
 
@@ -61,4 +70,8 @@ export class ConsoleTurnPresenter implements TurnPresenter {
   async resumeDelivery(): Promise<void> {}
 
   async flushAll(): Promise<void> {}
+
+  private agentLabel(sessionId: string): string {
+    return this.agentLabels.get(sessionId) ?? "Agent";
+  }
 }

package/src/deprecated-cli.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { cliText } from "./cli/i18n.js";
+
+process.stderr.write(`${cliText(
+  "Warning: `agent-bot` is deprecated and will be removed in a future release. Use `agentbot` instead.",
+  "警告：`agent-bot` 已弃用，并将在后续版本中移除。请改用 `agentbot`。",
+)}\n`);
+
+await import("./cli.js");