@downcity/city 1.1.1 → 1.1.4

package/src/services/chat/ChatService.ts

@@ -1,111 +0,0 @@
-/**
- * ChatService：chat service 的类实现。
- *
- * 关键点（中文）
- * - chat 的渠道 bot 状态归属于 ChatService 实例。
- * - chat 的 queue worker 也归属于 ChatService 实例，而不是 agent 入口。
- * - Index 只保留静态导出入口，这里承接真正的 service class 实现。
- * - action 注册表已经拆到独立模块，当前文件只保留实例骨架。
- */
-
-import type { AgentRuntime } from "@/types/agent/AgentRuntime.js";
-import { BaseService } from "@services/BaseService.js";
-import type { ServiceActions } from "@/shared/types/Service.js";
-import type { AgentContext } from "@/types/agent/AgentContext.js";
-import type { ChatChannelState } from "@/shared/types/ChatRuntime.js";
-import {
-  createChatChannelState,
-  startChatChannels,
-  stopChatChannels,
-} from "./runtime/ChatChannelFacade.js";
-import { createChatServiceActions } from "./runtime/ChatServiceActions.js";
-import { ChatQueueWorker } from "./runtime/ChatQueueWorker.js";
-import { buildChatServiceSystem } from "./runtime/ChatServiceSystem.js";
-import { ChatQueueStore } from "./runtime/ChatQueueStore.js";
-
-/**
- * Chat service 类实现。
- */
-export class ChatService extends BaseService {
-  /**
-   * service 名称。
-   */
-  readonly name = "chat";
-
-  /**
-   * 当前实例持有的渠道状态。
-   */
-  public readonly channelState: ChatChannelState = createChatChannelState();
-
-  /**
-   * 当前实例持有的 chat queue worker。
-   *
-   * 关键点（中文）
-   * - worker 生命周期与 chat service 保持一致。
-   * - 这样 agent 只负责装配，不直接持有 chat 领域长期状态。
-   */
-  public queueWorker: ChatQueueWorker | null = null;
-
-  /**
-   * 当前实例持有的 chat queue store。
-   *
-   * 关键点（中文）
-   * - 这是 chat queue 状态的实例归属起点。
-   * - 迁移完成后，入队路径也会统一走这里，而不是模块级全局 queue。
-   */
-  public readonly queueStore = new ChatQueueStore();
-
-  /**
-   * 当前 service 的 system 文本构建器。
-   */
-  readonly system = async (context: AgentContext): Promise<string> => {
-    return await buildChatServiceSystem(context);
-  };
-
-  /**
-   * 当前 service 的 action 定义表。
-   */
-  readonly actions: ServiceActions;
-
-  /**
-   * 启动当前实例的 queue worker。
-   */
-  private startQueueWorker(context: AgentContext): void {
-    if (this.queueWorker) return;
-    const worker = new ChatQueueWorker({
-      logger: context.logger,
-      context,
-      queueStore: this.queueStore,
-      config: context.config.services?.chat?.queue,
-    });
-    worker.start();
-    this.queueWorker = worker;
-  }
-
-  /**
-   * 停止当前实例的 queue worker。
-   */
-  private stopQueueWorker(): void {
-    const worker = this.queueWorker;
-    this.queueWorker = null;
-    if (!worker) return;
-    worker.stop();
-  }
-
-  constructor(agent: AgentRuntime | null) {
-    super(agent);
-    this.actions = createChatServiceActions({
-      channelState: this.channelState,
-    });
-    this.lifecycle = {
-      start: async (context) => {
-        this.startQueueWorker(context);
-        await startChatChannels(this.channelState, context);
-      },
-      stop: async () => {
-        this.stopQueueWorker();
-        await stopChatChannels(this.channelState);
-      },
-    };
-  }
-}

package/src/services/chat/Index.ts

@@ -1,9 +0,0 @@
-/**
- * Chat Service 导出入口。
- *
- * 关键点（中文）
- * - Index 只负责导出类实现。
- * - 真正的类实现位于 `ChatService.ts`。
- */
-
-export { ChatService } from "./ChatService.js";

package/src/services/chat/PROMPT.direct.txt

@@ -1,55 +0,0 @@
-# Chat Service 使用说明
-
-## 用户可见回复规则
-
-- 当前模式下，直接输出，即会发送消息给到用户对应的channel
-
-## 输出协议
-
-- 需要普通回复时，直接输出文本即可。文本顶部可用 frontmatter metadata (optional)，字段语义与 `city chat send` 保持一致：
-
-- `delay` / `delayMs`：延迟发送毫秒数。
-- `time` / `sendAt` / `sendAtMs`：定时发送时间。
-- `reply`：是否使用 reply 语义发送。
-- `messageId`：目标 `message_id`（群聊推荐）。
-- `react`：发送表情反应。
-  - 单个字符串：`react: "👍"`
-  - 或对象/数组：`emoji/big`
-  - 设置 `messageId` 时，`react` 会优先复用该消息作为目标消息。
-- 附件使用 `<file type="...">path</file>`（支持 `document/photo/voice/audio/video`）。
-- 附件路径必须是项目内可访问的相对路径。多附件可输出多个 `<file>` 标签。
-
-### 示例
-
-```text
----
-reply: true
-messageId: "128"
-react:
-  - emoji: "✅"
----
-这是今天的报告。
-<file type="document">reports/daily.md</file>
-```
-
-### 协议约束
-
-- frontmatter 必须位于文本最开头（`---` 包裹）。
-- 除 `<file>` 附件标签外，不要使用尖括号格式做控制参数。
-
-## 跨协议/跨平台操作
-
-- 当任务需要跨会话、跨平台或复杂路由，必须使用 `city chat send` / `city chat react`。
-- metadata 只适用于当前会话内的 direct 出站，不要拿 metadata 做跨 chat 路由。
-- 如果需要跨 chat 发送，或者不清楚怎么发送，直接先调用 `city chat --help` 查看方法。
-- 如不确定参数或正文协议，先自行调用：
-  - `city chat --help`
-  - `city chat send --help`
-  - `city chat react --help`
-
-## 入站消息结构（仅供内部理解）
-
-- 每条入队用户消息包含 `<info>...</info>` 元信息块 + 用户正文。
-- `<info>` 仅保留 user/request 元信息，例如 `user_id`、`username`、`message_id`、`permissions`、`received_at`。
-- 当前 chat 路由环境（例如 `channel`、`session_id`、`chat_key`、`chat_id`）会通过 system prompt 单独注入，不再混在 `<info>` 里。
-- `<info>` 不要原样回传给用户。

package/src/services/chat/accounts/ChannelAccountService.ts

@@ -1,317 +0,0 @@
-/**
- * Chat channel account 管理服务。
- *
- * 关键点（中文）
- * - 统一封装 city 全局 chat channel account 的 CRUD 与探测。
- * - 业务语义归属 chat service；console/CLI 只复用这里的能力。
- * - 敏感字段仅在写入时接收明文；读取时只返回脱敏与布尔状态。
- */
-
-import crypto from "node:crypto";
-import { ConsoleStore } from "@/shared/utils/store/index.js";
-import type { StoredChannelAccountChannel } from "@/shared/types/Store.js";
-import { resolveChatChannelBotInfo } from "@services/chat/channels/BotInfoProvider.js";
-import type {
-  ChatChannelAccountCreateInput,
-  ChatChannelAccountListResult,
-  ChatChannelAccountProbeResult,
-  ChatChannelAccountUpsertInput,
-} from "@services/chat/types/ChannelAccount.js";
-
-const SUPPORTED_CHANNELS: readonly StoredChannelAccountChannel[] = [
-  "telegram",
-  "feishu",
-  "qq",
-];
-
-function maskSecret(value: string | undefined): string {
-  const raw = String(value || "").trim();
-  if (!raw) return "";
-  if (raw.length <= 8) return "***";
-  return `${raw.slice(0, 4)}***${raw.slice(-4)}`;
-}
-
-function assertChannel(input: string): StoredChannelAccountChannel {
-  const channel = String(input || "").trim().toLowerCase() as StoredChannelAccountChannel;
-  if (!SUPPORTED_CHANNELS.includes(channel)) {
-    throw new Error(
-      `Unsupported channel: ${input}. Supported: ${SUPPORTED_CHANNELS.join(", ")}`,
-    );
-  }
-  return channel;
-}
-
-function normalizeOptionalText(value: unknown): string | undefined {
-  const text = String(value || "").trim();
-  return text || undefined;
-}
-
-function normalizeChannelAccountIdToken(value: string): string {
-  const token = String(value || "")
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9_-]+/g, "-")
-    .replace(/-+/g, "-")
-    .replace(/^-+/, "")
-    .replace(/-+$/, "");
-  return token || "bot";
-}
-
-function pickFirstNonEmpty(inputs: unknown[]): string {
-  for (const input of inputs) {
-    const text = String(input || "").trim();
-    if (text) return text;
-  }
-  return "";
-}
-
-/**
- * ChatChannelAccountService。
- */
-export class ChatChannelAccountService {
-  /**
-   * 生成唯一 channel account id。
-   *
-   * 关键点（中文）
-   * - 账号 id 统一由系统生成，避免用户手填导致冲突/命名不一致。
-   * - 若碰撞会自动追加随机后缀重试。
-   */
-  private async generateUniqueAccountId(params: {
-    channel: StoredChannelAccountChannel;
-    seed?: string;
-  }): Promise<string> {
-    const seed = normalizeChannelAccountIdToken(params.seed || "");
-    const prefix = `${params.channel}-${seed}`.slice(0, 36);
-    const store = new ConsoleStore();
-    try {
-      for (let index = 0; index < 8; index += 1) {
-        const suffix = crypto.randomBytes(3).toString("hex");
-        const candidate = `${prefix}-${suffix}`.slice(0, 64);
-        const existing = await store.getChannelAccount(candidate);
-        if (!existing) return candidate;
-      }
-      return `${params.channel}-${Date.now().toString(36)}`;
-    } finally {
-      store.close();
-    }
-  }
-
-  /**
-   * 探测 bot 凭据并返回自动填充信息。
-   */
-  async probe(input: {
-    channel: string;
-    botToken?: string;
-    appId?: string;
-    appSecret?: string;
-    domain?: string;
-    sandbox?: boolean;
-  }): Promise<ChatChannelAccountProbeResult> {
-    const channel = assertChannel(input.channel);
-    const botInfo = await resolveChatChannelBotInfo({
-      channel,
-      credentials: {
-        botToken: normalizeOptionalText(input.botToken),
-        appId: normalizeOptionalText(input.appId),
-        appSecret: normalizeOptionalText(input.appSecret),
-        domain: normalizeOptionalText(input.domain),
-        sandbox: input.sandbox === true,
-      },
-    });
-    const accountId = await this.generateUniqueAccountId({
-      channel,
-      seed: pickFirstNonEmpty([
-        botInfo.idSeed,
-        botInfo.botUserId,
-        botInfo.identity,
-        botInfo.name,
-        "bot",
-      ]),
-    });
-
-    return {
-      channel,
-      accountId,
-      name: botInfo.name,
-      identity: botInfo.identity,
-      owner: botInfo.owner,
-      creator: botInfo.creator,
-      botUserId: botInfo.botUserId,
-      message: botInfo.message,
-    };
-  }
-
-  /**
-   * 使用凭据创建账号。
-   *
-   * 关键点（中文）
-   * - 默认会尝试探测平台 bot 信息，成功时自动生成更友好的名称与身份。
-   * - 探测失败时允许用户给定名称继续保存，方便先录入后排查。
-   */
-  async create(input: ChatChannelAccountCreateInput): Promise<{
-    id: string;
-    probed: boolean;
-    message?: string;
-  }> {
-    const channel = assertChannel(input.channel);
-    let probeResult: ChatChannelAccountProbeResult | null = null;
-    if (input.probe !== false) {
-      try {
-        probeResult = await this.probe({
-          channel,
-          botToken: input.botToken,
-          appId: input.appId,
-          appSecret: input.appSecret,
-          domain: input.domain,
-          sandbox: input.sandbox,
-        });
-      } catch (error) {
-        if (!normalizeOptionalText(input.name)) {
-          throw error;
-        }
-      }
-    }
-
-    const id =
-      probeResult?.accountId ||
-      (await this.generateUniqueAccountId({
-        channel,
-        seed: pickFirstNonEmpty([input.name, input.appId, "bot"]),
-      }));
-    const name = normalizeOptionalText(input.name) || probeResult?.name || `${channel} bot`;
-
-    await this.upsert({
-      id,
-      channel,
-      name,
-      identity: probeResult?.identity,
-      owner: probeResult?.owner,
-      creator: probeResult?.creator,
-      botToken: input.botToken,
-      appId: input.appId,
-      appSecret: input.appSecret,
-      domain: input.domain,
-      sandbox: input.sandbox,
-    });
-
-    return {
-      id,
-      probed: Boolean(probeResult),
-      message: probeResult?.message,
-    };
-  }
-
-  /**
-   * 列出账户池（脱敏）。
-   */
-  async list(): Promise<ChatChannelAccountListResult> {
-    const store = new ConsoleStore();
-    try {
-      const rows = await store.listChannelAccounts();
-      return {
-        items: rows.map((item) => ({
-          id: item.id,
-          channel: item.channel,
-          name: item.name,
-          identity: item.identity,
-          owner: item.owner,
-          creator: item.creator,
-          domain: item.domain,
-          sandbox: item.sandbox === true,
-          hasBotToken: !!String(item.botToken || "").trim(),
-          hasAppId: !!String(item.appId || "").trim(),
-          hasAppSecret: !!String(item.appSecret || "").trim(),
-          botTokenMasked: maskSecret(item.botToken),
-          appIdMasked: maskSecret(item.appId),
-          appSecretMasked: maskSecret(item.appSecret),
-          createdAt: item.createdAt,
-          updatedAt: item.updatedAt,
-        })),
-      };
-    } finally {
-      store.close();
-    }
-  }
-
-  /**
-   * 新增或更新账户。
-   */
-  async upsert(input: ChatChannelAccountUpsertInput): Promise<{ id: string }> {
-    const id = String(input.id || "").trim();
-    if (!id) throw new Error("channel account id cannot be empty");
-    const name = String(input.name || "").trim();
-    if (!name) throw new Error("channel account name cannot be empty");
-
-    const channel = assertChannel(input.channel);
-
-    if (input.botToken !== undefined && input.clearBotToken === true) {
-      throw new Error("botToken and clearBotToken cannot be used together");
-    }
-    if (input.appId !== undefined && input.clearAppId === true) {
-      throw new Error("appId and clearAppId cannot be used together");
-    }
-    if (input.appSecret !== undefined && input.clearAppSecret === true) {
-      throw new Error("appSecret and clearAppSecret cannot be used together");
-    }
-
-    const store = new ConsoleStore();
-    try {
-      const current = await store.getChannelAccount(id);
-      const nextBotToken = input.clearBotToken
-        ? undefined
-        : input.botToken !== undefined
-          ? normalizeOptionalText(input.botToken)
-          : current?.botToken;
-      const nextAppId = input.clearAppId
-        ? undefined
-        : input.appId !== undefined
-          ? normalizeOptionalText(input.appId)
-          : current?.appId;
-      const nextAppSecret = input.clearAppSecret
-        ? undefined
-        : input.appSecret !== undefined
-          ? normalizeOptionalText(input.appSecret)
-          : current?.appSecret;
-      const nextIdentity = Object.prototype.hasOwnProperty.call(input, "identity")
-        ? normalizeOptionalText(input.identity)
-        : current?.identity;
-      const nextOwner = Object.prototype.hasOwnProperty.call(input, "owner")
-        ? normalizeOptionalText(input.owner)
-        : current?.owner;
-      const nextCreator = Object.prototype.hasOwnProperty.call(input, "creator")
-        ? normalizeOptionalText(input.creator)
-        : current?.creator;
-
-      await store.upsertChannelAccount({
-        id,
-        channel,
-        name,
-        identity: nextIdentity,
-        owner: nextOwner,
-        creator: nextCreator,
-        botToken: nextBotToken,
-        appId: nextAppId,
-        appSecret: nextAppSecret,
-        domain: normalizeOptionalText(input.domain),
-        sandbox: input.sandbox === true,
-      });
-      return { id };
-    } finally {
-      store.close();
-    }
-  }
-
-  /**
-   * 删除账户。
-   */
-  remove(idInput: string): void {
-    const id = String(idInput || "").trim();
-    if (!id) throw new Error("channel account id cannot be empty");
-    const store = new ConsoleStore();
-    try {
-      store.removeChannelAccount(id);
-    } finally {
-      store.close();
-    }
-  }
-}