aios-management-web 0.1.0

package/server/src/app.js

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import express from "express";
+
+import { createRoutes } from "./api/routes/index.js";
+import { loadEnv } from "./config/env.js";
+import { db } from "./db/index.js";
+import { ManagementRpcClient } from "./infra/mqtt/management-rpc-client.js";
+import { HzgProviderClient } from "./infra/providers/hzg-provider-client.js";
+import { ObjectStorage } from "./infra/s3/object-storage.js";
+import { AgentService } from "./services/agent-service.js";
+import { AgentStatusSyncService } from "./services/agent-status-sync-service.js";
+import { AuditLogService } from "./services/audit-log-service.js";
+import { AuthService } from "./services/auth-service.js";
+import { CatalogSyncService } from "./services/catalog-sync-service.js";
+import { ExternalService } from "./services/external-service.js";
+import { PortalService } from "./services/portal-service.js";
+import { SystemService } from "./services/system-service.js";
+import { TopicPingService } from "./services/topic-ping-service.js";
+import { AppError } from "./utils/errors.js";
+
+export function createServerApp() {
+  const env = loadEnv();
+  const objectStorage = new ObjectStorage(env);
+  const authService = new AuthService({ db, env });
+  const rpcClient = new ManagementRpcClient({ env, db });
+  const hzgProviderClient = new HzgProviderClient();
+  const auditLogService = new AuditLogService({ db });
+  const catalogSyncService = new CatalogSyncService({ db, rpcClient, auditLogService, env });
+  const agentStatusSyncService = new AgentStatusSyncService({ db, rpcClient, auditLogService });
+  const portalService = new PortalService({ db, objectStorage, rpcClient, authService });
+  const topicPingService = new TopicPingService({ db, env, rpcClient });
+  const agentService = new AgentService({ db, rpcClient, objectStorage, env });
+  const systemService = new SystemService({ db, objectStorage, rpcClient });
+  const externalService = new ExternalService({
+    db,
+    agentService,
+    systemService,
+    hzgProviderClient,
+    auditLogService
+  });
+
+  const services = {
+    env,
+    authService,
+    portalService,
+    agentService,
+    topicPingService,
+    auditLogService,
+    systemService,
+    externalService,
+    catalogSyncService,
+    agentStatusSyncService,
+    rpcClient,
+    hzgProviderClient
+  };
+
+  const app = express();
+  app.use(express.json({ limit: "5mb" }));
+  app.use(express.urlencoded({ extended: true }));
+  app.use("/api", createRoutes(services));
+
+  const distDir = path.resolve("dist");
+  if (fs.existsSync(distDir)) {
+    app.use(express.static(distDir));
+    app.get(/^(?!\/api).*/, (_req, res) => {
+      res.sendFile(path.join(distDir, "index.html"));
+    });
+  }
+
+  app.use((error, _req, res, _next) => {
+    if (error instanceof AppError) {
+      res.status(error.status).json({
+        code: error.code,
+        message: error.message,
+        details: error.details
+      });
+      return;
+    }
+
+    console.error(error);
+    res.status(500).json({
+      code: "internal_error",
+      message: error?.message || "服务器内部错误"
+    });
+  });
+
+  return { app, env, services };
+}

package/server/src/background/index.js

@@ -0,0 +1,106 @@
+export function startBackgroundServices({ env, services }) {
+  const rpcStarter = services.rpcClient.start();
+  const starters = [rpcStarter];
+  let schedulerStarterTimer = null;
+  let schedulerTimer = null;
+  let scheduledTaskIndex = 0;
+
+  function createStartupTasks() {
+    return [
+      () => services.catalogSyncService.syncAgentsTask({ trigger: "startup" }),
+      () => services.catalogSyncService.refreshAgentUsage({ trigger: "startup" }),
+      () => services.catalogSyncService.syncSkillsTask({ trigger: "startup" }),
+      () => services.catalogSyncService.syncTemplatesTask({ trigger: "startup" }),
+      () => services.catalogSyncService.syncSystemsTask({ trigger: "startup" })
+    ];
+  }
+
+  function createScheduledTasks() {
+    return [
+      {
+        label: "agent catalog sync",
+        run: () => services.catalogSyncService.syncAgentsTask({ trigger: "scheduled" })
+      },
+      {
+        label: "agent usage refresh",
+        run: () => services.catalogSyncService.refreshAgentUsage({ trigger: "scheduled" })
+      },
+      {
+        label: "skill catalog sync",
+        run: () => services.catalogSyncService.syncSkillsTask({ trigger: "scheduled" })
+      },
+      {
+        label: "template catalog sync",
+        run: () => services.catalogSyncService.syncTemplatesTask({ trigger: "scheduled" })
+      },
+      {
+        label: "ontology catalog sync",
+        run: () => services.catalogSyncService.syncSystemsTask({ trigger: "scheduled" })
+      }
+    ];
+  }
+
+  function scheduleGlobalClock() {
+    const startupDelayMs = 5 * 60 * 1000;
+    const intervalMs = 60 * 1000;
+    const scheduledTasks = createScheduledTasks();
+    const runNextScheduledTask = () => {
+      const task = scheduledTasks[scheduledTaskIndex];
+      scheduledTaskIndex = (scheduledTaskIndex + 1) % scheduledTasks.length;
+      task.run().catch((error) => {
+        console.error(`Scheduled ${task.label} failed`, error);
+      });
+    };
+
+    if (schedulerStarterTimer) {
+      clearTimeout(schedulerStarterTimer);
+    }
+    if (schedulerTimer) {
+      clearInterval(schedulerTimer);
+    }
+
+    scheduledTaskIndex = 0;
+    schedulerStarterTimer = setTimeout(() => {
+      schedulerStarterTimer = null;
+      runNextScheduledTask();
+      schedulerTimer = setInterval(runNextScheduledTask, intervalMs);
+    }, startupDelayMs);
+  }
+
+  Promise.allSettled(starters).then((results) => {
+    for (const result of results) {
+      if (result.status === "rejected") {
+        console.error("Background service failed to start", result.reason);
+      }
+    }
+  });
+
+  rpcStarter
+    .then(async () => {
+      for (const run of createStartupTasks()) {
+        await run();
+      }
+      scheduleGlobalClock();
+    })
+    .catch((error) => {
+      console.error("Background startup sync failed", error);
+    });
+
+  return {
+    async stop() {
+      if (schedulerStarterTimer) {
+        clearTimeout(schedulerStarterTimer);
+        schedulerStarterTimer = null;
+      }
+
+      if (schedulerTimer) {
+        clearInterval(schedulerTimer);
+        schedulerTimer = null;
+      }
+
+      await Promise.allSettled([
+        services.rpcClient.stop()
+      ]);
+    }
+  };
+}

package/server/src/background/protocol.js

@@ -0,0 +1,15 @@
+export function newSuccessResponse(traceId, data) {
+  return {
+    traceId,
+    code: 0,
+    data
+  };
+}
+
+export function newErrorResponse(traceId, code, message) {
+  return {
+    traceId,
+    code,
+    message
+  };
+}

package/server/src/config/env.js

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import path from "node:path";
+
+let fileEnvCache = null;
+
+function loadFileEnv() {
+  if (fileEnvCache !== null) {
+    return fileEnvCache;
+  }
+
+  const envFilePath = path.resolve(".env.json");
+  if (!fs.existsSync(envFilePath)) {
+    fileEnvCache = {};
+    return fileEnvCache;
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(envFilePath, "utf8"));
+    fileEnvCache = parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    fileEnvCache = {};
+  }
+
+  return fileEnvCache;
+}
+
+function readEnvValue(name, fallback = "") {
+  const envValue = process.env[name];
+  if (envValue !== undefined && envValue !== null && String(envValue).trim() !== "") {
+    return String(envValue).trim();
+  }
+
+  const fileEnvValue = loadFileEnv()[name];
+  if (fileEnvValue !== undefined && fileEnvValue !== null && String(fileEnvValue).trim() !== "") {
+    return String(fileEnvValue).trim();
+  }
+
+  return fallback;
+}
+
+function readEnvBoolean(name, fallback = false) {
+  const value = readEnvValue(name, fallback ? "true" : "false");
+  return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+
+function readEnvNumber(name, fallback) {
+  const value = Number(readEnvValue(name, String(fallback)));
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+export function loadEnv() {
+  const aiosRoot = readEnvValue("AIOS_ROOT", "");
+  const defaultDataDir = aiosRoot
+    ? path.join(aiosRoot, "data", "web")
+    : path.join("data");
+  const dataDir = path.resolve(readEnvValue("AIOS_WEB_DATA_DIR", defaultDataDir));
+
+  return {
+    port: 3030,
+    dataDir,
+    sessionTtlHours: Number(readEnvValue("AIOS_WEB_SESSION_TTL_HOURS", "12")),
+    managementTimeoutMs: readEnvNumber("AIOS_MANAGEMENT_WEBSITE_TIMEOUT", 120) * 1000,
+    mqtt: {
+      brokerUrl: readEnvValue("AIOS_MQTT_CHANNEL_BROKER"),
+      username: readEnvValue("AIOS_MQTT_CHANNEL_USERNAME"),
+      password: readEnvValue("AIOS_MQTT_CHANNEL_PASSWORD"),
+      adminInboundTopic: readEnvValue("AIOS_ADMIN_INBOUND_TOPIC", "aios/admin/inbound"),
+      adminOutboundTopic: readEnvValue("AIOS_ADMIN_OUTBOUND_TOPIC", "aios/admin/outbound"),
+      agentInboundTopicTemplate: readEnvValue(
+        "AIOS_AGENT_CHANNEL_INBOUND_TOPIC_TEMPLATE",
+        "aios/agent/{agentId}/inbound"
+      ),
+      agentOutboundTopicTemplate: readEnvValue(
+        "AIOS_AGENT_CHANNEL_OUTBOUND_TOPIC_TEMPLATE",
+        "aios/agent/{agentId}/outbound"
+      )
+    },
+    s3: {
+      endpoint: readEnvValue("AIOS_S3_ENDPOINT"),
+      region: readEnvValue("AIOS_S3_REGION", "local"),
+      accessKeyId: readEnvValue("AIOS_S3_ACCESS_KEY_ID"),
+      secretAccessKey: readEnvValue("AIOS_S3_SECRET_ACCESS_KEY"),
+      forcePathStyle: readEnvBoolean("AIOS_S3_FORCE_PATH_STYLE", true),
+      adminInboxBucket: readEnvValue("AIOS_S3_ADMIN_INBOX_BUCKET"),
+      adminOutboxBucket: readEnvValue("AIOS_S3_ADMIN_OUTBOX_BUCKET"),
+      agentInboxBucket: readEnvValue("AIOS_S3_AGENT_INBOX_BUCKET"),
+      agentOutboxBucket: readEnvValue("AIOS_S3_AGENT_OUTBOX_BUCKET")
+    }
+  };
+}