aios-management-web 0.1.0

package/test/integration/common.js

@@ -0,0 +1,208 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import mqtt from "mqtt";
+
+const DEFAULT_BASE_URL = "http://127.0.0.1:3030";
+const DEFAULT_ARTIFACT_ROOT = "E:\\tmp\\aios4";
+
+export function loadSettings() {
+  const artifactRoot = path.resolve(process.env.AIOS_TEST_ARTIFACT_ROOT || DEFAULT_ARTIFACT_ROOT);
+  const envJsonPath = path.resolve(process.env.AIOS_TEST_ENV_JSON || ".env.json");
+  const envConfig = JSON.parse(fs.readFileSync(envJsonPath, "utf8"));
+  const moduleDir = path.dirname(new URL(import.meta.url).pathname.replace(/^\//, ""));
+  const reportDir = path.resolve(process.env.AIOS_TEST_REPORT_DIR || path.join(moduleDir, "..", ".reports"));
+
+  return {
+    baseUrl: process.env.AIOS_WEB_BASE_URL || DEFAULT_BASE_URL,
+    artifactRoot,
+    envJsonPath,
+    envConfig,
+    reportDir,
+    ontologyZip: path.join(artifactRoot, ".ontology-demo", "hzg-ontology-demo-wms.zip"),
+    templateZip: path.join(artifactRoot, ".workspace-demo", "finance.zip"),
+    skipCleanup: process.env.AIOS_TEST_SKIP_CLEANUP === "1"
+  };
+}
+
+export function newReport(name, extra = {}) {
+  return {
+    name,
+    startedAt: new Date().toISOString(),
+    actions: [],
+    cleanup: [],
+    error: null,
+    ...extra
+  };
+}
+
+export function addAction(report, action, ok, status, body, note) {
+  report.actions.push({
+    action,
+    ok,
+    status,
+    body,
+    note
+  });
+}
+
+export async function runCleanup(report, action, fn) {
+  try {
+    const result = await fn();
+    report.cleanup.push({
+      action,
+      ok: true,
+      result
+    });
+  } catch (error) {
+    report.cleanup.push({
+      action,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+
+export function finishReport(report) {
+  report.finishedAt = new Date().toISOString();
+}
+
+export function writeReport(settings, report) {
+  fs.mkdirSync(settings.reportDir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const filePath = path.join(settings.reportDir, `${report.name}-${stamp}.json`);
+  fs.writeFileSync(filePath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+  return filePath;
+}
+
+export class HttpSession {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+    this.token = "";
+  }
+
+  setToken(token) {
+    this.token = token;
+  }
+
+  async request(method, route, options = {}) {
+    const headers = new Headers(options.headers || {});
+    if (this.token) {
+      headers.set("Authorization", `Bearer ${this.token}`);
+    }
+
+    let body = undefined;
+    if (options.json !== undefined) {
+      headers.set("Content-Type", "application/json");
+      body = JSON.stringify(options.json);
+    } else if (options.formData) {
+      body = options.formData;
+    }
+
+    const response = await fetch(`${this.baseUrl}${route}`, {
+      method,
+      headers,
+      body
+    });
+
+    if (response.status === 204) {
+      return {
+        ok: response.ok,
+        status: response.status,
+        body: null
+      };
+    }
+
+    const payload = await response.json();
+    return {
+      ok: response.ok,
+      status: response.status,
+      body: payload
+    };
+  }
+
+  get(route) {
+    return this.request("GET", route);
+  }
+
+  post(route, json) {
+    return this.request("POST", route, { json });
+  }
+
+  put(route, json) {
+    return this.request("PUT", route, { json });
+  }
+
+  delete(route) {
+    return this.request("DELETE", route);
+  }
+
+  multipart(method, route, fields, fileField) {
+    const form = new FormData();
+    for (const [key, value] of Object.entries(fields)) {
+      if (value === undefined || value === null) {
+        continue;
+      }
+      form.set(key, Array.isArray(value) ? JSON.stringify(value) : String(value));
+    }
+
+    if (fileField) {
+      const buffer = fs.readFileSync(fileField.path);
+      form.set(fileField.name, new Blob([buffer]), fileField.filename);
+    }
+
+    return this.request(method, route, { formData: form });
+  }
+}
+
+export async function loginAsAdmin(session, report) {
+  const response = await session.post("/api/auth/login", {
+    username: "aios",
+    password: "123456"
+  });
+  addAction(report, "auth.login", response.ok, response.status, response.body);
+  if (!response.ok) {
+    throw new Error(`auth.login failed: ${JSON.stringify(response.body)}`);
+  }
+  session.setToken(response.body.token);
+  return response.body;
+}
+
+export async function mqttPublish(envConfig, topic, payload) {
+  await new Promise((resolve, reject) => {
+    const client = mqtt.connect(envConfig.AIOS_MQTT_CHANNEL_BROKER, {
+      clientId: `aios-web-it-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      username: envConfig.AIOS_MQTT_CHANNEL_USERNAME || undefined,
+      password: envConfig.AIOS_MQTT_CHANNEL_PASSWORD || undefined,
+      clean: true,
+      reconnectPeriod: 1000
+    });
+
+    const fail = (error) => {
+      client.end(true);
+      reject(error);
+    };
+
+    client.once("error", fail);
+    client.once("connect", () => {
+      client.publish(topic, JSON.stringify(payload), { qos: 1, retain: false }, (error) => {
+        if (error) {
+          fail(error);
+          return;
+        }
+        client.end(true, {}, () => resolve());
+      });
+    });
+  });
+}
+
+export function buildAgentTopics(envConfig, agentId) {
+  return {
+    inbound: envConfig.AIOS_AGENT_CHANNEL_INBOUND_TOPIC_TEMPLATE.replace("{agentId}", agentId),
+    outbound: envConfig.AIOS_AGENT_CHANNEL_OUTBOUND_TOPIC_TEMPLATE.replace("{agentId}", agentId)
+  };
+}
+
+export function findBy(items, key, value) {
+  return Array.isArray(items) ? items.find((item) => item?.[key] === value) : undefined;
+}

package/test/integration/fast.js

@@ -0,0 +1,135 @@
+import {
+  HttpSession,
+  addAction,
+  finishReport,
+  findBy,
+  loadSettings,
+  loginAsAdmin,
+  newReport,
+  runCleanup,
+  writeReport
+} from "./common.js";
+
+async function main() {
+  const settings = loadSettings();
+  const report = newReport("fast", {
+    baseUrl: settings.baseUrl,
+    ontologyZip: settings.ontologyZip,
+    templateZip: settings.templateZip
+  });
+  const session = new HttpSession(settings.baseUrl);
+  const stamp = String(Date.now());
+  const templateName = `tmpl${stamp}`;
+  const agentSlug = `agent${stamp}`;
+  const applicationName = `app-${stamp}`;
+
+  let templateRow = null;
+  let agentRow = null;
+  let systemRow = null;
+
+  try {
+    await loginAsAdmin(session, report);
+
+    const templateCreate = await session.multipart("POST", "/api/templates", {
+      template_name: templateName,
+      description: "fast integration template"
+    }, {
+      name: "artifact",
+      path: settings.templateZip,
+      filename: "finance.zip"
+    });
+    addAction(report, "templates.create", templateCreate.ok, templateCreate.status, templateCreate.body);
+    if (!templateCreate.ok) {
+      throw new Error(`templates.create failed: ${JSON.stringify(templateCreate.body)}`);
+    }
+    templateRow = templateCreate.body;
+
+    const agentCreate = await session.post("/api/agents", {
+      slug: agentSlug,
+      agent_name: "Fast Integration Agent",
+      template_name: templateName,
+      description: "fast integration agent",
+      docs_content: "# Agent\n\nFast integration test.\n",
+      tags: ["fast"],
+      permission_usernames: ["zhangsan"],
+      skill_slugs: [],
+      restart: true
+    });
+    addAction(report, "agents.create", agentCreate.ok && agentCreate.body?.status === "normal", agentCreate.status, agentCreate.body);
+    if (!agentCreate.ok) {
+      throw new Error(`agents.create failed: ${JSON.stringify(agentCreate.body)}`);
+    }
+    agentRow = agentCreate.body;
+
+    const syncStatus = await session.post("/api/settings/agent-sync", {});
+    addAction(report, "settings.agent-sync", syncStatus.ok && syncStatus.body?.status === "success", syncStatus.status, syncStatus.body);
+    if (!syncStatus.ok) {
+      throw new Error(`settings.agent-sync failed: ${JSON.stringify(syncStatus.body)}`);
+    }
+
+    const systemCreate = await session.multipart("POST", "/api/systems", {
+      provider: "hzg",
+      application_name: applicationName,
+      description: "fast integration system",
+      scheme: "https",
+      host: "example.com",
+      port: 443,
+      status: "active"
+    }, {
+      name: "ontology",
+      path: settings.ontologyZip,
+      filename: "hzg-ontology-demo-wms.zip"
+    });
+    addAction(report, "systems.create", systemCreate.ok, systemCreate.status, systemCreate.body);
+    if (!systemCreate.ok) {
+      throw new Error(`systems.create failed: ${JSON.stringify(systemCreate.body)}`);
+    }
+    systemRow = systemCreate.body;
+
+    const templatesList = await session.get("/api/templates");
+    addAction(report, "templates.list", templatesList.ok && Boolean(findBy(templatesList.body, "template_name", templateName)), templatesList.status, templatesList.body);
+
+    const agentsList = await session.get("/api/agents");
+    addAction(report, "agents.list", agentsList.ok && Boolean(findBy(agentsList.body, "slug", agentSlug)), agentsList.status, agentsList.body);
+
+    const internalAgents = await session.get("/api/internal/cui/agents");
+    const normalAgent = Array.isArray(internalAgents.body?.items)
+      ? findBy(internalAgents.body.items, "agent_id", agentSlug)
+      : null;
+    addAction(
+      report,
+      "internal.cui.agents",
+      internalAgents.ok
+        && Boolean(normalAgent),
+      internalAgents.status,
+      internalAgents.body
+    );
+
+    const systemsList = await session.get("/api/systems");
+    addAction(report, "systems.list", systemsList.ok && Boolean(findBy(systemsList.body, "application_name", applicationName)), systemsList.status, systemsList.body);
+  } catch (error) {
+    report.error = error instanceof Error ? error.message : String(error);
+  } finally {
+    if (!settings.skipCleanup) {
+      if (systemRow?.id) {
+        await runCleanup(report, "systems.delete", async () => (await session.delete(`/api/systems/${systemRow.id}`)).body);
+      }
+      if (agentRow?.id) {
+        await runCleanup(report, "agents.delete", async () => (await session.delete(`/api/agents/${agentRow.id}`)).body);
+      }
+      if (templateRow?.template_name) {
+        await runCleanup(report, "templates.delete", async () => (await session.delete(`/api/templates/${templateRow.template_name}`)).body);
+      }
+    }
+
+    finishReport(report);
+    const reportPath = writeReport(settings, report);
+    console.log(reportPath);
+    process.exit(report.error ? 1 : 0);
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack : String(error));
+  process.exit(1);
+});

package/test/integration/full.js

@@ -0,0 +1,306 @@
+import {
+  HttpSession,
+  addAction,
+  buildAgentTopics,
+  finishReport,
+  findBy,
+  loadSettings,
+  loginAsAdmin,
+  mqttPublish,
+  newReport,
+  runCleanup,
+  writeReport
+} from "./common.js";
+
+function assertOk(response, label) {
+  if (!response.ok) {
+    throw new Error(`${label} failed: ${JSON.stringify(response.body)}`);
+  }
+}
+
+async function main() {
+  const settings = loadSettings();
+  const report = newReport("full", {
+    baseUrl: settings.baseUrl,
+    skipped: ["skills"]
+  });
+  const session = new HttpSession(settings.baseUrl);
+  const stamp = String(Date.now());
+  const templateName = `tmpl${stamp}`;
+  const agentSlug = `agent${stamp}`;
+  const applicationName = `app-${stamp}`;
+  const username = `user${stamp}`;
+  const sessionId = `session-${stamp}`;
+  const traceId = `invoke-${stamp}`;
+
+  let templateRow = null;
+  let agentRow = null;
+  let systemRow = null;
+  let userRow = null;
+
+  try {
+    await loginAsAdmin(session, report);
+
+    for (const route of ["/api/auth/me", "/api/bootstrap", "/api/dashboard", "/api/settings"]) {
+      const response = await session.get(route);
+      addAction(report, route, response.ok, response.status, response.body);
+      assertOk(response, route);
+    }
+
+    const usersInitial = await session.get("/api/users");
+    addAction(report, "users.list.initial", usersInitial.ok && Array.isArray(usersInitial.body) && usersInitial.body.length >= 3, usersInitial.status, usersInitial.body);
+    assertOk(usersInitial, "users.list.initial");
+
+    const userCreate = await session.post("/api/users", {
+      role: "aios-admin",
+      username,
+      display_name: "Integration User",
+      status: "active",
+      password: "12345678",
+      tags: ["it"]
+    });
+    addAction(report, "users.create", userCreate.ok, userCreate.status, userCreate.body);
+    assertOk(userCreate, "users.create");
+    userRow = userCreate.body;
+
+    const userUpdate = await session.put(`/api/users/${userRow.id}`, {
+      display_name: "Integration User Updated",
+      status: "disabled",
+      tags: ["it", "disabled"]
+    });
+    addAction(report, "users.update", userUpdate.ok && userUpdate.body?.status === "disabled", userUpdate.status, userUpdate.body);
+    assertOk(userUpdate, "users.update");
+
+    const templateCreate = await session.multipart("POST", "/api/templates", {
+      template_name: templateName,
+      description: "full integration template"
+    }, {
+      name: "artifact",
+      path: settings.templateZip,
+      filename: "finance.zip"
+    });
+    addAction(report, "templates.create", templateCreate.ok, templateCreate.status, templateCreate.body);
+    assertOk(templateCreate, "templates.create");
+    templateRow = templateCreate.body;
+
+    const templatesList = await session.get("/api/templates");
+    addAction(report, "templates.list.verify", templatesList.ok && Boolean(findBy(templatesList.body, "template_name", templateName)), templatesList.status, templatesList.body);
+    assertOk(templatesList, "templates.list.verify");
+
+    const agentCreate = await session.post("/api/agents", {
+      slug: agentSlug,
+      agent_name: "Integration Agent",
+      template_name: templateName,
+      description: "integration agent",
+      docs_content: "# Agent\n\nIntegration test.\n",
+      tags: ["it"],
+      permission_usernames: ["zhangsan"],
+      skill_slugs: [],
+      restart: true
+    });
+    addAction(report, "agents.create", agentCreate.ok && agentCreate.body?.status === "normal", agentCreate.status, agentCreate.body);
+    assertOk(agentCreate, "agents.create");
+    agentRow = agentCreate.body;
+
+    const agentsList = await session.get("/api/agents");
+    addAction(report, "agents.list.verify", agentsList.ok && Boolean(findBy(agentsList.body, "slug", agentSlug)), agentsList.status, agentsList.body);
+    assertOk(agentsList, "agents.list.verify");
+
+    const topics = buildAgentTopics(settings.envConfig, agentSlug);
+    const syncStatus = await session.post("/api/settings/agent-sync", {});
+    addAction(report, "settings.agent-sync", syncStatus.ok && syncStatus.body?.status === "success", syncStatus.status, syncStatus.body);
+    assertOk(syncStatus, "settings.agent-sync");
+
+    const internalAgents = await session.get("/api/internal/cui/agents");
+    const normalAgent = Array.isArray(internalAgents.body?.items)
+      ? findBy(internalAgents.body.items, "agent_id", agentSlug)
+      : null;
+    addAction(
+      report,
+      "internal.cui.agents.normal-visible",
+      internalAgents.ok
+        && Boolean(normalAgent),
+      internalAgents.status,
+      internalAgents.body
+    );
+    assertOk(internalAgents, "internal.cui.agents.normal-visible");
+    await mqttPublish(settings.envConfig, topics.inbound, {
+      senderId: "employee-a",
+      senderName: "Employee A",
+      sessionId,
+      traceId: `trace-in-${stamp}`,
+      text: "please see file_input://admin-in/test/sample.txt"
+    });
+    await mqttPublish(settings.envConfig, topics.outbound, {
+      sessionId,
+      traceId: `trace-out-${stamp}`,
+      text: "processed file_output://admin-out/test/result.txt"
+    });
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
+    const threads = await session.get("/api/audit/threads");
+    const thread = Array.isArray(threads.body)
+      ? threads.body.find((item) => item.agent_slug === agentSlug && item.session_id === sessionId)
+      : null;
+    addAction(report, "audit.threads", threads.ok && Boolean(thread), threads.status, threads.body);
+    assertOk(threads, "audit.threads");
+    if (!thread) {
+      throw new Error("audit thread not found");
+    }
+
+    const messages = await session.get(`/api/audit/threads/${thread.id}/messages`);
+    addAction(report, "audit.messages", messages.ok && Array.isArray(messages.body) && messages.body.length >= 2, messages.status, messages.body);
+    assertOk(messages, "audit.messages");
+
+    const files = await session.get("/api/files?q=file_");
+    const fileHits = Array.isArray(files.body) ? files.body.filter((item) => item.agent_slug === agentSlug) : [];
+    addAction(report, "files.query", files.ok && fileHits.length >= 2, files.status, files.body);
+    assertOk(files, "files.query");
+    if (fileHits.length < 2) {
+      throw new Error("audit files missing");
+    }
+
+    const agentDisable = await session.put(`/api/agents/${agentRow.id}`, {
+      agent_name: "Integration Agent Updated",
+      description: "integration agent updated",
+      docs_content: "# Agent\n\nUpdated.\n",
+      status: "disabled",
+      tags: ["it", "updated"],
+      permission_usernames: ["lisi"],
+      skill_slugs: [],
+      restart: true
+    });
+    addAction(report, "agents.update.disable", agentDisable.ok && agentDisable.body?.status === "disabled", agentDisable.status, agentDisable.body);
+    assertOk(agentDisable, "agents.update.disable");
+
+    const internalAgentsDisabled = await session.get("/api/internal/cui/agents");
+    const disabledAgent = Array.isArray(internalAgentsDisabled.body?.items)
+      ? findBy(internalAgentsDisabled.body.items, "agent_id", agentSlug)
+      : null;
+    addAction(
+      report,
+      "internal.cui.agents.disabled-filtered",
+      internalAgentsDisabled.ok && !disabledAgent,
+      internalAgentsDisabled.status,
+      internalAgentsDisabled.body
+    );
+    assertOk(internalAgentsDisabled, "internal.cui.agents.disabled-filtered");
+
+    const systemCreate = await session.multipart("POST", "/api/systems", {
+      provider: "hzg",
+      application_name: applicationName,
+      description: "integration system",
+      scheme: "https",
+      host: "example.com",
+      port: 443,
+      status: "active"
+    }, {
+      name: "ontology",
+      path: settings.ontologyZip,
+      filename: "hzg-ontology-demo-wms.zip"
+    });
+    addAction(report, "systems.create", systemCreate.ok, systemCreate.status, systemCreate.body);
+    assertOk(systemCreate, "systems.create");
+    systemRow = systemCreate.body;
+
+    const systemUpdate = await session.multipart("PUT", `/api/systems/${systemRow.id}`, {
+      description: "integration system updated",
+      host: "service2.example.com",
+      status: "disabled"
+    });
+    addAction(report, "systems.update", systemUpdate.ok, systemUpdate.status, systemUpdate.body);
+    assertOk(systemUpdate, "systems.update");
+
+    const systemEnable = await session.post(`/api/systems/${systemRow.id}/status`, {
+      status: "active"
+    });
+    addAction(report, "systems.status.active", systemEnable.ok && systemEnable.body?.status === "active", systemEnable.status, systemEnable.body);
+    assertOk(systemEnable, "systems.status.active");
+
+    const systemTest = await session.request("POST", `/api/systems/${systemRow.id}/test`);
+    addAction(report, "systems.test", systemTest.ok && systemTest.body?.ok === true, systemTest.status, systemTest.body);
+    assertOk(systemTest, "systems.test");
+
+    const internalSystem = await session.get(`/api/internal/app-invoke/base-url?applicationName=${applicationName}`);
+    addAction(report, "internal.app-invoke.base-url", internalSystem.ok && internalSystem.body?.baseUrl === `https://service2.example.com:443/${applicationName}`, internalSystem.status, internalSystem.body);
+    assertOk(internalSystem, "internal.app-invoke.base-url");
+
+    const internalLog = await session.post("/api/internal/app-invoke/logs", {
+      trace_id: traceId,
+      agent_slug: agentSlug,
+      session_id: sessionId,
+      provider: "hzg",
+      application_name: applicationName,
+      command_name: "ping",
+      request_payload: { hello: "world" },
+      response_payload: { ok: true },
+      response_time_ms: 123,
+      success: true
+    });
+    addAction(report, "internal.app-invoke.logs", internalLog.ok, internalLog.status, internalLog.body);
+    assertOk(internalLog, "internal.app-invoke.logs");
+
+    const systemsLogs = await session.get(`/api/systems/logs?application_name=${applicationName}&agent_slug=${agentSlug}`);
+    const foundLog = Array.isArray(systemsLogs.body) ? systemsLogs.body.find((item) => item.trace_id === traceId) : null;
+    addAction(report, "systems.logs", systemsLogs.ok && Boolean(foundLog), systemsLogs.status, systemsLogs.body);
+    assertOk(systemsLogs, "systems.logs");
+
+    const systemsStats = await session.get(`/api/systems/stats?application_name=${applicationName}&agent_slug=${agentSlug}`);
+    addAction(report, "systems.stats", systemsStats.ok && Array.isArray(systemsStats.body) && systemsStats.body.length >= 1, systemsStats.status, systemsStats.body);
+    assertOk(systemsStats, "systems.stats");
+
+    const settingsUpdate = await session.put("/api/settings", {
+      portal_name: "AIOS IT",
+      brand_subtitle: "Integration",
+      theme_color: "#123456"
+    });
+    addAction(report, "settings.update", settingsUpdate.ok && settingsUpdate.body?.theme_color === "#123456", settingsUpdate.status, settingsUpdate.body);
+    assertOk(settingsUpdate, "settings.update");
+
+    const dashboardVerify = await session.get("/api/dashboard");
+    addAction(
+      report,
+      "dashboard.verify",
+      dashboardVerify.ok
+        && dashboardVerify.body?.stats?.agents >= 1
+        && dashboardVerify.body?.stats?.systems >= 1
+        && dashboardVerify.body?.stats?.threads >= 1,
+      dashboardVerify.status,
+      dashboardVerify.body
+    );
+    assertOk(dashboardVerify, "dashboard.verify");
+
+    const logout = await session.request("POST", "/api/auth/logout");
+    addAction(report, "auth.logout", logout.status === 204, logout.status, logout.body);
+  } catch (error) {
+    report.error = error instanceof Error ? error.message : String(error);
+  } finally {
+    if (!settings.skipCleanup) {
+      if (systemRow?.id) {
+        await runCleanup(report, "systems.delete", async () => (await session.delete(`/api/systems/${systemRow.id}`)).body);
+      }
+      if (agentRow?.id) {
+        await runCleanup(report, "agents.delete", async () => (await session.delete(`/api/agents/${agentRow.id}`)).body);
+      }
+      if (templateRow?.template_name) {
+        await runCleanup(report, "templates.delete", async () => (await session.delete(`/api/templates/${templateRow.template_name}`)).body);
+      }
+      if (userRow?.id) {
+        await runCleanup(report, "users.delete", async () => {
+          const response = await session.delete(`/api/users/${userRow.id}`);
+          return { status: response.status };
+        });
+      }
+    }
+
+    finishReport(report);
+    const reportPath = writeReport(settings, report);
+    console.log(reportPath);
+    process.exit(report.error ? 1 : 0);
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack : String(error));
+  process.exit(1);
+});