aios-management-web 0.1.0

package/server/src/services/external-service.js

@@ -0,0 +1,308 @@
+import { randomUUID } from "node:crypto";
+
+import { badRequest, internalError, notFound } from "../utils/errors.js";
+
+const MAX_COOKIE_LENGTH = 16 * 1024;
+
+function normalizeProvider(value) {
+  const provider = String(value || "").trim().toLowerCase();
+  if (provider !== "hzg" && provider !== "phx") {
+    throw badRequest("provider 必须是 hzg 或 phx");
+  }
+  return provider;
+}
+
+function normalizeCookie(value) {
+  const cookie = String(value || "").trim();
+  if (cookie.length > MAX_COOKIE_LENGTH) {
+    throw badRequest(`cookie 长度不能超过 ${MAX_COOKIE_LENGTH} 字符`);
+  }
+  return cookie;
+}
+
+function parseJsonString(value, fallback = {}) {
+  if (typeof value !== "string" || !value.trim()) {
+    return fallback;
+  }
+
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+function normalizeResponsePayload(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+function extractAgentTopics(remoteStateJson) {
+  const remote = parseJsonString(remoteStateJson, {});
+  return {
+    inboundTopic: String(remote?.inboundTopic || remote?.["inbound-topic"] || "").trim(),
+    outboundTopic: String(remote?.outboundTopic || remote?.["outbound-topic"] || "").trim()
+  };
+}
+
+function describeUnavailableAgentStatus(status) {
+  switch (status) {
+    case "disabled":
+      return "agent 已停用";
+    case "overlimit":
+      return "agent 已超出用量限额";
+    default:
+      return `agent 状态不是 normal，当前状态为 ${status || "unknown"}`;
+  }
+}
+
+export class ExternalService {
+  constructor({ db, agentService, systemService, hzgProviderClient, auditLogService }) {
+    this.db = db;
+    this.agentService = agentService;
+    this.systemService = systemService;
+    this.hzgProviderClient = hzgProviderClient;
+    this.auditLogService = auditLogService;
+  }
+
+  upsertSessionCookie(sessionId, provider, cookie) {
+    const now = new Date().toISOString();
+    const normalizedCookie = normalizeCookie(cookie);
+    this.db.prepare(`
+      INSERT INTO external_session_cookies (
+        session_id, provider, cookie, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(session_id, provider) DO UPDATE SET
+        cookie = excluded.cookie,
+        updated_at = excluded.updated_at
+    `).run(sessionId, provider, normalizedCookie, now, now);
+  }
+
+  listAgentsForUser(username) {
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw badRequest("userName 不能为空");
+    }
+
+    return this.agentService.listAgentDirectoryForUser(normalizedUsername);
+  }
+
+  getOrCreateSession({ userName, agentId, cookie }) {
+    const normalizedUserName = String(userName || "").trim();
+    const normalizedAgentId = String(agentId || "").trim();
+    const normalizedCookie = normalizeCookie(cookie);
+    if (!normalizedUserName || !normalizedAgentId) {
+      throw badRequest("userName 和 agentId 不能为空");
+    }
+
+    const agent = this.db.prepare(`
+      SELECT id, slug, status, remote_state_json
+      FROM agents
+      WHERE slug = ?
+    `).get(normalizedAgentId);
+    if (!agent) {
+      throw notFound(`数字员工不存在：${normalizedAgentId}`);
+    }
+    if (agent.status !== "normal") {
+      throw internalError(`无法创建外部会话：${describeUnavailableAgentStatus(agent.status)}，agentId=${normalizedAgentId}`, {
+        agentId: normalizedAgentId,
+        status: agent.status
+      });
+    }
+
+    const hasPermission = this.db.prepare(`
+      SELECT 1
+      FROM agent_permissions ap
+      JOIN aios_users d ON d.id = ap.aios_user_id
+      WHERE ap.agent_id = ? AND d.username = ?
+    `).get(agent.id, normalizedUserName);
+    if (!hasPermission) {
+      throw notFound(`用户 ${normalizedUserName} 无权访问数字员工 ${normalizedAgentId}`);
+    }
+
+    const aiosUser = this.db.prepare(`
+      SELECT id
+      FROM aios_users
+      WHERE username = ?
+    `).get(normalizedUserName);
+    if (!aiosUser) {
+      throw notFound(`用户 ${normalizedUserName} 无权访问数字员工 ${normalizedAgentId}`);
+    }
+
+    const { inboundTopic, outboundTopic } = extractAgentTopics(agent.remote_state_json);
+    const existing = this.db.prepare(`
+      SELECT session_id
+      FROM external_sessions
+      WHERE aios_user_id = ? AND agent_id = ?
+    `).get(aiosUser.id, agent.id);
+    if (existing?.session_id) {
+      if (normalizedCookie) {
+        this.upsertSessionCookie(existing.session_id, "hzg", normalizedCookie);
+      }
+      return {
+        sessionId: existing.session_id,
+        inboundTopic,
+        outboundTopic
+      };
+    }
+
+    const sessionId = `s-${randomUUID()}`;
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      INSERT INTO external_sessions (
+        session_id, aios_user_id, agent_id, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?)
+    `).run(sessionId, aiosUser.id, agent.id, now, now);
+
+    if (normalizedCookie) {
+      this.upsertSessionCookie(sessionId, "hzg", normalizedCookie);
+    }
+
+    this.auditLogService.write({
+      userId: null,
+      username: normalizedUserName,
+      action: "创建外部会话",
+      detail: `用户 ${normalizedUserName} 为数字员工 ${agent.slug} 创建会话 ${sessionId}，agent状态=${agent.status}`
+    });
+
+    return {
+      sessionId,
+      inboundTopic,
+      outboundTopic
+    };
+  }
+
+  async getCookie(sessionId, provider, applicationName = "") {
+    const normalizedSessionId = String(sessionId || "").trim();
+    const normalizedProvider = normalizeProvider(provider);
+    const normalizedApplicationName = String(applicationName || "").trim().toLowerCase();
+    if (!normalizedSessionId) {
+      throw badRequest("sessionId 不能为空");
+    }
+
+    const existing = this.db.prepare(`
+      SELECT cookie
+      FROM external_session_cookies
+      WHERE session_id = ? AND provider = ?
+    `).get(normalizedSessionId, normalizedProvider);
+    if (existing?.cookie) {
+      return {
+        provider: normalizedProvider,
+        cookie: existing.cookie
+      };
+    }
+
+    const session = this.db.prepare(`
+      SELECT
+        es.session_id,
+        ag.slug AS agent_slug
+      FROM external_sessions es
+      JOIN agents ag ON ag.id = es.agent_id
+      WHERE es.session_id = ?
+    `).get(normalizedSessionId);
+    if (!session) {
+      throw notFound(`会话不存在：${normalizedSessionId}`);
+    }
+
+    if (normalizedProvider !== "hzg") {
+      throw notFound(`未找到 provider=${normalizedProvider} 的 Cookie`);
+    }
+
+    const system = normalizedApplicationName
+      ? this.systemService.findSystemForInvocation(normalizedProvider, normalizedApplicationName)
+      : this.systemService.findLatestActiveSystemByProvider(normalizedProvider);
+    if (!system) {
+      throw notFound(`未找到 provider=${normalizedProvider} 的可用业务系统`);
+    }
+
+    const cookie = await this.hzgProviderClient.createSessionCookie(system.base_url, normalizedSessionId);
+    this.upsertSessionCookie(normalizedSessionId, normalizedProvider, cookie);
+
+    return {
+      provider: normalizedProvider,
+      cookie
+    };
+  }
+
+  getContext(sessionId) {
+    const normalizedSessionId = String(sessionId || "").trim();
+    if (!normalizedSessionId) {
+      throw badRequest("sessionId 不能为空");
+    }
+
+    const session = this.db.prepare(`
+      SELECT
+        es.session_id,
+        d.username AS user_name,
+        ag.slug AS agent_id,
+        ag.agent_name,
+        ag.remote_state_json
+      FROM external_sessions es
+      JOIN aios_users d ON d.id = es.aios_user_id
+      JOIN agents ag ON ag.id = es.agent_id
+      WHERE es.session_id = ?
+    `).get(normalizedSessionId);
+    if (!session) {
+      throw notFound(`会话不存在：${normalizedSessionId}`);
+    }
+
+    const { inboundTopic, outboundTopic } = extractAgentTopics(session.remote_state_json);
+    return {
+      inboundTopic,
+      outboundTopic,
+      agentName: String(session.agent_name || "").trim(),
+      agentId: String(session.agent_id || "").trim(),
+      userName: String(session.user_name || "").trim()
+    };
+  }
+
+  async recordInvocation(payload) {
+    const sessionId = String(payload?.sessionId || "").trim();
+    const provider = normalizeProvider(payload?.provider);
+    const applicationName = String(payload?.applicationName || "").trim().toLowerCase();
+    const commandName = String(payload?.commandName || "").trim();
+    if (!sessionId || !applicationName || !commandName) {
+      throw badRequest("sessionId、applicationName、commandName 不能为空");
+    }
+
+    const session = this.db.prepare(`
+      SELECT
+        es.session_id,
+        d.username AS user_name,
+        ag.slug AS agent_slug
+      FROM external_sessions es
+      JOIN aios_users d ON d.id = es.aios_user_id
+      JOIN agents ag ON ag.id = es.agent_id
+      WHERE es.session_id = ?
+    `).get(sessionId);
+    if (!session) {
+      throw notFound(`会话不存在：${sessionId}`);
+    }
+
+    const system = this.systemService.findSystemForInvocation(provider, applicationName);
+    if (!system) {
+      throw notFound(`未找到业务系统：${provider}/${applicationName}`);
+    }
+
+    await this.systemService.recordInvocation({
+      trace_id: randomUUID(),
+      agent_slug: session.agent_slug,
+      session_id: sessionId,
+      provider: system.provider || provider,
+      application_name: applicationName,
+      command_name: commandName,
+      request_payload: parseJsonString(payload?.paramaters, {}),
+      response_payload: normalizeResponsePayload(payload?.response),
+      response_time_ms: Number(payload?.durationInMS || 0),
+      success: Boolean(payload?.isOK),
+      error_message: payload?.errorMessage ? String(payload.errorMessage) : null
+    });
+  }
+}

package/server/src/services/kernel-reset-service.js

@@ -0,0 +1,86 @@
+function normalizeRemoteName(...values) {
+  for (const value of values) {
+    const text = String(value || "").trim();
+    if (text) {
+      return text;
+    }
+  }
+
+  return "";
+}
+
+export class KernelResetService {
+  constructor({ rpcClient }) {
+    this.rpcClient = rpcClient;
+  }
+
+  async listAgentIds() {
+    const remote = await this.rpcClient.call("agent.list", {});
+    const items = Array.isArray(remote?.items) ? remote.items : [];
+    return items
+      .map((item) => normalizeRemoteName(item?.agentId, item?.id, item?.name))
+      .filter(Boolean);
+  }
+
+  async listOntologyIds() {
+    const remote = await this.rpcClient.call("ontology.list", {});
+    const items = Array.isArray(remote?.items) ? remote.items : [];
+    return items
+      .filter((item) => !item?.["is-built-in"])
+      .map((item) => normalizeRemoteName(item?.name, item?.applicationName, item?.id, item?.ontologyName))
+      .filter(Boolean);
+  }
+
+  async listTemplateNames() {
+    const remote = await this.rpcClient.call("agent.template.list", {});
+    const items = Array.isArray(remote?.items) ? remote.items : [];
+    return items
+      .filter((item) => !item?.["is-built-in"])
+      .map((item) => normalizeRemoteName(item?.templateName, item?.name))
+      .filter(Boolean);
+  }
+
+  async deleteAgents(agentIds) {
+    for (const agentId of agentIds) {
+      await this.rpcClient.call("agent.delete", { agentId });
+    }
+  }
+
+  async deleteOntologies(ontologyIds) {
+    for (const systemId of ontologyIds) {
+      await this.rpcClient.call("apps.delete", { systemId });
+    }
+  }
+
+  async deleteTemplates(templateNames) {
+    for (const templateName of templateNames) {
+      await this.rpcClient.call("agent.template.delete", { templateName });
+    }
+  }
+
+  async planReset() {
+    const agentIds = await this.listAgentIds();
+    const ontologyIds = await this.listOntologyIds();
+    const templateNames = await this.listTemplateNames();
+
+    return {
+      deletedAgents: agentIds,
+      deletedOntologies: ontologyIds,
+      deletedTemplates: templateNames
+    };
+  }
+
+  async resetKernel({ dryRun = false } = {}) {
+    const plan = await this.planReset();
+    if (!dryRun) {
+      await this.deleteAgents(plan.deletedAgents);
+      await this.deleteOntologies(plan.deletedOntologies);
+      await this.deleteTemplates(plan.deletedTemplates);
+    }
+
+    return {
+      ...plan,
+      dryRun
+    };
+  }
+}