@keyou007/agent-bot 0.1.0

package/src/codex/ProjectlessWorkspace.ts

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+
+export interface ProjectlessWorkspace {
+  cwd: string;
+  outputDirectory: string;
+  workspaceRoot: string;
+}
+
+export function createProjectlessWorkspace(options: {
+  prompt?: string;
+  directoryName?: string;
+  homeDirectory?: string;
+  now?: Date;
+} = {}): ProjectlessWorkspace {
+  const workspaceRoot = path.join(options.homeDirectory ?? os.homedir(), "Documents", "Codex");
+  const dateDirectory = path.join(workspaceRoot, formatDate(options.now ?? new Date()));
+  ensureRealDirectory(workspaceRoot);
+  ensureRealDirectory(dateDirectory);
+
+  const baseName = projectlessDirectoryName(options.directoryName, options.prompt);
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    const name = attempt === 0 ? baseName : `${baseName}-${attempt + 1}`;
+    const workspace = tryCreateWorkspace(dateDirectory, name, workspaceRoot);
+    if (workspace) return workspace;
+  }
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    const suffix = randomUUID().replaceAll("-", "").slice(0, 8);
+    const workspace = tryCreateWorkspace(dateDirectory, `${baseName}-${suffix}`, workspaceRoot);
+    if (workspace) return workspace;
+  }
+  throw new Error("Unable to create a unique Codex projectless task directory.");
+}
+
+export function detectProjectlessWorkspace(cwd: string): ProjectlessWorkspace | undefined {
+  const normalized = path.resolve(cwd);
+  const match = normalized.match(/^(.*[\\/]Documents[\\/]Codex)[\\/]\d{4}-\d{2}-\d{2}[\\/][a-z0-9][a-z0-9-]*[\\/]*$/i);
+  if (!match?.[1]) return undefined;
+  return {
+    cwd: normalized,
+    outputDirectory: path.join(normalized, "outputs"),
+    workspaceRoot: match[1],
+  };
+}
+
+function projectlessDirectoryName(directoryName?: string, prompt?: string): string {
+  const words = (directoryName ?? prompt)?.toLowerCase().match(/[a-z0-9]+/g);
+  if (!words?.length) return "new-chat";
+  return (directoryName === undefined ? words.slice(0, 6) : words).join("-").slice(0, 80);
+}
+
+function tryCreateWorkspace(
+  dateDirectory: string,
+  directoryName: string,
+  workspaceRoot: string,
+): ProjectlessWorkspace | undefined {
+  const cwd = path.join(dateDirectory, directoryName);
+  try {
+    fs.mkdirSync(cwd);
+  } catch (error) {
+    if (isAlreadyExists(error)) return undefined;
+    throw error;
+  }
+  const outputDirectory = path.join(cwd, "outputs");
+  fs.mkdirSync(outputDirectory);
+  fs.mkdirSync(path.join(cwd, "work"));
+  return { cwd, outputDirectory, workspaceRoot };
+}
+
+function ensureRealDirectory(directory: string): void {
+  fs.mkdirSync(directory, { recursive: true });
+  const metadata = fs.lstatSync(directory);
+  if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+    throw new Error(`Codex projectless task directory must be a real directory: ${directory}`);
+  }
+}
+
+function formatDate(date: Date): string {
+  return [
+    date.getFullYear(),
+    String(date.getMonth() + 1).padStart(2, "0"),
+    String(date.getDate()).padStart(2, "0"),
+  ].join("-");
+}
+
+function isAlreadyExists(error: unknown): boolean {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}

package/src/codex/protocol.ts

@@ -0,0 +1,37 @@
+export type AppServerRequestId = string | number;
+
+export interface AppServerRequest {
+  id: AppServerRequestId;
+  method: string;
+  params?: unknown;
+}
+
+export interface AppServerNotification {
+  method: string;
+  params?: unknown;
+}
+
+export interface AppServerSuccess {
+  id: AppServerRequestId;
+  result: unknown;
+}
+
+export interface AppServerFailure {
+  id: AppServerRequestId;
+  error: { code: number; message: string; data?: unknown };
+}
+
+export type AppServerResponse = AppServerSuccess | AppServerFailure;
+export type AppServerMessage = AppServerRequest | AppServerNotification | AppServerResponse;
+
+export function isResponse(message: AppServerMessage): message is AppServerResponse {
+  return "id" in message && !("method" in message) && ("result" in message || "error" in message);
+}
+
+export function isRequest(message: AppServerMessage): message is AppServerRequest {
+  return "id" in message && "method" in message;
+}
+
+export function isNotification(message: AppServerMessage): message is AppServerNotification {
+  return !("id" in message) && "method" in message;
+}

package/src/commands/CommandRouter.ts

@@ -0,0 +1,179 @@
+import type { Command } from "./commandTypes.js";
+
+export class CommandRouter {
+  parse(text: string): Command {
+    const trimmed = text.trim();
+    if (trimmed.startsWith("!") || trimmed.startsWith("！")) {
+      const command = trimmed.slice(1).trim();
+      if (!command) throw new Error("请输入要执行的命令，例如：! ls 或 ！ls");
+      return { type: "shell", command };
+    }
+    if (!trimmed.startsWith("/")) {
+      return { type: "prompt", text };
+    }
+
+    const [rawCommand, ...args] = splitArgs(trimmed);
+    const command = rawCommand.slice(1).toLowerCase();
+
+    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,
+        };
+      case "fork":
+        if (args.length > 1) throw new Error("/fork 只接受一个可选的任务序号或任务 ID。");
+        return args[0] ? { type: "fork", sessionId: args[0] } : { type: "fork" };
+      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();
+        if (!prompt) throw new Error(`请输入要排队的 Prompt，例如：/${command} 完成后再运行全部测试。`);
+        return { type: "nosteer", text: prompt };
+      }
+      case "sessions":
+        return { type: "sessions", searchTerm: trimmed.slice(rawCommand.length).trim() || undefined };
+      case "switch":
+        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":
+        return args[0] ? { type: "status", sessionId: args[0] } : { type: "status" };
+      case "goal": {
+        if (args.length === 0) return { type: "goal", action: "show" };
+        const action = args[0]!.toLowerCase();
+        if (action === "pause" || action === "resume" || action === "clear") {
+          if (args.length > 1) throw new Error(`/goal ${action} 不接受额外参数。`);
+          return { type: "goal", action };
+        }
+        if (action === "edit") {
+          const objective = args.slice(1).join(" ").trim();
+          if (!objective) throw new Error("请输入修改后的 Goal，例如：/goal edit 完成迁移并通过全部测试。");
+          return { type: "goal", action: "edit", objective };
+        }
+        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 }));
+      case "model":
+        return { type: "model", model: args[0] };
+      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 };
+      }
+      case "help":
+        return { type: "help" };
+      default:
+        throw new Error(`未知命令：${rawCommand}。发送 /help 查看可用命令。`);
+    }
+  }
+}
+
+function requireArg<T>(value: string | undefined, name: string, create: (value: string) => T): T {
+  if (!value) {
+    throw new Error(`Missing ${name}.`);
+  }
+
+  return create(value);
+}
+
+function parseNewCommand(args: string[]): Extract<Command, { type: "new" }> {
+  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 不能同时使用。");
+      projectless = true;
+      continue;
+    }
+    if (argument !== "--dir") {
+      titleParts.push(argument);
+      continue;
+    }
+    if (projectless) throw new Error("/new 的 --dir 和 --nodir 不能同时使用。");
+    if (cwd !== undefined) throw new Error("/new 只能指定一次 --dir。");
+    const directory = args[index + 1];
+    if (!directory || directory === "--dir") {
+      throw new Error("请在 --dir 后指定工作目录，例如：/new 修复会话列表 --dir D:\\dev\\project。");
+    }
+    cwd = directory;
+    index += 1;
+  }
+  return {
+    type: "new",
+    title: titleParts.join(" ").trim() || undefined,
+    cwd,
+    ...(projectless ? { projectless: true } : {}),
+  };
+}
+
+function parseNewGroupCommand(args: string[]): Extract<Command, { type: "newgroup" }> {
+  if (args.includes("--dir")) {
+    throw new Error("/newgroup 只创建飞书群，不支持 --dir；请在新群中使用 /new --dir <cwd> 创建任务。");
+  }
+  return {
+    type: "newgroup",
+    title: args.join(" ").trim() || undefined,
+  };
+}
+
+function splitArgs(input: string): string[] {
+  const args: string[] = [];
+  let current = "";
+  let quote: string | undefined;
+
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    if ((char === '"' || char === "'") && !quote) {
+      quote = char;
+      continue;
+    }
+
+    if (char === quote) {
+      quote = undefined;
+      continue;
+    }
+
+    if (/\s/.test(char) && !quote) {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current) {
+    args.push(current);
+  }
+
+  return args;
+}

package/src/commands/commandTypes.ts

@@ -0,0 +1,28 @@
+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: "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: "help" }
+  | { type: "prompt"; text: string };

package/src/config/loadConfig.ts

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import path from "node:path";
+import { config as loadDotEnv } from "dotenv";
+import YAML from "yaml";
+import { appConfigSchema, type AppConfig } from "./schema.js";
+import { defaultConfigPath, defaultDotEnvPath, resolveUserPath } from "./paths.js";
+
+const ENV_PATTERN = /\$\{([A-Z0-9_]+)\}/gi;
+const DEFAULT_CONFIG = `feishu:
+  transport: "auto"
+  appId: "\${FEISHU_APP_ID}"
+  appSecret: "\${FEISHU_APP_SECRET}"
+  useConsoleWhenMissingCredentials: true
+
+console:
+  enabled: true
+
+agents:
+  codex:
+    kind: "codex"
+    title: "Codex"
+    command: "codex"
+    args:
+      - "app-server"
+      - "--enable"
+      - "goals"
+      - "--listen"
+      - "stdio://"
+    env: {}
+
+  coco:
+    title: "Coco"
+    command: "coco"
+    args:
+      - "acp"
+      - "serve"
+    env: {}
+
+  coco-yolo:
+    title: "Coco YOLO"
+    command: "coco"
+    args:
+      - "acp"
+      - "serve"
+      - "--yolo"
+    env: {}
+
+  example:
+    title: "Example ACP Agent"
+    command: "node"
+    args:
+      - "./examples/example-acp-agent.js"
+    env: {}
+
+defaults:
+  agent: "codex"
+  cwd: "."
+
+storage:
+  sqlitePath: "./data/agent-bot.sqlite"
+
+logging:
+  level: "info"
+  path: "./logs/agent-bot.log"
+`;
+
+export function loadConfig(
+  configPath?: string,
+): AppConfig {
+  loadDotEnv({ path: defaultDotEnvPath(), quiet: true });
+
+  const configuredPath = firstNonBlank(configPath, process.env.AGENT_BOT_CONFIG);
+  const absolutePath = resolveUserPath(configuredPath ?? defaultConfigPath());
+  if (!fs.existsSync(absolutePath)) {
+    if (configuredPath) throw new Error(`Config file does not exist: ${absolutePath}`);
+    fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+    fs.writeFileSync(absolutePath, DEFAULT_CONFIG);
+  }
+
+  const raw = fs.readFileSync(absolutePath, "utf8");
+  const expanded = expandEnv(raw);
+  const parsed = YAML.parse(expanded) as unknown;
+  const config = appConfigSchema.parse(parsed);
+
+  const defaultAgent = config.defaults.agent ?? Object.keys(config.agents)[0];
+  if (!config.agents[defaultAgent]) {
+    throw new Error(`Default agent "${defaultAgent}" is not configured.`);
+  }
+
+  const configDirectory = path.dirname(absolutePath);
+  const sqlitePath = resolveUserPath(config.storage.sqlitePath, configDirectory);
+  return {
+    ...config,
+    defaults: {
+      ...config.defaults,
+      agent: defaultAgent,
+      cwd: path.resolve(config.defaults.cwd),
+    },
+    storage: {
+      sqlitePath,
+    },
+    logging: {
+      ...config.logging,
+      path: resolveUserPath(config.logging.path, configDirectory),
+    },
+  };
+}
+
+function expandEnv(raw: string): string {
+  return raw.replace(ENV_PATTERN, (_match, name: string) => process.env[name] ?? "");
+}
+
+function firstNonBlank(...values: Array<string | undefined>): string | undefined {
+  return values.find((value) => value !== undefined && value.trim().length > 0);
+}

package/src/config/paths.ts

@@ -0,0 +1,37 @@
+import os from "node:os";
+import path from "node:path";
+
+export const AGENT_BOT_HOME_ENV = "AGENT_BOT_HOME";
+export const DEFAULT_CONFIG_FILE = "config.yaml";
+export const DEFAULT_ENV_FILE = ".env";
+export const DEFAULT_SQLITE_PATH = "./data/agent-bot.sqlite";
+export const DEFAULT_LOG_PATH = "./logs/agent-bot.log";
+
+export function agentBotHome(env: NodeJS.ProcessEnv = process.env): string {
+  return path.resolve(expandHome(env[AGENT_BOT_HOME_ENV] ?? path.join(os.homedir(), ".agent-bot")));
+}
+
+export function defaultConfigPath(env: NodeJS.ProcessEnv = process.env): string {
+  return path.join(agentBotHome(env), DEFAULT_CONFIG_FILE);
+}
+
+export function defaultDotEnvPath(env: NodeJS.ProcessEnv = process.env): string {
+  return path.join(agentBotHome(env), DEFAULT_ENV_FILE);
+}
+
+export function defaultSqlitePath(env: NodeJS.ProcessEnv = process.env): string {
+  return path.join(agentBotHome(env), "data", "agent-bot.sqlite");
+}
+
+export function resolveUserPath(input: string, baseDirectory = process.cwd()): string {
+  const expanded = expandHome(input);
+  return path.isAbsolute(expanded) ? path.normalize(expanded) : path.resolve(baseDirectory, expanded);
+}
+
+function expandHome(input: string): string {
+  if (input === "~") return os.homedir();
+  if (input.startsWith("~/") || input.startsWith("~\\")) {
+    return path.join(os.homedir(), input.slice(2));
+  }
+  return input;
+}

package/src/config/schema.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { DEFAULT_LOG_PATH, DEFAULT_SQLITE_PATH } from "./paths.js";
+
+const envRecordSchema = z.record(z.string(), z.string()).default({});
+
+export const agentConfigSchema = z.object({
+  kind: z.enum(["acp", "codex"]).default("acp"),
+  title: z.string().min(1),
+  command: z.string().min(1),
+  args: z.array(z.string()).default([]),
+  env: envRecordSchema,
+});
+
+export const appConfigSchema = z.object({
+  console: z
+    .object({
+      enabled: z.boolean().default(true),
+    })
+    .default({ enabled: true }),
+  feishu: z.object({
+    transport: z.enum(["auto", "sdk", "console"]).default("auto"),
+    appId: z.string().optional(),
+    appSecret: z.string().optional(),
+    useConsoleWhenMissingCredentials: z.boolean().default(true),
+  }),
+  agents: z.record(z.string().min(1), agentConfigSchema).refine(
+    (agents) => Object.keys(agents).length > 0,
+    "At least one agent must be configured.",
+  ),
+  defaults: z
+    .object({
+      agent: z.string().optional(),
+      cwd: z.string().default("."),
+    })
+    .default({ cwd: "." }),
+  storage: z.object({
+    sqlitePath: z.string().default(DEFAULT_SQLITE_PATH),
+  }).default({ sqlitePath: DEFAULT_SQLITE_PATH }),
+  logging: z.object({
+    level: z.enum(["trace", "debug", "info", "warn", "error", "fatal"]).default("info"),
+    path: z.string().optional().default(DEFAULT_LOG_PATH),
+  }).default({ level: "info", path: DEFAULT_LOG_PATH }),
+});
+
+export type AgentConfig = z.infer<typeof agentConfigSchema>;
+export type AppConfig = z.infer<typeof appConfigSchema>;

package/src/console/ConsoleConnector.ts

@@ -0,0 +1,40 @@
+import readline from "node:readline";
+import type { Logger } from "pino";
+import type { FeishuEventHandler, IncomingMessage } from "../feishu/types.js";
+
+export class ConsoleConnector {
+  private reader?: readline.Interface;
+
+  constructor(
+    private readonly handler: FeishuEventHandler,
+    private readonly logger: Logger,
+  ) {}
+
+  start(): void {
+    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> " });
+    this.reader = reader;
+    reader.prompt();
+    reader.on("line", (line) => {
+      const message: IncomingMessage = {
+        messageId: `console-${Date.now()}`,
+        contextKey: "console:local",
+        userId: "local",
+        text: line,
+      };
+      void this.handler.onMessage(message).catch((error) => {
+        this.logger.error({ error }, "Console message handling failed.");
+      }).finally(() => reader.prompt());
+    });
+    reader.on("close", () => {
+      if (this.reader === reader) this.reader = undefined;
+    });
+  }
+
+  stop(): void {
+    this.reader?.close();
+    this.reader = undefined;
+  }
+}

package/src/console/ConsoleTurnPresenter.ts

@@ -0,0 +1,64 @@
+import type { AgentEvent } from "../runtime/types.js";
+import type { FeishuOutbound } from "../feishu/types.js";
+import type { TurnPresenter } from "../presentation/OutboundRouter.js";
+
+export class ConsoleTurnPresenter implements TurnPresenter {
+  private readonly contexts = new Map<string, string>();
+  private readonly delivered = new Set<string>();
+
+  constructor(private readonly outbound: FeishuOutbound) {}
+
+  registerSession(sessionId: string, contextKey: string): void {
+    this.contexts.set(sessionId, contextKey);
+  }
+
+  updateSessionTitle(): void {}
+
+  unregisterSession(sessionId: string): void {
+    this.contexts.delete(sessionId);
+  }
+
+  async startPendingTurn(_sessionId: string, contextKey: string): Promise<void> {
+    await this.outbound.sendText(contextKey, "Connecting to Codex...");
+  }
+
+  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}`);
+  }
+
+  async appendSteerMessage(): Promise<void> {}
+
+  async onEvent(event: AgentEvent): Promise<void> {
+    const contextKey = this.contexts.get(event.sessionId);
+    if (!contextKey) return;
+    if (event.type === "turn_started") {
+      await this.outbound.sendText(contextKey, `Codex 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.`);
+    } 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}`);
+    } else if (event.type === "turn_cancelled") {
+      await this.outbound.sendText(contextKey, "Codex stopped.");
+    }
+  }
+
+  async showDetails(contextKey: string, turnId: string): Promise<void> {
+    await this.outbound.sendText(contextKey, `Turn details are available in Feishu (${turnId}).`);
+  }
+
+  async showActivityPage(contextKey: string, turnId: string): Promise<void> {
+    await this.outbound.sendText(contextKey, `Turn activity pages are available in Feishu (${turnId}).`);
+  }
+
+  async resumeDelivery(): Promise<void> {}
+
+  async flushAll(): Promise<void> {}
+}