aios-management-web 0.1.0

package/server/test/agent-status-sync-service.test.js

@@ -0,0 +1,167 @@
+import { AgentStatusSyncService } from "../src/services/agent-status-sync-service.js";
+
+function createDb(rows = []) {
+  const statements = [];
+  const items = rows.map((row) => ({ ...row }));
+
+  return {
+    statements,
+    items,
+    exec(sql) {
+      statements.push({ type: "exec", sql });
+    },
+    prepare(sql) {
+      if (sql.includes("SELECT *") && sql.includes("FROM agents")) {
+        return {
+          all: () => items
+        };
+      }
+
+      if (sql.includes("INSERT INTO agents")) {
+        return {
+          run: (
+            slug,
+            agentName,
+            description,
+            docsContent,
+            templateName,
+            status,
+            tagsJson,
+            dailyLimit,
+            usageSnapshotJson,
+            remoteStateJson,
+            createdAt,
+            updatedAt
+          ) => {
+            items.push({
+              id: items.length + 1,
+              slug,
+              agent_name: agentName,
+              description,
+              docs_content: docsContent,
+              template_name: templateName,
+              status,
+              tags_json: tagsJson,
+              daily_limit: dailyLimit,
+              usage_snapshot_json: usageSnapshotJson,
+              remote_state_json: remoteStateJson,
+              created_at: createdAt,
+              updated_at: updatedAt
+            });
+            return { lastInsertRowid: items.length };
+          }
+        };
+      }
+
+      if (sql.includes("DELETE FROM agents WHERE id = ?")) {
+        return {
+          run: (id) => {
+            const index = items.findIndex((item) => item.id === id);
+            if (index >= 0) {
+              items.splice(index, 1);
+            }
+            return { changes: index >= 0 ? 1 : 0 };
+          }
+        };
+      }
+
+      if (sql.includes("UPDATE agents") && sql.includes("SET agent_name = ?, status = ?, remote_state_json = ?, updated_at = ?")) {
+        return {
+          run: (agentName, status, remoteStateJson, updatedAt, id) => {
+            const target = items.find((item) => item.id === id);
+            if (target) {
+              target.agent_name = agentName;
+              target.status = status;
+              target.remote_state_json = remoteStateJson;
+              target.updated_at = updatedAt;
+            }
+            statements.push({ type: "run", sql, args: [agentName, status, remoteStateJson, updatedAt, id] });
+            return { changes: target ? 1 : 0 };
+          }
+        };
+      }
+
+      return {
+        all: () => [],
+        get: () => null,
+        run: () => ({ changes: 0, lastInsertRowid: 1 })
+      };
+    }
+  };
+}
+
+it("refreshes local agent status through agent.list", async () => {
+  const db = createDb([{
+    id: 1,
+    slug: "agent-a",
+    agent_name: "Agent A",
+    status: "normal",
+    remote_state_json: "{}"
+  }]);
+  const rpcCalls = [];
+  const service = new AgentStatusSyncService({
+    db,
+    rpcClient: {
+      isConfigured() {
+        return true;
+      },
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        return {
+          items: [{
+            agentId: "agent-a",
+            name: "Agent A",
+            status: "active",
+            inboundTopic: "topic/in/agent-a",
+            outboundTopic: "topic/out/agent-a"
+          }]
+        };
+      }
+    },
+    auditLogService: {
+      write() {}
+    }
+  });
+
+  const result = await service.refreshStatuses({ trigger: "scheduled" });
+
+  expect(result.status).toBe("success");
+  expect(result.updated_agents).toBe(1);
+  expect(rpcCalls).toEqual([{
+    action: "agent.list",
+    params: {}
+  }]);
+  expect(db.items[0].status).toBe("normal");
+});
+
+it("keeps local agents when status sync does not see them remotely", async () => {
+  const db = createDb([{
+    id: 1,
+    slug: "agent-a",
+    agent_name: "Agent A",
+    status: "normal",
+    remote_state_json: "{}"
+  }]);
+  const service = new AgentStatusSyncService({
+    db,
+    rpcClient: {
+      isConfigured() {
+        return true;
+      },
+      async call() {
+        return {
+          items: []
+        };
+      }
+    },
+    auditLogService: {
+      write() {}
+    }
+  });
+
+  const result = await service.refreshStatuses({ trigger: "scheduled" });
+
+  expect(result.status).toBe("success");
+  expect(result.updated_agents).toBe(0);
+  expect(db.items.map((item) => item.slug)).toEqual(["agent-a"]);
+});

package/server/test/agent-update-audit.test.js

@@ -0,0 +1,63 @@
+const { buildAgentUpdateAudit } = await import("../src/api/routes/index.js");
+
+function makeAgent(overrides = {}) {
+  return {
+    id: 1,
+    slug: "agent-a",
+    agent_name: "Agent A",
+    status: "active",
+    daily_limit: -1,
+    permissions: [
+      { username: "zhangsan" },
+      { username: "lisi" }
+    ],
+    ...overrides
+  };
+}
+
+it("writes assignment-specific audit details with added and removed users", () => {
+  const audit = buildAgentUpdateAudit(makeAgent(), makeAgent({
+    permissions: [
+      { username: "lisi" },
+      { username: "wangwu" }
+    ]
+  }), {
+    permission_usernames: ["lisi", "wangwu"]
+  });
+
+  expect(audit).toEqual({
+    action: "编辑数字员工人员分配",
+    detail: "编辑数字员工人员分配：ID=1，名称=agent-a；添加：wangwu；移除：zhangsan"
+  });
+});
+
+it("keeps agent-edit audit action when only base agent fields change", () => {
+  const audit = buildAgentUpdateAudit(makeAgent(), makeAgent({
+    agent_name: "Agent A Updated"
+  }), {
+    agent_name: "Agent A Updated"
+  });
+
+  expect(audit).toEqual({
+    action: "编辑数字员工",
+    detail: "编辑数字员工：ID=1，名称=agent-a"
+  });
+});
+
+it("includes assignment diff when base agent fields and assignments change together", () => {
+  const audit = buildAgentUpdateAudit(makeAgent(), makeAgent({
+    agent_name: "Agent A Updated",
+    permissions: [
+      { username: "lisi" },
+      { username: "wangwu" }
+    ]
+  }), {
+    agent_name: "Agent A Updated",
+    permission_usernames: ["lisi", "wangwu"]
+  });
+
+  expect(audit).toEqual({
+    action: "编辑数字员工",
+    detail: "编辑数字员工：ID=1，名称=agent-a；人员分配添加：wangwu；人员分配移除：zhangsan"
+  });
+});

package/server/test/auth-middleware.test.js

@@ -0,0 +1,71 @@
+import { createAuthMiddleware } from "../src/api/middleware/auth.js";
+
+function runMiddleware(middleware, { headers = {}, remoteAddress = "" } = {}) {
+  return new Promise((resolve) => {
+    const req = {
+      headers,
+      socket: {
+        remoteAddress
+      }
+    };
+
+    middleware(req, {}, (error) => resolve({
+      error: error ?? null,
+      req
+    }));
+  });
+}
+
+it("injects local api user for localhost requests", async () => {
+  const middleware = createAuthMiddleware({
+    getLocalApiUser() {
+      return {
+        id: 1,
+        username: "aios",
+        role: "aios-admin"
+      };
+    },
+    getSessionUser() {
+      throw new Error("should not call token auth on localhost");
+    }
+  });
+
+  const result = await runMiddleware(middleware, {
+    remoteAddress: "127.0.0.1"
+  });
+
+  expect(result.error).toBeNull();
+  expect(result.req.authToken).toBe("localhost");
+  expect(result.req.currentUser).toEqual({
+    id: 1,
+    username: "aios",
+    role: "aios-admin"
+  });
+});
+
+it("requires bearer token for non-localhost requests", async () => {
+  const middleware = createAuthMiddleware({
+    getLocalApiUser() {
+      return null;
+    },
+    getSessionUser() {
+      return {
+        id: 1
+      };
+    }
+  });
+
+  const missing = await runMiddleware(middleware, {
+    remoteAddress: "10.0.0.8"
+  });
+  expect(missing.error.status).toBe(401);
+
+  const ok = await runMiddleware(middleware, {
+    remoteAddress: "10.0.0.8",
+    headers: {
+      authorization: "Bearer token-1"
+    }
+  });
+  expect(ok.error).toBeNull();
+  expect(ok.req.authToken).toBe("token-1");
+});

package/server/test/background-services.test.js

@@ -0,0 +1,160 @@
+import { startBackgroundServices } from "../src/background/index.js";
+
+it("runs startup sync and schedules the global one-minute task clock", async () => {
+  const timeouts = [];
+  const intervals = [];
+  const originalSetTimeout = globalThis.setTimeout;
+  const originalClearTimeout = globalThis.clearTimeout;
+  const originalSetInterval = globalThis.setInterval;
+  const originalClearInterval = globalThis.clearInterval;
+  globalThis.setTimeout = ((fn, delay) => {
+    const handle = { fn, delay };
+    timeouts.push(handle);
+    return handle;
+  });
+  globalThis.clearTimeout = (() => {});
+  globalThis.setInterval = ((fn, delay) => {
+    const handle = { fn, delay };
+    intervals.push(handle);
+    return handle;
+  });
+  globalThis.clearInterval = (() => {});
+
+  const calls = [];
+  const startupResolvers = [];
+  const createStartupTask = (label) => async ({ trigger }) => {
+    calls.push(`${label}:${trigger}`);
+    if (trigger !== "startup") {
+      return { status: "success" };
+    }
+
+    await new Promise((resolve) => {
+      startupResolvers.push(resolve);
+    });
+    return { status: "success" };
+  };
+  const background = startBackgroundServices({
+    env: {
+      mqtt: {}
+    },
+    services: {
+      rpcClient: {
+        async start() {
+          calls.push("rpc.start");
+        },
+        async stop() {
+          calls.push("rpc.stop");
+        }
+      },
+      catalogSyncService: {
+        syncAgentsTask: createStartupTask("sync-agents"),
+        syncSkillsTask: createStartupTask("sync-skills"),
+        syncTemplatesTask: createStartupTask("sync-templates"),
+        syncSystemsTask: createStartupTask("sync-systems"),
+        refreshAgentUsage: createStartupTask("usage")
+      },
+      agentStatusSyncService: {},
+      systemService: {},
+      hzgProviderClient: {}
+    }
+  });
+
+  try {
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(calls).toContain("rpc.start");
+    expect(calls.filter((entry) => entry.endsWith(":startup"))).toEqual([
+      "sync-agents:startup"
+    ]);
+    expect(startupResolvers.length).toBe(1);
+    expect(intervals.length).toBe(0);
+
+    for (const resolve of startupResolvers) {
+      resolve();
+    }
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+    expect(calls.filter((entry) => entry.endsWith(":startup"))).toEqual([
+      "sync-agents:startup",
+      "usage:startup"
+    ]);
+
+    for (const resolve of startupResolvers.slice(1)) {
+      resolve();
+    }
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+    for (const resolve of startupResolvers.slice(2)) {
+      resolve();
+    }
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+    for (const resolve of startupResolvers.slice(3)) {
+      resolve();
+    }
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+    for (const resolve of startupResolvers.slice(4)) {
+      resolve();
+    }
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(calls.filter((entry) => entry.endsWith(":startup"))).toEqual([
+      "sync-agents:startup",
+      "usage:startup",
+      "sync-skills:startup",
+      "sync-templates:startup",
+      "sync-systems:startup"
+    ]);
+
+    expect(timeouts.length).toBe(1);
+    expect(timeouts[0].delay).toBe(5 * 60 * 1000);
+    expect(intervals.length).toBe(0);
+
+    const startupScheduler = timeouts[0];
+    await startupScheduler.fn();
+
+    expect(intervals.length).toBe(1);
+    expect(intervals[0].delay).toBe(60 * 1000);
+
+    const firstScheduledCalls = calls.filter((entry) => [
+      "usage:scheduled",
+      "sync-agents:scheduled",
+      "sync-skills:scheduled",
+      "sync-templates:scheduled",
+      "sync-systems:scheduled"
+    ].includes(entry));
+    expect(firstScheduledCalls).toEqual([
+      "sync-agents:scheduled"
+    ]);
+
+    const scheduler = intervals[0];
+    await scheduler.fn();
+    await scheduler.fn();
+    await scheduler.fn();
+    await scheduler.fn();
+
+    const scheduledCalls = calls.filter((entry) => [
+      "usage:scheduled",
+      "sync-agents:scheduled",
+      "sync-skills:scheduled",
+      "sync-templates:scheduled",
+      "sync-systems:scheduled"
+    ].includes(entry));
+    expect(scheduledCalls).toEqual([
+      "sync-agents:scheduled",
+      "usage:scheduled",
+      "sync-skills:scheduled",
+      "sync-templates:scheduled",
+      "sync-systems:scheduled"
+    ]);
+  } finally {
+    await background.stop();
+    globalThis.setTimeout = originalSetTimeout;
+    globalThis.clearTimeout = originalClearTimeout;
+    globalThis.setInterval = originalSetInterval;
+    globalThis.clearInterval = originalClearInterval;
+  }
+});