@downcity/city 1.1.1

package/src/cli/ChatAuth.ts

@@ -0,0 +1,186 @@
+/**
+ * `city chat auth` CLI 辅助模块。
+ *
+ * 关键点（中文）
+ * - chat authorization 属于 city 全局 chat service 策略。
+ * - 授权主体使用 `<platform>:<platformUserId>`，例如 `telegram:12345678`。
+ * - 管理员执行 `city chat auth set telegram:12345678` 后交互式选择 role。
+ */
+
+import prompts from "prompts";
+import type { Command } from "commander";
+import { emitCliBlock } from "./CliReporter.js";
+import { parseBoolean } from "./IndexSupport.js";
+import {
+  listChatAuthorizationRoles,
+  readChatAuthorizationConfigSync,
+  setChatAuthorizationUserRole,
+} from "@/plugins/auth/runtime/AuthorizationConfig.js";
+import { resolveAuthorizedUserRole } from "@/plugins/auth/runtime/AuthorizationPolicy.js";
+import {
+  isChatAuthorizationChannel,
+  type ChatAuthorizationChannel,
+  type ChatAuthorizationRole,
+} from "@/shared/types/AuthPlugin.js";
+
+type ChatAuthSetOptions = {
+  /**
+   * 非交互式直接指定 roleId。
+   */
+  role?: string;
+  /**
+   * 是否以 JSON 输出。
+   */
+  json?: boolean;
+};
+
+type ParsedPrincipal = {
+  /**
+   * 授权主体所在平台。
+   */
+  channel: ChatAuthorizationChannel;
+  /**
+   * 平台用户 ID。
+   */
+  userId: string;
+};
+
+function parsePrincipal(principalInput: string): ParsedPrincipal {
+  const principal = String(principalInput || "").trim();
+  const separator = principal.indexOf(":");
+  if (separator <= 0 || separator === principal.length - 1) {
+    throw new Error("principal 格式应为 <platform>:<userId>，例如 telegram:12345678");
+  }
+  const channel = principal.slice(0, separator).trim().toLowerCase();
+  const userId = principal.slice(separator + 1).trim();
+  if (!isChatAuthorizationChannel(channel)) {
+    throw new Error("platform 仅支持 telegram、feishu、qq");
+  }
+  if (!userId) {
+    throw new Error("userId 不能为空");
+  }
+  return { channel, userId };
+}
+
+function findRole(roles: ChatAuthorizationRole[], roleId: string): ChatAuthorizationRole | null {
+  return roles.find((role) => role.roleId === roleId) || null;
+}
+
+async function chooseRole(params: {
+  roles: ChatAuthorizationRole[];
+  currentRoleId?: string;
+}): Promise<ChatAuthorizationRole | null> {
+  const initial = Math.max(
+    0,
+    params.roles.findIndex((role) => role.roleId === params.currentRoleId),
+  );
+  const response = (await prompts({
+    type: "select",
+    name: "roleId",
+    message: "选择新的 auth role",
+    choices: params.roles.map((role) => ({
+      title: role.roleId,
+      description: `${role.name} · ${role.permissions.length} permissions`,
+      value: role.roleId,
+    })),
+    initial,
+  })) as { roleId?: string };
+  const roleId = String(response.roleId || "").trim();
+  if (!roleId) return null;
+  return findRole(params.roles, roleId);
+}
+
+/**
+ * 设置授权主体角色。
+ */
+export async function runChatAuthSet(params: {
+  principal: string;
+  options?: ChatAuthSetOptions;
+}): Promise<void> {
+  const principal = parsePrincipal(params.principal);
+  const config = readChatAuthorizationConfigSync();
+  const roles = listChatAuthorizationRoles({ config });
+  const currentRole = resolveAuthorizedUserRole({
+    channel: principal.channel,
+    userId: principal.userId,
+    authorizationConfig: config,
+  });
+
+  let nextRole: ChatAuthorizationRole | null = null;
+  const explicitRoleId = String(params.options?.role || "").trim();
+  if (explicitRoleId) {
+    nextRole = findRole(roles, explicitRoleId);
+    if (!nextRole) throw new Error(`Unknown role: ${explicitRoleId}`);
+  } else {
+    emitCliBlock({
+      tone: "info",
+      title: "Chat auth principal",
+      facts: [
+        { label: "Principal", value: `${principal.channel}:${principal.userId}` },
+        { label: "Current role", value: currentRole?.roleId || "default" },
+        { label: "Scope", value: "city" },
+      ],
+    });
+    nextRole = await chooseRole({
+      roles,
+      currentRoleId: currentRole?.roleId,
+    });
+  }
+
+  if (!nextRole) return;
+
+  await setChatAuthorizationUserRole({
+    channel: principal.channel,
+    userId: principal.userId,
+    roleId: nextRole.roleId,
+  });
+
+  emitCliBlock({
+    tone: "success",
+    title: "Chat auth role updated",
+    summary: `${principal.channel}:${principal.userId} -> ${nextRole.roleId}`,
+    facts: [
+      { label: "Role", value: nextRole.name },
+      { label: "Scope", value: "city" },
+    ],
+  });
+}
+
+/**
+ * 交互式输入授权主体并设置角色。
+ */
+export async function runInteractiveChatAuthSetFlow(options?: ChatAuthSetOptions): Promise<void> {
+  const response = (await prompts({
+    type: "text",
+    name: "principal",
+    message: "输入授权主体（例如 telegram:12345678）",
+  })) as { principal?: string };
+  const principal = String(response.principal || "").trim();
+  if (!principal) return;
+  await runChatAuthSet({
+    principal,
+    options,
+  });
+}
+
+/**
+ * 注册 `city chat auth` 命令。
+ */
+export function registerChatAuthCommands(chat: Command): void {
+  const auth = chat
+    .command("auth")
+    .description("管理 city 全局 chat authorization")
+    .helpOption("--help", "display help for command");
+
+  auth
+    .command("set <principal>")
+    .description("给授权主体设置角色，例如：city chat auth set telegram:12345678")
+    .option("--role <roleId>", "直接指定 roleId；不传则交互式选择")
+    .option("--json [enabled]", "以 JSON 输出", parseBoolean, false)
+    .action(async (principal: string, options: ChatAuthSetOptions) => {
+      await runChatAuthSet({
+        principal,
+        options,
+      });
+    });
+}

package/src/cli/ChatManager.ts

@@ -0,0 +1,439 @@
+/**
+ * `city chat` 交互式管理器。
+ *
+ * 关键点（中文）
+ * - 裸 `city chat` 进入 chat service 管理，而不是只输出静态 help。
+ * - chat channel account 属于 city 级配置，在这里通过“配置 channel”管理。
+ * - agent 只绑定 channel account，不在 agent 流程中维护密钥。
+ */
+
+import prompts from "prompts";
+import type { PromptObject } from "prompts";
+import { emitCliBlock, emitCliList } from "./CliReporter.js";
+import { runServiceControlCommand } from "./ServiceCommandRemote.js";
+import { ChatChannelAccountService } from "@services/chat/accounts/ChannelAccountService.js";
+import type { ChatChannelAccountListItem } from "@services/chat/types/ChannelAccount.js";
+import type { StoredChannelAccountChannel } from "@/shared/types/Store.js";
+import type {
+  ChatChannelAccountAction,
+  ChatManagerRootAction,
+} from "@/types/cli/ChatManager.js";
+import { runInteractiveChatAuthSetFlow } from "./ChatAuth.js";
+
+const CHAT_CHANNELS: StoredChannelAccountChannel[] = ["telegram", "feishu", "qq"];
+
+function isInteractiveTerminal(): boolean {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+
+function formatAccountTitle(account: ChatChannelAccountListItem): string {
+  const identity = account.identity ? ` · ${account.identity}` : "";
+  return `${account.channel} · ${account.name}${identity}`;
+}
+
+function formatCredentialSummary(account: ChatChannelAccountListItem): string {
+  const parts: string[] = [];
+  if (account.botTokenMasked) parts.push(`botToken ${account.botTokenMasked}`);
+  if (account.appIdMasked) parts.push(`appId ${account.appIdMasked}`);
+  if (account.appSecretMasked) parts.push(`appSecret ${account.appSecretMasked}`);
+  if (account.domain) parts.push(`domain ${account.domain}`);
+  if (account.sandbox) parts.push("sandbox");
+  return parts.join(" · ") || "no credentials";
+}
+
+async function promptRootAction(): Promise<ChatManagerRootAction | null> {
+  const service = new ChatChannelAccountService();
+  const accounts = await service.list();
+  const response = (await prompts({
+    type: "select",
+    name: "action",
+    message: "管理 chat service",
+    choices: [
+      {
+        title: "查看状态",
+        description: "查看当前项目 chat service 运行状态",
+        value: "status",
+      },
+      {
+        title: "启动",
+        description: "启动当前项目 chat service",
+        value: "start",
+      },
+      {
+        title: "停止",
+        description: "停止当前项目 chat service",
+        value: "stop",
+      },
+      {
+        title: "重启",
+        description: "重启当前项目 chat service",
+        value: "restart",
+      },
+      {
+        title: "配置 channel",
+        description: `${accounts.items.length} 个 city 级 channel account`,
+        value: "configureChannels",
+      },
+      {
+        title: "退出",
+        description: "关闭 chat manager",
+        value: "exit",
+      },
+    ],
+    initial: 0,
+  })) as { action?: ChatManagerRootAction };
+
+  return response.action || null;
+}
+
+async function promptChannelAccountAction(): Promise<ChatChannelAccountAction | null> {
+  const service = new ChatChannelAccountService();
+  const accounts = await service.list();
+  const response = (await prompts({
+    type: "select",
+    name: "action",
+    message: "配置 chat channel accounts",
+    choices: [
+      {
+        title: "查看 accounts",
+        description: `${accounts.items.length} 个已配置账号`,
+        value: "list",
+      },
+      {
+        title: "新增 account",
+        description: "配置 Telegram、Feishu 或 QQ 账号",
+        value: "add",
+      },
+      {
+        title: "编辑 account",
+        description: "修改名称、域名或密钥",
+        value: "edit",
+      },
+      {
+        title: "删除 account",
+        description: "从 city 全局账号池删除",
+        value: "remove",
+      },
+      {
+        title: "配置 authorization",
+        description: "给平台用户分配 auth role",
+        value: "configureAuthorization",
+      },
+      {
+        title: "返回",
+        description: "回到 chat service 菜单",
+        value: "back",
+      },
+    ],
+    initial: 0,
+  })) as { action?: ChatChannelAccountAction };
+
+  return response.action || null;
+}
+
+async function emitChannelAccountList(): Promise<void> {
+  const service = new ChatChannelAccountService();
+  const { items } = await service.list();
+  if (items.length === 0) {
+    emitCliBlock({
+      tone: "info",
+      title: "Chat channel accounts",
+      summary: "0 configured",
+      note: "在 `city chat` 中选择“配置 channel”后新增 Telegram、Feishu 或 QQ account。",
+    });
+    return;
+  }
+
+  emitCliList({
+    tone: "accent",
+    title: "Chat channel accounts",
+    summary: `${items.length} configured`,
+    items: items.map((account) => ({
+      title: formatAccountTitle(account),
+      facts: [
+        { label: "ID", value: account.id },
+        { label: "Credentials", value: formatCredentialSummary(account) },
+        { label: "Updated", value: account.updatedAt },
+      ],
+    })),
+  });
+}
+
+async function chooseChannel(): Promise<StoredChannelAccountChannel | null> {
+  const response = (await prompts({
+    type: "select",
+    name: "channel",
+    message: "选择 channel",
+    choices: CHAT_CHANNELS.map((channel) => ({
+      title: channel,
+      value: channel,
+    })),
+    initial: 0,
+  })) as { channel?: StoredChannelAccountChannel };
+
+  return response.channel || null;
+}
+
+async function chooseAccount(): Promise<ChatChannelAccountListItem | null> {
+  const service = new ChatChannelAccountService();
+  const { items } = await service.list();
+  if (items.length === 0) {
+    emitCliBlock({
+      tone: "info",
+      title: "No city channel accounts found",
+      note: "先新增一个 Telegram、Feishu 或 QQ account。",
+    });
+    return null;
+  }
+
+  const response = (await prompts({
+    type: "select",
+    name: "id",
+    message: "选择 account",
+    choices: items.map((account) => ({
+      title: formatAccountTitle(account),
+      description: `${account.id} · ${formatCredentialSummary(account)}`,
+      value: account.id,
+    })),
+    initial: 0,
+  })) as { id?: string };
+
+  const id = String(response.id || "").trim();
+  return items.find((item) => item.id === id) || null;
+}
+
+async function promptCredentialFields(params: {
+  channel: StoredChannelAccountChannel;
+  current?: ChatChannelAccountListItem;
+}): Promise<{
+  name?: string;
+  botToken?: string;
+  appId?: string;
+  appSecret?: string;
+  domain?: string;
+  sandbox?: boolean;
+}> {
+  const questions: PromptObject[] = [
+    {
+      type: "text",
+      name: "name",
+      message: "账号名称",
+      initial: params.current?.name || "",
+    },
+  ];
+
+  if (params.channel === "telegram") {
+    questions.push({
+      type: "password",
+      name: "botToken",
+      message: params.current ? "Bot Token（留空保持不变）" : "Bot Token",
+    });
+  }
+
+  if (params.channel === "feishu" || params.channel === "qq") {
+    questions.push(
+      {
+        type: "text",
+        name: "appId",
+        message: params.current ? "App ID（留空保持不变）" : "App ID",
+      },
+      {
+        type: "password",
+        name: "appSecret",
+        message: params.current ? "App Secret（留空保持不变）" : "App Secret",
+      },
+    );
+  }
+
+  if (params.channel === "feishu") {
+    questions.push({
+      type: "text",
+      name: "domain",
+      message: "Domain（可选，例如 open.feishu.cn）",
+      initial: params.current?.domain || "",
+    });
+  }
+
+  if (params.channel === "qq") {
+    questions.push({
+      type: "confirm",
+      name: "sandbox",
+      message: "启用 QQ sandbox？",
+      initial: params.current?.sandbox === true,
+    });
+  }
+
+  const response = (await prompts(questions)) as {
+    name?: string;
+    botToken?: string;
+    appId?: string;
+    appSecret?: string;
+    domain?: string;
+    sandbox?: boolean;
+  };
+
+  return response;
+}
+
+async function addChannelAccount(): Promise<void> {
+  const channel = await chooseChannel();
+  if (!channel) return;
+
+  const input = await promptCredentialFields({ channel });
+  const name = String(input.name || "").trim();
+
+  const probeResponse = (await prompts({
+    type: "confirm",
+    name: "probe",
+    message: "保存前探测 bot 信息？",
+    initial: true,
+  })) as { probe?: boolean };
+
+  const service = new ChatChannelAccountService();
+  const result = await service.create({
+    channel,
+    name,
+    botToken: input.botToken,
+    appId: input.appId,
+    appSecret: input.appSecret,
+    domain: input.domain,
+    sandbox: input.sandbox,
+    probe: probeResponse.probe !== false,
+  });
+
+  emitCliBlock({
+    tone: "success",
+    title: "Channel account saved",
+    summary: result.id,
+    note: result.message || (result.probed ? "bot 信息已探测" : "已按输入信息保存"),
+  });
+}
+
+async function editChannelAccount(): Promise<void> {
+  const account = await chooseAccount();
+  if (!account) return;
+
+  const input = await promptCredentialFields({
+    channel: account.channel,
+    current: account,
+  });
+  const service = new ChatChannelAccountService();
+  await service.upsert({
+    id: account.id,
+    channel: account.channel,
+    name: String(input.name || account.name).trim(),
+    botToken: String(input.botToken || "").trim() || undefined,
+    appId: String(input.appId || "").trim() || undefined,
+    appSecret: String(input.appSecret || "").trim() || undefined,
+    domain: input.domain,
+    sandbox: input.sandbox,
+  });
+
+  emitCliBlock({
+    tone: "success",
+    title: "Channel account updated",
+    summary: account.id,
+  });
+}
+
+async function removeChannelAccount(): Promise<void> {
+  const account = await chooseAccount();
+  if (!account) return;
+
+  const response = (await prompts({
+    type: "confirm",
+    name: "remove",
+    message: `删除 ${account.channel} · ${account.name}？`,
+    initial: false,
+  })) as { remove?: boolean };
+
+  if (response.remove !== true) return;
+
+  const service = new ChatChannelAccountService();
+  service.remove(account.id);
+  emitCliBlock({
+    tone: "success",
+    title: "Channel account removed",
+    summary: account.id,
+  });
+}
+
+async function runChannelAccountManager(): Promise<void> {
+  while (true) {
+    const action = await promptChannelAccountAction();
+    if (!action || action === "back") return;
+
+    try {
+      if (action === "list") {
+        await emitChannelAccountList();
+        continue;
+      }
+      if (action === "add") {
+        await addChannelAccount();
+        continue;
+      }
+      if (action === "edit") {
+        await editChannelAccount();
+        continue;
+      }
+      if (action === "remove") {
+        await removeChannelAccount();
+        continue;
+      }
+      if (action === "configureAuthorization") {
+        await runInteractiveChatAuthSetFlow();
+      }
+    } catch (error) {
+      emitCliBlock({
+        tone: "error",
+        title: "Channel account action failed",
+        note: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+}
+
+async function runChatLifecycleAction(
+  action: "start" | "stop" | "restart" | "status",
+): Promise<void> {
+  await runServiceControlCommand({
+    serviceName: "chat",
+    action,
+    options: {
+      path: ".",
+      json: false,
+    },
+  });
+}
+
+/**
+ * 运行 `city chat` 交互式管理器。
+ */
+export async function runInteractiveChatManager(): Promise<void> {
+  if (!isInteractiveTerminal()) return;
+
+  while (true) {
+    const action = await promptRootAction();
+    if (!action || action === "exit") {
+      emitCliBlock({
+        tone: "info",
+        title: "Chat manager closed",
+      });
+      return;
+    }
+
+    try {
+      if (action === "configureChannels") {
+        await runChannelAccountManager();
+        continue;
+      }
+      await runChatLifecycleAction(action);
+    } catch (error) {
+      emitCliBlock({
+        tone: "error",
+        title: "Chat manager action failed",
+        note: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+}