@downcity/city 1.1.24 → 1.1.32

package/src/model/service/ModelPoolService.ts

@@ -0,0 +1,525 @@
+/**
+ * Console 模型池服务。
+ *
+ * 关键点（中文）
+ * - 统一封装 provider/model 的增删改查与测试逻辑，供 CLI 与 Console API 共同复用。
+ * - 删除保护、引用检查、输入校验都在这里收敛，避免多处实现漂移。
+ * - Provider 的密钥仅返回脱敏视图，避免在 UI 或 CLI 输出中泄露明文。
+ */
+
+import fs from "fs-extra";
+import { generateText } from "ai";
+import type {
+  LlmProviderType,
+  StoredModel,
+  StoredModelProvider,
+} from "@downcity/agent";
+import { getDowncityJsonPath } from "@/config/Paths.js";
+import { PlatformStore } from "@/platform/store/index.js";
+import { listManagedAgentEntries } from "@/process/registry/CityRegistry.js";
+import { discoverProviderModels } from "@/cli/model/ModelSupport.js";
+import { createRuntimeModel } from "@/model/runtime/CreateRuntimeModel.js";
+
+const SUPPORTED_PROVIDER_TYPES: readonly LlmProviderType[] = [
+  "anthropic",
+  "openai",
+  "deepseek",
+  "gemini",
+  "open-compatible",
+  "open-responses",
+  "moonshot-cn",
+  "moonshot-ai",
+  "kimi-code",
+  "xai",
+  "huggingface",
+  "openrouter",
+];
+
+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 assertProviderType(inputType: string): LlmProviderType {
+  const candidate = String(inputType || "").trim() as LlmProviderType;
+  if (!SUPPORTED_PROVIDER_TYPES.includes(candidate)) {
+    throw new Error(
+      `Unsupported provider type: ${inputType}. Supported: ${SUPPORTED_PROVIDER_TYPES.join(", ")}`,
+    );
+  }
+  return candidate;
+}
+
+function parseOptionalNumber(input: unknown): number | undefined {
+  if (input === undefined || input === null || input === "") return undefined;
+  const num = Number(input);
+  if (!Number.isFinite(num) || Number.isNaN(num)) {
+    throw new Error(`Invalid number: ${String(input)}`);
+  }
+  return num;
+}
+
+function parseOptionalPositiveInteger(input: unknown): number | undefined {
+  if (input === undefined || input === null || input === "") return undefined;
+  const num = Number.parseInt(String(input), 10);
+  if (!Number.isFinite(num) || Number.isNaN(num) || !Number.isInteger(num) || num <= 0) {
+    throw new Error(`Invalid positive integer: ${String(input)}`);
+  }
+  return num;
+}
+
+function formatModelIds(modelIds: string[]): string {
+  return modelIds.map((modelId) => `"${modelId}"`).join(", ");
+}
+
+function formatAgentReference(reference: {
+  projectRoot: string;
+  shipJsonPath: string;
+  agentName?: string;
+}): string {
+  const agentName = String(reference.agentName || "").trim();
+  if (agentName) {
+    return `${agentName} (${reference.projectRoot})`;
+  }
+  return reference.projectRoot;
+}
+
+async function listModelReferences(modelId: string): Promise<Array<{
+  projectRoot: string;
+  shipJsonPath: string;
+  agentName?: string;
+}>> {
+  const references: Array<{
+    projectRoot: string;
+    shipJsonPath: string;
+    agentName?: string;
+  }> = [];
+  const entries = await listManagedAgentEntries();
+  for (const entry of entries) {
+    const projectRoot = String(entry.projectRoot || "").trim();
+    if (!projectRoot) continue;
+    const shipJsonPath = getDowncityJsonPath(projectRoot);
+    if (!(await fs.pathExists(shipJsonPath))) continue;
+    try {
+      const raw = (await fs.readJson(shipJsonPath)) as {
+        name?: unknown;
+        execution?: {
+          type?: unknown;
+          modelId?: unknown;
+        };
+      };
+      const executionType = String(raw?.execution?.type || "").trim();
+      const candidateModelId = String(raw?.execution?.modelId || "").trim();
+      if (executionType !== "api" || candidateModelId !== modelId) continue;
+      const agentName = String(raw?.name || "").trim() || undefined;
+      references.push({
+        projectRoot,
+        shipJsonPath,
+        agentName,
+      });
+    } catch {
+      continue;
+    }
+  }
+  return references.sort((a, b) => a.projectRoot.localeCompare(b.projectRoot));
+}
+
+/**
+ * ModelPoolService：提供 CLI / UI 共用的模型池管理能力。
+ */
+export class ModelPoolService {
+  /**
+   * 读取模型池快照。
+   */
+  async listPool(): Promise<{
+    providers: Array<{
+      id: string;
+      type: string;
+      baseUrl?: string;
+      hasApiKey: boolean;
+      apiKeyMasked?: string;
+      createdAt: string;
+      updatedAt: string;
+    }>;
+    models: Array<{
+      id: string;
+      providerId: string;
+      name: string;
+      temperature?: number;
+      maxTokens?: number;
+      topP?: number;
+      frequencyPenalty?: number;
+      presencePenalty?: number;
+      anthropicVersion?: string;
+      isPaused: boolean;
+      createdAt: string;
+      updatedAt: string;
+    }>;
+    providerIds: string[];
+    modelIds: string[];
+  }> {
+    const store = new PlatformStore();
+    try {
+      const providersRaw = await store.listProviders();
+      const models = store.listModels();
+      const providers = providersRaw.map((item) => ({
+        id: item.id,
+        type: item.type,
+        baseUrl: item.baseUrl,
+        hasApiKey: String(item.apiKey || "").trim().length > 0,
+        apiKeyMasked: maskSecret(item.apiKey),
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+      }));
+      return {
+        providers,
+        models,
+        providerIds: providers.map((x) => x.id),
+        modelIds: models.map((x) => x.id),
+      };
+    } finally {
+      store.close();
+    }
+  }
+
+  /**
+   * 读取单个 provider 以及它绑定的模型。
+   */
+  async getProviderUsage(providerId: string): Promise<{
+    provider: StoredModelProvider;
+    models: StoredModel[];
+  }> {
+    const id = String(providerId || "").trim();
+    if (!id) throw new Error("providerId cannot be empty");
+    const store = new PlatformStore();
+    try {
+      const provider = await store.getProvider(id);
+      if (!provider) throw new Error(`Provider not found: ${id}`);
+      const models = store
+        .listModels()
+        .filter((model) => model.providerId === id)
+        .sort((a, b) => a.id.localeCompare(b.id));
+      return {
+        provider,
+        models,
+      };
+    } finally {
+      store.close();
+    }
+  }
+
+  /**
+   * 读取单个 model 以及它被哪些 agent 项目引用。
+   */
+  async getModelUsage(modelId: string): Promise<{
+    model: StoredModel;
+    references: Array<{
+      projectRoot: string;
+      shipJsonPath: string;
+      agentName?: string;
+    }>;
+  }> {
+    const id = String(modelId || "").trim();
+    if (!id) throw new Error("modelId cannot be empty");
+    const store = new PlatformStore();
+    try {
+      const model = store.getModel(id);
+      if (!model) throw new Error(`Model not found: ${id}`);
+      const references = await listModelReferences(id);
+      return {
+        model,
+        references,
+      };
+    } finally {
+      store.close();
+    }
+  }
+
+  /**
+   * 新增或更新 provider。
+   */
+  async upsertProvider(input: {
+    id: string;
+    type: string;
+    baseUrl?: string;
+    apiKey?: string;
+    clearBaseUrl?: boolean;
+    clearApiKey?: boolean;
+  }): Promise<{
+    providerId: string;
+    provider: {
+      id: string;
+      type: string;
+      baseUrl?: string;
+      hasApiKey: boolean;
+      apiKeyMasked?: string;
+    };
+  }> {
+    const id = String(input.id || "").trim();
+    if (!id) throw new Error("providerId cannot be empty");
+    const type = assertProviderType(input.type);
+    if (input.baseUrl !== undefined && input.clearBaseUrl === true) {
+      throw new Error("baseUrl and clearBaseUrl cannot be used together");
+    }
+    if (input.apiKey !== undefined && input.clearApiKey === true) {
+      throw new Error("apiKey and clearApiKey cannot be used together");
+    }
+
+    const store = new PlatformStore();
+    try {
+      const current = await store.getProvider(id);
+      const nextBaseUrl = input.clearBaseUrl === true
+        ? undefined
+        : input.baseUrl !== undefined
+          ? String(input.baseUrl || "").trim() || undefined
+          : current?.baseUrl;
+      const nextApiKey = input.clearApiKey === true
+        ? undefined
+        : input.apiKey !== undefined
+          ? String(input.apiKey || "")
+          : current?.apiKey;
+
+      await store.upsertProvider({
+        id,
+        type,
+        baseUrl: nextBaseUrl,
+        apiKey: nextApiKey,
+      });
+
+      const saved = await store.getProvider(id);
+      return {
+        providerId: id,
+        provider: {
+          id,
+          type,
+          baseUrl: saved?.baseUrl,
+          hasApiKey: String(saved?.apiKey || "").trim().length > 0,
+          apiKeyMasked: maskSecret(saved?.apiKey),
+        },
+      };
+    } finally {
+      store.close();
+    }
+  }
+
+  /**
+   * 删除 provider。
+   */
+  async removeProvider(providerId: string): Promise<void> {
+    const usage = await this.getProviderUsage(providerId);
+    if (usage.models.length > 0) {
+      throw new Error(
+        `Provider "${usage.provider.id}" is still referenced by models: ${formatModelIds(usage.models.map((model) => model.id))}. Remove or rebind those models first.`,
+      );
+    }
+    const store = new PlatformStore();
+    try {
+      store.removeProvider(usage.provider.id);
+    } finally {
+      store.close();
+    }
+  }
+
+  /**
+   * 测试 provider 并返回发现结果。
+   */
+  async testProvider(providerId: string): Promise<{
+    providerId: string;
+    discoveredModels: string[];
+    modelCount: number;
+    status?: number;
+  }> {
+    const id = String(providerId || "").trim();
+    if (!id) throw new Error("providerId cannot be empty");
+    const store = new PlatformStore();
+    try {
+      const provider = await store.getProvider(id);
+      if (!provider) throw new Error(`Provider not found: ${id}`);
+      const discovery = await discoverProviderModels({
+        providerId: id,
+        providerType: provider.type,
+        baseUrl: provider.baseUrl,
+        apiKey: provider.apiKey,
+      });
+      if (!discovery.ok) {
+        throw new Error(discovery.error || `provider test failed (${discovery.status || "n/a"})`);
+      }
+      return {
+        providerId: id,
+        discoveredModels: discovery.models,
+        modelCount: discovery.models.length,
+        status: discovery.status,
+      };
+    } finally {
+      store.close();
+    }
+  }
+
+  /**
+   * 发现 provider 模型并可选自动写入模型池。
+   */
+  async discoverProvider(params: {
+    providerId: string;
+    autoAdd?: boolean;
+    prefix?: string;
+  }): Promise<{
+    providerId: string;
+    discoveredModels: string[];
+    modelCount: number;
+    autoAdded: Array<{ modelId: string; modelName: string }>;
+  }> {
+    const providerId = String(params.providerId || "").trim();
+    if (!providerId) throw new Error("providerId cannot be empty");
+    const store = new PlatformStore();
+    try {
+      const provider = await store.getProvider(providerId);
+      if (!provider) throw new Error(`Provider not found: ${providerId}`);
+      const discovery = await discoverProviderModels({
+        providerId,
+        providerType: provider.type,
+        baseUrl: provider.baseUrl,
+        apiKey: provider.apiKey,
+      });
+      if (!discovery.ok) {
+        throw new Error(
+          discovery.error || `provider discover failed (${discovery.status || "n/a"})`,
+        );
+      }
+
+      const autoAdded: Array<{ modelId: string; modelName: string }> = [];
+      if (params.autoAdd === true) {
+        const prefix = String(params.prefix || "").trim();
+        for (const remoteModelName of discovery.models) {
+          const modelName = String(remoteModelName || "").trim();
+          if (!modelName) continue;
+          const modelId = prefix ? `${prefix}${modelName}` : modelName;
+          if (store.getModel(modelId)) continue;
+          store.upsertModel({
+            id: modelId,
+            providerId,
+            name: modelName,
+          });
+          autoAdded.push({ modelId, modelName });
+        }
+      }
+
+      return {
+        providerId,
+        discoveredModels: discovery.models,
+        modelCount: discovery.models.length,
+        autoAdded,
+      };
+    } finally {
+      store.close();
+    }
+  }
+
+  /**
+   * 新增或更新 model。
+   */
+  async upsertModel(input: {
+    id: string;
+    providerId: string;
+    name: string;
+    temperature?: unknown;
+    maxTokens?: unknown;
+    topP?: unknown;
+    frequencyPenalty?: unknown;
+    presencePenalty?: unknown;
+    anthropicVersion?: string;
+    isPaused?: boolean;
+  }): Promise<{ modelId: string }> {
+    const id = String(input.id || "").trim();
+    if (!id) throw new Error("modelId cannot be empty");
+    const providerId = String(input.providerId || "").trim();
+    if (!providerId) throw new Error("providerId cannot be empty");
+    const name = String(input.name || "").trim();
+    if (!name) throw new Error("modelName cannot be empty");
+
+    const store = new PlatformStore();
+    try {
+      const provider = await store.getProvider(providerId);
+      if (!provider) throw new Error(`Provider not found: ${providerId}`);
+      store.upsertModel({
+        id,
+        providerId,
+        name,
+        temperature: parseOptionalNumber(input.temperature),
+        maxTokens: parseOptionalPositiveInteger(input.maxTokens),
+        topP: parseOptionalNumber(input.topP),
+        frequencyPenalty: parseOptionalNumber(input.frequencyPenalty),
+        presencePenalty: parseOptionalNumber(input.presencePenalty),
+        anthropicVersion: String(input.anthropicVersion || "").trim() || undefined,
+        isPaused: input.isPaused === true,
+      });
+      return { modelId: id };
+    } finally {
+      store.close();
+    }
+  }
+
+  /**
+   * 删除 model。
+   */
+  async removeModel(modelId: string): Promise<void> {
+    const usage = await this.getModelUsage(modelId);
+    if (usage.references.length > 0) {
+      throw new Error(
+        `Model "${usage.model.id}" is still used by agent projects: ${usage.references.map((reference) => formatAgentReference(reference)).join(", ")}. Switch those projects to another model first.`,
+      );
+    }
+    const store = new PlatformStore();
+    try {
+      store.removeModel(usage.model.id);
+    } finally {
+      store.close();
+    }
+  }
+
+  /**
+   * 设置 model pause 状态。
+   */
+  async setModelPaused(modelId: string, isPaused: boolean): Promise<void> {
+    const id = String(modelId || "").trim();
+    if (!id) throw new Error("modelId cannot be empty");
+    const store = new PlatformStore();
+    try {
+      const model = store.getModel(id);
+      if (!model) throw new Error(`Model not found: ${id}`);
+      store.setModelPaused(id, isPaused);
+    } finally {
+      store.close();
+    }
+  }
+
+  /**
+   * 测试 model 可调用性（真实推理调用）。
+   */
+  async testModel(modelId: string, prompt?: string): Promise<{
+    modelId: string;
+    prompt: string;
+    text: string;
+  }> {
+    const id = String(modelId || "").trim();
+    if (!id) throw new Error("modelId cannot be empty");
+    const actualPrompt = String(prompt || "").trim() || "Reply with exactly: OK";
+    const model = await createRuntimeModel({
+      config: {
+        name: "console-model-test",
+        version: "1.0.0",
+        execution: { type: "api", modelId: id },
+      },
+    });
+    const result = await generateText({
+      model,
+      prompt: actualPrompt,
+    });
+    return {
+      modelId: id,
+      prompt: actualPrompt,
+      text: result.text,
+    };
+  }
+}

package/src/process/daemon/Api.ts

@@ -3,7 +3,7 @@
  *
  * 关键点（中文）
  * - 这里描述的是 CLI 与 agent daemon 之间的远程访问契约，不包含具体 HTTP 实现。
- * - service 等上层模块只依赖这些协议类型，不需要感知 city/daemon 的内部实现细节。
+ * - plugin runtime 等上层模块只依赖这些协议类型，不需要感知 city/daemon 的内部实现细节。
  * - 该文件属于 `main/city/daemon/*` 的协议边界，而不是通用 HTTP 类型目录。
  */
 
@@ -40,7 +40,7 @@ export type DaemonJsonApiCallParams = {
    *
    * 说明（中文）
    * - 仅本地 IPC transport 当前会消费该参数。
-   * - 用于 `session execute`、`service command` 这类可能持续几十秒的请求，
+   * - 用于 `session execute`、`plugin command` 这类可能持续几十秒的请求，
    *   避免被默认短超时误判成“Agent server 未启动”。
    */
   timeoutMs?: number;

package/src/process/registry/AgentHostRuntime.ts

@@ -3,7 +3,7 @@
  *
  * 关键点（中文）
  * - `main/agent/*` 负责创建这些宿主能力对象，再注入到 AgentRuntime。
- * - services / session / plugins 只消费这些对象，不再直接 import `main/*`。
+ * - plugin runtimes / session / plugins 只消费这些对象，不再直接 import `main/*`。
  * - 当前由 city 在这里统一装配路径、plugin 配置持久化与平台能力三类宿主对象。
  */
 import {
@@ -23,6 +23,9 @@ import type {
   AgentPathRuntime,
   AgentPlatformRuntime,
   AgentPluginConfigRuntime,
+  ChatChannelAccountListItem,
+  StoredChannelAccount,
+  StoredChannelAccountChannel,
 } from "@downcity/agent";
 import type { DowncityConfig } from "@downcity/agent";
 import { PlatformStore } from "@/platform/store/index.js";
@@ -36,13 +39,71 @@ import {
   writeChatAuthorizationConfig,
 } from "@/platform/chatAuthorization/Store.js";
 
+/**
+ * 脱敏显示密钥。
+ *
+ * 关键点（中文）
+ * - channel account 列表只返回安全视图，避免在 CLI/UI 展示链路泄露明文。
+ * - 保持和现有 model provider 脱敏规则一致，减少用户心智负担。
+ */
+function maskSecret(value: string | undefined): string | undefined {
+  const raw = String(value || "").trim();
+  if (!raw) return undefined;
+  if (raw.length <= 8) return "***";
+  return `${raw.slice(0, 4)}***${raw.slice(-4)}`;
+}
+
+/**
+ * 将存储层 channel account 转成对外安全视图。
+ */
+function toChannelAccountListItem(
+  account: StoredChannelAccount,
+): ChatChannelAccountListItem {
+  return {
+    id: account.id,
+    channel: account.channel,
+    name: account.name,
+    identity: account.identity,
+    owner: account.owner,
+    creator: account.creator,
+    domain: account.domain,
+    sandbox: account.sandbox === true,
+    hasBotToken: !!String(account.botToken || "").trim(),
+    hasAppId: !!String(account.appId || "").trim(),
+    hasAppSecret: !!String(account.appSecret || "").trim(),
+    botTokenMasked: maskSecret(account.botToken),
+    appIdMasked: maskSecret(account.appId),
+    appSecretMasked: maskSecret(account.appSecret),
+    createdAt: account.createdAt,
+    updatedAt: account.updatedAt,
+  };
+}
+
+/**
+ * 归一化并校验 channel account 渠道名。
+ */
+function normalizeChannelAccountChannel(
+  channelInput: string,
+): StoredChannelAccountChannel {
+  const channel = String(channelInput || "").trim().toLowerCase();
+  if (channel === "telegram" || channel === "feishu" || channel === "qq") {
+    return channel;
+  }
+  throw new Error(`Unsupported channel account channel: ${channelInput}`);
+}
+
 /**
  * 创建当前项目的路径能力集合。
  */
-export function createAgentPathRuntime(projectRoot: string): AgentPathRuntime {
+export function createAgentPathRuntime(
+  projectRoot: string,
+  agentIdInput: string,
+): AgentPathRuntime {
   const rootPath = String(projectRoot || "").trim();
+  const agentId = String(agentIdInput || "").trim();
   return {
     projectRoot: rootPath,
+    agentId,
     getDowncityDirPath: () => getDowncityDirPath(rootPath),
     getCacheDirPath: () => getCacheDirPath(rootPath),
     getDowncityChannelDirPath: () => getDowncityChannelDirPath(rootPath),
@@ -51,9 +112,10 @@ export function createAgentPathRuntime(projectRoot: string): AgentPathRuntime {
     getDowncityMemoryLongTermPath: () => getDowncityMemoryLongTermPath(rootPath),
     getDowncityMemoryDailyDirPath: () => getDowncityMemoryDailyDirPath(rootPath),
     getDowncityMemoryDailyPath: (date) => getDowncityMemoryDailyPath(rootPath, date),
-    getDowncitySessionRootDirPath: () => getDowncitySessionRootDirPath(rootPath),
-    getDowncitySessionDirPath: (sessionId) => getDowncitySessionDirPath(rootPath, sessionId),
-  };
+    getDowncitySessionRootDirPath: () => getDowncitySessionRootDirPath(rootPath, agentId),
+    getDowncitySessionDirPath: (sessionId) =>
+      getDowncitySessionDirPath(rootPath, agentId, sessionId),
+  } as AgentPathRuntime;
 }
 
 /**
@@ -130,6 +192,34 @@ export function createAgentPlatformRuntime(): AgentPlatformRuntime {
         store.close();
       }
     },
+    listChannelAccounts: async () => {
+      const store = new PlatformStore();
+      try {
+        const accounts = await store.listChannelAccounts();
+        return accounts.map(toChannelAccountListItem);
+      } finally {
+        store.close();
+      }
+    },
+    updateChannelAccount: async (input) => {
+      const store = new PlatformStore();
+      try {
+        await store.upsertChannelAccount({
+          ...input,
+          channel: normalizeChannelAccountChannel(input.channel),
+        });
+      } finally {
+        store.close();
+      }
+    },
+    removeChannelAccount: async (channelAccountId) => {
+      const store = new PlatformStore();
+      try {
+        store.removeChannelAccount(channelAccountId);
+      } finally {
+        store.close();
+      }
+    },
     readChatAuthorizationConfig: (projectRoot) => readChatAuthorizationConfigSync(projectRoot),
     writeChatAuthorizationConfig,
     setChatAuthorizationUserRole,

package/bin/cli/service/ServiceActionCommands.d.ts

@@ -1,14 +0,0 @@
-/**
- * Service action CLI 注册器。
- *
- * 关键点（中文）
- * - 负责把 service actions 挂到 commander（`city <service> <action>`）。
- * - 仅处理 CLI 参数映射与远程调用，不承载 service 状态机逻辑。
- * - service 注册表与调度时间解析统一复用 agent 包实现，避免 city 维护第二套事实源。
- */
-import type { Command } from "commander";
-/**
- * 注册所有 service actions 的 CLI 命令。
- */
-export declare function registerAllServicesForCli(program: Command): void;
-//# sourceMappingURL=ServiceActionCommands.d.ts.map

package/bin/cli/service/ServiceActionCommands.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServiceActionCommands.d.ts","sourceRoot":"","sources":["../../../src/cli/service/ServiceActionCommands.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgYzC;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkBhE"}