@keyou007/agent-bot 0.1.0

package/src/cli/Initializer.ts

@@ -0,0 +1,159 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse as parseDotEnv } from "dotenv";
+import {
+  agentBotHome,
+  defaultConfigPath,
+  defaultDotEnvPath,
+  resolveUserPath,
+} from "../config/paths.js";
+
+export type InitializationStatus = "created" | "existing";
+
+export interface InitializedPath {
+  path: string;
+  status: InitializationStatus;
+}
+
+export interface InitializationResult {
+  home: InitializedPath;
+  config: InitializedPath;
+  env: InitializedPath;
+  data: InitializedPath;
+  logs: InitializedPath;
+}
+
+export interface InitializationOptions {
+  env?: NodeJS.ProcessEnv;
+  configPath?: string;
+  configTemplatePath?: string;
+  envTemplatePath?: string;
+}
+
+export type FeishuCredentialStatus = "configured" | "missing" | "incomplete";
+
+export interface FeishuCredentialState {
+  status: FeishuCredentialStatus;
+  appId?: string;
+  appSecret?: string;
+}
+
+export interface FeishuCredentials {
+  appId: string;
+  appSecret: string;
+}
+
+const DEFAULT_CONFIG_TEMPLATE = fileURLToPath(new URL("../../config.example.yaml", import.meta.url));
+const DEFAULT_ENV_TEMPLATE = fileURLToPath(new URL("../../.env.example", import.meta.url));
+
+export function initializeAgentBot(options: InitializationOptions = {}): InitializationResult {
+  const env = options.env ?? process.env;
+  const configTemplatePath = path.resolve(options.configTemplatePath ?? DEFAULT_CONFIG_TEMPLATE);
+  const envTemplatePath = path.resolve(options.envTemplatePath ?? DEFAULT_ENV_TEMPLATE);
+  assertTemplate(configTemplatePath);
+  assertTemplate(envTemplatePath);
+
+  const homePath = agentBotHome(env);
+  const configuredPath = firstNonBlank(options.configPath, env.AGENT_BOT_CONFIG);
+  const configPath = resolveUserPath(configuredPath ?? defaultConfigPath(env));
+  const envPath = defaultDotEnvPath(env);
+  const configDirectory = path.dirname(configPath);
+
+  const home = ensureDirectory(homePath);
+  fs.mkdirSync(configDirectory, { recursive: true });
+
+  let config: InitializedPath;
+  if (fs.existsSync(configPath)) {
+    config = { path: configPath, status: "existing" };
+  } else {
+    fs.copyFileSync(configTemplatePath, configPath, fs.constants.COPYFILE_EXCL);
+    config = { path: configPath, status: "created" };
+  }
+
+  const envFile = copyIfMissing(envTemplatePath, envPath);
+  restrictFilePermissions(envFile.path);
+  const data = ensureDirectory(path.join(configDirectory, "data"));
+  const logs = ensureDirectory(path.join(configDirectory, "logs"));
+
+  return { home, config, env: envFile, data, logs };
+}
+
+export function readFeishuCredentials(envPath: string, env: NodeJS.ProcessEnv = process.env): FeishuCredentialState {
+  const fileValues = fs.existsSync(envPath) ? parseDotEnv(fs.readFileSync(envPath, "utf8")) : {};
+  const appId = firstNonBlank(env.FEISHU_APP_ID, fileValues.FEISHU_APP_ID);
+  const appSecret = firstNonBlank(env.FEISHU_APP_SECRET, fileValues.FEISHU_APP_SECRET);
+  if (appId && appSecret) return { status: "configured", appId, appSecret };
+  if (appId || appSecret) return { status: "incomplete", appId, appSecret };
+  return { status: "missing" };
+}
+
+export function writeFeishuCredentials(envPath: string, credentials: FeishuCredentials): void {
+  assertDotEnvValue("FEISHU_APP_ID", credentials.appId);
+  assertDotEnvValue("FEISHU_APP_SECRET", credentials.appSecret);
+  const original = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf8") : "";
+  let updated = upsertDotEnvValue(original, "FEISHU_APP_ID", credentials.appId);
+  updated = upsertDotEnvValue(updated, "FEISHU_APP_SECRET", credentials.appSecret);
+
+  fs.mkdirSync(path.dirname(envPath), { recursive: true });
+  const temporaryPath = `${envPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(temporaryPath, updated, { encoding: "utf8", mode: 0o600 });
+    fs.renameSync(temporaryPath, envPath);
+    restrictFilePermissions(envPath);
+  } finally {
+    fs.rmSync(temporaryPath, { force: true });
+  }
+}
+
+function assertTemplate(templatePath: string): void {
+  if (!fs.statSync(templatePath, { throwIfNoEntry: false })?.isFile()) {
+    throw new Error(`Initialization template does not exist: ${templatePath}`);
+  }
+}
+
+function ensureDirectory(directoryPath: string): InitializedPath {
+  const status = fs.existsSync(directoryPath) ? "existing" : "created";
+  fs.mkdirSync(directoryPath, { recursive: true });
+  return { path: directoryPath, status };
+}
+
+function copyIfMissing(sourcePath: string, targetPath: string): InitializedPath {
+  if (fs.existsSync(targetPath)) return { path: targetPath, status: "existing" };
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath, fs.constants.COPYFILE_EXCL);
+  return { path: targetPath, status: "created" };
+}
+
+function upsertDotEnvValue(contents: string, key: string, value: string): string {
+  const newline = contents.includes("\r\n") ? "\r\n" : "\n";
+  const lines = contents.length > 0 ? contents.split(/\r?\n/) : [];
+  const matcher = new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=`);
+  const index = lines.findIndex((line) => matcher.test(line));
+  if (index >= 0) {
+    lines[index] = `${key}=${value}`;
+  } else {
+    while (lines.length > 0 && lines.at(-1) === "") lines.pop();
+    lines.push(`${key}=${value}`);
+  }
+  while (lines.length > 0 && lines.at(-1) === "") lines.pop();
+  return `${lines.join(newline)}${newline}`;
+}
+
+function assertDotEnvValue(key: string, value: string): void {
+  if (!value.trim() || /[\r\n]/.test(value)) {
+    throw new Error(`${key} 不是有效的单行环境变量值。`);
+  }
+}
+
+function restrictFilePermissions(filePath: string): void {
+  try {
+    fs.chmodSync(filePath, 0o600);
+  } catch {
+    // Windows and some mounted filesystems do not implement POSIX modes.
+  }
+}
+
+function firstNonBlank(...values: Array<string | undefined>): string | undefined {
+  return values.find((value) => value !== undefined && value.trim().length > 0);
+}

package/src/cli/LocalControlClient.ts

@@ -0,0 +1,48 @@
+import net from "node:net";
+import type { ControlRequest, ControlResponse } from "./controlProtocol.js";
+
+export async function sendControlRequest(
+  endpoint: string,
+  request: ControlRequest,
+  timeoutMs = 5_000,
+): Promise<ControlResponse> {
+  return new Promise<ControlResponse>((resolve, reject) => {
+    const socket = net.createConnection(endpoint);
+    let settled = false;
+    let input = "";
+    const finish = (operation: () => void): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      operation();
+    };
+    const timer = setTimeout(() => finish(() => reject(new Error("连接 Agent Bot 控制端点超时。"))), timeoutMs);
+    socket.setEncoding("utf8");
+    socket.once("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+    socket.on("data", (chunk: string) => {
+      input += chunk;
+      const newline = input.indexOf("\n");
+      if (newline < 0) return;
+      try {
+        const response = JSON.parse(input.slice(0, newline)) as ControlResponse;
+        finish(() => resolve(response));
+      } catch (error) {
+        finish(() => reject(error));
+      }
+    });
+    socket.once("error", (error) => finish(() => reject(error)));
+    socket.once("end", () => {
+      if (!settled) finish(() => reject(new Error("Agent Bot 控制端点未返回结果。")));
+    });
+  });
+}
+
+export async function isServerRunning(endpoint: string): Promise<boolean> {
+  try {
+    const response = await sendControlRequest(endpoint, { action: "health" }, 1_000);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}

package/src/cli/LocalControlServer.ts

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import net from "node:net";
+import type { ControlRequest, ControlResponse } from "./controlProtocol.js";
+
+export type ControlRequestHandler = (request: ControlRequest) => Promise<ControlResponse>;
+
+export class LocalControlServer {
+  private server?: net.Server;
+
+  constructor(
+    private readonly endpoint: string,
+    private readonly handleRequest: ControlRequestHandler,
+  ) {}
+
+  async start(): Promise<void> {
+    if (this.server) return;
+    if (process.platform !== "win32") fs.rmSync(this.endpoint, { force: true });
+    const server = net.createServer((socket) => {
+      socket.setEncoding("utf8");
+      let input = "";
+      socket.on("data", (chunk: string) => {
+        input += chunk;
+        const newline = input.indexOf("\n");
+        if (newline < 0) return;
+        const line = input.slice(0, newline);
+        input = "";
+        void this.respond(socket, line);
+      });
+    });
+    await new Promise<void>((resolve, reject) => {
+      const onError = (error: Error) => reject(error);
+      server.once("error", onError);
+      server.listen(this.endpoint, () => {
+        server.off("error", onError);
+        resolve();
+      });
+    });
+    this.server = server;
+  }
+
+  async close(): Promise<void> {
+    const server = this.server;
+    this.server = undefined;
+    if (server) {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+    if (process.platform !== "win32") fs.rmSync(this.endpoint, { force: true });
+  }
+
+  private async respond(socket: net.Socket, line: string): Promise<void> {
+    let response: ControlResponse;
+    try {
+      response = await this.handleRequest(parseRequest(line));
+    } catch (error) {
+      response = { ok: false, message: error instanceof Error ? error.message : String(error) };
+    }
+    socket.end(`${JSON.stringify(response)}\n`);
+  }
+}
+
+function parseRequest(line: string): ControlRequest {
+  const value = JSON.parse(line) as unknown;
+  if (!value || typeof value !== "object" || !("action" in value) || typeof value.action !== "string") {
+    throw new Error("无效的本地控制请求。");
+  }
+  return value as ControlRequest;
+}

package/src/cli/SkillRegistry.ts

@@ -0,0 +1,151 @@
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const SKILL_NAME = "agent-bot";
+const MARKER_FILE = ".agent-bot-managed.json";
+
+interface RegistrationMarker {
+  schemaVersion: 1;
+  managedBy: "agent-bot";
+  installedAt: string;
+  sourceDigest: string;
+}
+
+export interface SkillRegistrationStatus {
+  sourcePath: string;
+  skillsRoot: string;
+  targetPath: string;
+  registered: boolean;
+  managed: boolean;
+  upToDate: boolean;
+  sourceDigest: string;
+  installedDigest?: string;
+}
+
+export function resolveSystemSkillsRoot(
+  env: NodeJS.ProcessEnv = process.env,
+  homeDirectory = os.homedir(),
+): string {
+  return path.resolve(env.AGENT_BOT_SKILLS_DIR ?? path.join(homeDirectory, ".agents", "skills"));
+}
+
+export class SkillRegistry {
+  readonly sourcePath: string;
+  readonly skillsRoot: string;
+  readonly targetPath: string;
+
+  constructor(sourcePath: string, skillsRoot = resolveSystemSkillsRoot()) {
+    this.sourcePath = path.resolve(sourcePath);
+    this.skillsRoot = path.resolve(skillsRoot);
+    this.targetPath = path.join(this.skillsRoot, SKILL_NAME);
+    this.assertSafeTarget();
+  }
+
+  status(): SkillRegistrationStatus {
+    this.assertValidSource();
+    const registered = fs.existsSync(path.join(this.targetPath, "SKILL.md"));
+    const managed = registered && this.readMarker()?.managedBy === "agent-bot";
+    const sourceDigest = digestDirectory(this.sourcePath);
+    const installedDigest = registered ? digestDirectory(this.targetPath) : undefined;
+    return {
+      sourcePath: this.sourcePath,
+      skillsRoot: this.skillsRoot,
+      targetPath: this.targetPath,
+      registered,
+      managed,
+      upToDate: managed && installedDigest === sourceDigest,
+      sourceDigest,
+      installedDigest,
+    };
+  }
+
+  install(): { updated: boolean; status: SkillRegistrationStatus } {
+    this.assertValidSource();
+    const existing = fs.existsSync(this.targetPath);
+    if (existing && this.readMarker()?.managedBy !== "agent-bot") {
+      throw new Error(`目标目录已存在且不由 Agent Bot 管理：${this.targetPath}`);
+    }
+
+    const before = existing ? this.status() : undefined;
+    if (before?.upToDate) return { updated: false, status: before };
+
+    fs.mkdirSync(this.skillsRoot, { recursive: true });
+    const temporaryPath = path.join(this.skillsRoot, `.${SKILL_NAME}.install-${process.pid}-${randomUUID()}`);
+    try {
+      fs.cpSync(this.sourcePath, temporaryPath, { recursive: true, errorOnExist: true });
+      const marker: RegistrationMarker = {
+        schemaVersion: 1,
+        managedBy: "agent-bot",
+        installedAt: new Date().toISOString(),
+        sourceDigest: digestDirectory(this.sourcePath),
+      };
+      fs.writeFileSync(path.join(temporaryPath, MARKER_FILE), `${JSON.stringify(marker, null, 2)}\n`, "utf8");
+      if (existing) this.removeManagedTarget();
+      fs.renameSync(temporaryPath, this.targetPath);
+    } finally {
+      if (fs.existsSync(temporaryPath)) fs.rmSync(temporaryPath, { recursive: true, force: true });
+    }
+    return { updated: true, status: this.status() };
+  }
+
+  uninstall(): boolean {
+    if (!fs.existsSync(this.targetPath)) return false;
+    if (this.readMarker()?.managedBy !== "agent-bot") {
+      throw new Error(`拒绝删除不由 Agent Bot 管理的目录：${this.targetPath}`);
+    }
+    this.removeManagedTarget();
+    return true;
+  }
+
+  private assertValidSource(): void {
+    if (!fs.existsSync(path.join(this.sourcePath, "SKILL.md"))) {
+      throw new Error(`找不到内置 Agent Bot Skill：${this.sourcePath}`);
+    }
+  }
+
+  private assertSafeTarget(): void {
+    if (path.dirname(this.targetPath) !== this.skillsRoot || path.basename(this.targetPath) !== SKILL_NAME) {
+      throw new Error(`不安全的 Skill 目标路径：${this.targetPath}`);
+    }
+  }
+
+  private readMarker(): RegistrationMarker | undefined {
+    try {
+      const marker = JSON.parse(fs.readFileSync(path.join(this.targetPath, MARKER_FILE), "utf8")) as Partial<RegistrationMarker>;
+      if (marker.schemaVersion !== 1 || marker.managedBy !== "agent-bot") return undefined;
+      return marker as RegistrationMarker;
+    } catch {
+      return undefined;
+    }
+  }
+
+  private removeManagedTarget(): void {
+    this.assertSafeTarget();
+    fs.rmSync(this.targetPath, { recursive: true, force: true });
+  }
+}
+
+function digestDirectory(directory: string): string {
+  const hash = createHash("sha256");
+  for (const file of listFiles(directory)) {
+    const relativePath = path.relative(directory, file).replaceAll(path.sep, "/");
+    if (relativePath === MARKER_FILE) continue;
+    hash.update(relativePath);
+    hash.update("\0");
+    hash.update(fs.readFileSync(file));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+function listFiles(directory: string): string[] {
+  const files: string[] = [];
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) files.push(...listFiles(entryPath));
+    else if (entry.isFile()) files.push(entryPath);
+  }
+  return files.sort((left, right) => left.localeCompare(right));
+}

package/src/cli/controlProtocol.ts

@@ -0,0 +1,34 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import type { TurnViewState } from "../presentation/turnViewTypes.js";
+import type { RemoteSessionSummary } from "../runtime/types.js";
+import type { SessionRecord } from "../state/StateStore.js";
+
+export type ControlRequest =
+  | { action: "health" }
+  | { action: "server_restart"; mode: "safe" | "immediate"; reason: string }
+  | { action: "server_stop" }
+  | { action: "task_status"; localSessionId: string }
+  | { action: "task_stop"; localSessionId: string }
+  | { action: "task_title"; localSessionId: string; title: string }
+  | { action: "task_prompt"; localSessionId: string; text: string };
+
+export interface ControlResponse {
+  ok: boolean;
+  message?: string;
+  data?: unknown;
+}
+
+export interface TaskStatusControlData {
+  session: SessionRecord;
+  snapshot?: TurnViewState;
+  remote?: RemoteSessionSummary;
+}
+
+export function controlEndpoint(sqlitePath: string): string {
+  const resolvedPath = path.resolve(sqlitePath);
+  const key = createHash("sha256").update(resolvedPath.toLowerCase()).digest("hex").slice(0, 16);
+  return process.platform === "win32"
+    ? `\\\\.\\pipe\\agent-bot-${key}`
+    : path.join(path.dirname(resolvedPath), `.agent-bot-${key}.sock`);
+}

package/src/cli/taskChatRoute.ts

@@ -0,0 +1,31 @@
+import { baseChatContextKey, isThreadContextKey } from "../feishu/contextKey.js";
+import type { SessionRecord } from "../state/StateStore.js";
+
+const CHAT_CONTEXT_PREFIX = "chat_id:";
+const THREAD_CONTEXT_MARKER = ":thread_id:";
+
+export interface TaskChatRoute {
+  taskId: string;
+  chatId: string;
+  contextKey: string;
+  threadId?: string;
+}
+
+export function taskChatRoute(session: SessionRecord): TaskChatRoute {
+  const contextKey = session.contextKey;
+  const baseContextKey = baseChatContextKey(contextKey);
+  if (!baseContextKey.startsWith(CHAT_CONTEXT_PREFIX)) {
+    throw new Error(`任务没有绑定飞书会话：${session.remoteSessionId ?? session.acpSessionId ?? session.localSessionId}`);
+  }
+  const chatId = baseContextKey.slice(CHAT_CONTEXT_PREFIX.length);
+  if (!chatId) throw new Error(`任务的飞书会话 ID 无效：${contextKey}`);
+  const threadId = isThreadContextKey(contextKey)
+    ? contextKey.slice(contextKey.indexOf(THREAD_CONTEXT_MARKER) + THREAD_CONTEXT_MARKER.length)
+    : undefined;
+  return {
+    taskId: session.remoteSessionId ?? session.acpSessionId ?? session.localSessionId,
+    chatId,
+    contextKey,
+    ...(threadId ? { threadId } : {}),
+  };
+}