aios-management-web 0.1.0

package/server/test/agent-service-create.test.js

@@ -0,0 +1,662 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "aios-web-agent-create-test-"));
+process.env.AIOS_WEB_DATA_DIR = dataDir;
+const { AgentService } = await import("../src/services/agent-service.js");
+
+function createDb({ failAgentInsert = false } = {}) {
+  const insertedRows = [];
+  const permissions = [];
+  const aiosUsers = new Map([
+    ["zhangsan", { id: 11, username: "zhangsan" }],
+    ["lisi", { id: 12, username: "lisi" }]
+  ]);
+  const skills = new Map();
+
+  return {
+    insertedRows,
+    permissions,
+    prepare(sql) {
+      if (sql.includes("SELECT 1 FROM agents WHERE slug = ?")) {
+        return {
+          get: () => null
+        };
+      }
+
+      if (sql.includes("SELECT * FROM agents WHERE id = ?")) {
+        return {
+          get: () => ({
+            id: 1,
+            slug: "agent-a",
+            agent_name: "Agent A",
+            description: "demo",
+            docs_content: "",
+            template_name: "default",
+            status: "normal",
+            usage_snapshot_json: "{}",
+            tags_json: "[]",
+            daily_limit: -1
+          })
+        };
+      }
+
+      if (sql.includes("SELECT * FROM agents ORDER BY updated_at DESC")) {
+        return {
+          all: () => insertedRows
+        };
+      }
+
+      if (sql.includes("SELECT d.id, d.username")) {
+        return {
+          all: (agentId) => permissions
+            .filter((item) => item.agent_id === agentId)
+            .map((item) => [...aiosUsers.values()].find((user) => user.id === item.aios_user_id))
+            .filter(Boolean)
+        };
+      }
+
+      if (sql.includes("SELECT s.slug")) {
+        return {
+          all: () => []
+        };
+      }
+
+      if (sql.includes("INSERT INTO aios_users")) {
+        return {
+          run: (username) => {
+            if (!aiosUsers.has(username)) {
+              aiosUsers.set(username, { id: aiosUsers.size + 11, username });
+            }
+            return { changes: 1 };
+          }
+        };
+      }
+
+      if (sql.includes("SELECT id") && sql.includes("FROM aios_users")) {
+        return {
+          get: (username) => {
+            const user = aiosUsers.get(username);
+            return user ? { id: user.id } : null;
+          },
+          all: () => [...aiosUsers.values()]
+        };
+      }
+
+      if (sql.includes("DELETE FROM agent_permissions WHERE agent_id = ?")) {
+        return {
+          run: (agentId) => {
+            for (let index = permissions.length - 1; index >= 0; index -= 1) {
+              if (permissions[index].agent_id === agentId) {
+                permissions.splice(index, 1);
+              }
+            }
+            return { changes: 1 };
+          }
+        };
+      }
+
+      if (sql.includes("INSERT INTO agent_permissions (agent_id, aios_user_id)")) {
+        return {
+          run: (agentId, aiosUserId) => {
+            const user = [...aiosUsers.values()].find((item) => item.id === aiosUserId);
+            if (user) {
+              permissions.push({
+                agent_id: agentId,
+                aios_user_id: aiosUserId
+              });
+            }
+            return { changes: 1 };
+          }
+        };
+      }
+
+      if (sql.includes("DELETE FROM agent_skill_bindings WHERE agent_id = ?")) {
+        return {
+          run: () => ({ changes: 1 })
+        };
+      }
+
+      if (sql.includes("SELECT id FROM skills WHERE slug = ?")) {
+        return {
+          get: (slug) => skills.get(slug) || null
+        };
+      }
+
+      if (sql.includes("INSERT INTO agent_skill_bindings (agent_id, skill_id)")) {
+        return {
+          run: () => ({ changes: 1 })
+        };
+      }
+
+      if (sql.includes("INSERT INTO agents")) {
+        return {
+          run: (...params) => {
+            if (failAgentInsert) {
+              throw new Error("db insert failed");
+            }
+            insertedRows.splice(0, insertedRows.length, {
+              id: 1,
+              slug: params[0],
+              agent_name: params[1],
+              description: params[2],
+              docs_content: params[3],
+              template_name: params[4],
+              status: params[5],
+              tags_json: params[6],
+              daily_limit: params[7],
+              remote_state_json: params[8],
+              created_at: params[9],
+              updated_at: params[10],
+              usage_snapshot_json: "{}"
+            });
+            return { lastInsertRowid: 1 };
+          }
+        };
+      }
+
+      if (sql.includes("UPDATE agents")) {
+        return {
+          run: (...params) => {
+            if (!insertedRows[0]) {
+              insertedRows.push({
+                id: 1,
+                slug: "agent-a",
+                template_name: "default",
+                usage_snapshot_json: "{}",
+                remote_state_json: "{}"
+              });
+            }
+            if (sql.includes("SET agent_name = ?, status = ?, remote_state_json = ?, updated_at = ?")) {
+              insertedRows[0] = {
+                ...insertedRows[0],
+                id: 1,
+                slug: "agent-a",
+                agent_name: params[0],
+                status: params[1],
+                remote_state_json: params[2],
+                updated_at: params[3]
+              };
+              return { changes: 1 };
+            }
+            insertedRows[0] = {
+              ...insertedRows[0],
+              id: 1,
+              slug: "agent-a",
+              agent_name: params[0],
+              description: params[1],
+              docs_content: params[2],
+              status: params[3],
+              tags_json: params[4],
+              daily_limit: params[5],
+              updated_at: params[6]
+            };
+            return { changes: 1 };
+          }
+        };
+      }
+
+      if (sql.includes("DELETE FROM agents WHERE id = ?")) {
+        return {
+          run: (agentId) => {
+            const index = insertedRows.findIndex((item) => Number(item.id) === Number(agentId));
+            if (index >= 0) {
+              insertedRows.splice(index, 1);
+            }
+            return { changes: index >= 0 ? 1 : 0 };
+          }
+        };
+      }
+
+      return {
+        get: () => null,
+        all: () => [],
+        run: () => ({ lastInsertRowid: 1 })
+      };
+    }
+  };
+}
+
+it("rejects model configuration during agent creation", async () => {
+  const rpcCalls = [];
+  const service = new AgentService({
+    db: createDb(),
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        if (action === "agent.get") {
+          return {
+            agentId: "agent-a",
+            name: "Agent A",
+            status: "normal",
+            inboundTopic: "topic/in/agent-a",
+            outboundTopic: "topic/out/agent-a"
+          };
+        }
+        return { ok: true };
+      }
+    },
+    objectStorage: {}
+  });
+
+  await expectAsync(service.createAgent({
+    slug: "agent-a",
+    template_name: "default",
+    model_primary: "gpt-4.1-mini"
+  })).toBeRejectedWithError("当前版本不支持在创建时配置模型");
+
+  expect(rpcCalls).toEqual([]);
+});
+
+it("rejects invalid slug during agent creation", async () => {
+  const service = new AgentService({
+    db: createDb(),
+    rpcClient: {
+      async call() {
+        return { ok: true };
+      }
+    },
+    objectStorage: {}
+  });
+
+  await expectAsync(service.createAgent({
+    slug: "Agent_A",
+    template_name: "default"
+  })).toBeRejectedWithError(/slug 规则/);
+});
+
+it("stores agent_name and synthesized topics during agent creation", async () => {
+  const rpcCalls = [];
+  const db = createDb();
+  const service = new AgentService({
+    db,
+    rpcClient: {
+      isConfigured() {
+        return true;
+      },
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        if (action === "agent.get") {
+          return {
+            agentId: "agent-a",
+            name: "Agent A",
+            status: "normal",
+            inboundTopic: "topic/in/agent-a",
+            outboundTopic: "topic/out/agent-a"
+          };
+        }
+        return { ok: true };
+      }
+    },
+    objectStorage: {},
+    env: {
+      mqtt: {
+        agentInboundTopicTemplate: "topic/in/{agentId}",
+        agentOutboundTopicTemplate: "topic/out/{agentId}"
+      }
+    }
+  });
+
+  const created = await service.createAgent({
+    slug: "agent-a",
+    agent_name: "Agent A",
+    template_name: "default"
+  });
+
+  expect(created.status).toBe("normal");
+  expect(created.health).toBe("normal");
+  expect(created.agent_name).toBe("Agent A");
+  expect(db.insertedRows[0]?.status).toBe("normal");
+  expect(created.remote_state).toEqual({
+    agentId: "agent-a",
+    name: "Agent A",
+    inboundTopic: "topic/in/agent-a",
+    outboundTopic: "topic/out/agent-a",
+  });
+  expect(rpcCalls.map((item) => item.action)).toEqual(["agent.create"]);
+  expect(rpcCalls[0].params).toEqual(jasmine.objectContaining({
+    agentId: "agent-a",
+    name: "Agent A",
+    agentName: "Agent A",
+    templateName: "default",
+    restart: true
+  }));
+});
+
+it("does not insert the agent before agent.create succeeds", async () => {
+  const db = createDb();
+  const observedInsertedRowCounts = [];
+  const service = new AgentService({
+    db,
+    rpcClient: {
+      async call(action) {
+        if (action === "agent.create") {
+          observedInsertedRowCounts.push(db.insertedRows.length);
+        }
+        return { ok: true };
+      }
+    },
+    objectStorage: {},
+    env: {
+      mqtt: {
+        agentInboundTopicTemplate: "topic/in/{agentId}",
+        agentOutboundTopicTemplate: "topic/out/{agentId}"
+      }
+    }
+  });
+
+  const created = await service.createAgent({
+    slug: "agent-a",
+    agent_name: "Agent A",
+    template_name: "default"
+  });
+
+  expect(created.slug).toBe("agent-a");
+  expect(created.status).toBe("normal");
+  expect(observedInsertedRowCounts).toEqual([0]);
+  expect(db.insertedRows.length).toBe(1);
+});
+
+it("creates agent-user bindings from users field", async () => {
+  const db = createDb();
+  const service = new AgentService({
+    db,
+    rpcClient: {
+      async call() {
+        return { ok: true };
+      }
+    },
+    objectStorage: {},
+    env: {
+      mqtt: {
+        agentInboundTopicTemplate: "topic/in/{agentId}",
+        agentOutboundTopicTemplate: "topic/out/{agentId}"
+      }
+    }
+  });
+
+  const created = await service.createAgent({
+    slug: "agent-a",
+    template_name: "default",
+    users: ["zhangsan", "lisi"]
+  });
+
+  expect(created.permissions).toEqual([
+    { id: 11, username: "zhangsan" },
+    { id: 12, username: "lisi" }
+  ]);
+});
+
+it("does not insert a local agent record when agent.create fails", async () => {
+  const db = createDb();
+  const service = new AgentService({
+    db,
+    rpcClient: {
+      async call(action) {
+        if (action === "agent.create") {
+          throw new Error("create failed");
+        }
+        return { ok: true };
+      }
+    },
+    objectStorage: {},
+    env: {
+      mqtt: {
+        agentInboundTopicTemplate: "topic/in/{agentId}",
+        agentOutboundTopicTemplate: "topic/out/{agentId}"
+      }
+    }
+  });
+
+  await expectAsync(service.createAgent({
+    slug: "agent-a",
+    agent_name: "Agent A",
+    template_name: "default"
+  })).toBeRejectedWithError("create failed");
+
+  expect(db.insertedRows).toEqual([]);
+});
+
+it("does not insert a local agent record when agent.create times out", async () => {
+  const db = createDb();
+  const service = new AgentService({
+    db,
+    rpcClient: {
+      async call(action) {
+        if (action === "agent.create") {
+          const error = new Error("管理动作超时：agent.create");
+          error.details = { timeout: true, action };
+          throw error;
+        }
+        return { ok: true };
+      }
+    },
+    objectStorage: {},
+    env: {
+      mqtt: {
+        agentInboundTopicTemplate: "topic/in/{agentId}",
+        agentOutboundTopicTemplate: "topic/out/{agentId}"
+      }
+    }
+  });
+
+  await expectAsync(service.createAgent({
+    slug: "agent-a",
+    agent_name: "Agent A",
+    template_name: "default"
+  })).toBeRejectedWithError("管理动作超时：agent.create");
+
+  expect(db.insertedRows).toEqual([]);
+});
+
+it("deletes remote agent when docs update fails before local insert", async () => {
+  const db = createDb();
+  const rpcCalls = [];
+  const service = new AgentService({
+    db,
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        if (action === "agent.docs.update") {
+          throw new Error("docs failed");
+        }
+        return { ok: true };
+      }
+    },
+    objectStorage: {},
+    env: {
+      mqtt: {
+        agentInboundTopicTemplate: "topic/in/{agentId}",
+        agentOutboundTopicTemplate: "topic/out/{agentId}"
+      }
+    }
+  });
+
+  await expectAsync(service.createAgent({
+    slug: "agent-a",
+    agent_name: "Agent A",
+    template_name: "default",
+    docs_content: "hello"
+  })).toBeRejectedWithError("docs failed");
+
+  expect(db.insertedRows).toEqual([]);
+  expect(rpcCalls.map((item) => item.action)).toEqual([
+    "agent.create",
+    "agent.docs.update",
+    "agent.delete"
+  ]);
+  expect(rpcCalls[2].params).toEqual({
+    agentId: "agent-a",
+    restart: true
+  });
+});
+
+it("deletes remote agent when local insert fails after agent.create succeeds", async () => {
+  const db = createDb({ failAgentInsert: true });
+  const rpcCalls = [];
+  const service = new AgentService({
+    db,
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        return { ok: true };
+      }
+    },
+    objectStorage: {},
+    env: {
+      mqtt: {
+        agentInboundTopicTemplate: "topic/in/{agentId}",
+        agentOutboundTopicTemplate: "topic/out/{agentId}"
+      }
+    }
+  });
+
+  await expectAsync(service.createAgent({
+    slug: "agent-a",
+    agent_name: "Agent A",
+    template_name: "default"
+  })).toBeRejectedWithError("db insert failed");
+
+  expect(db.insertedRows).toEqual([]);
+  expect(rpcCalls.map((item) => item.action)).toEqual([
+    "agent.create",
+    "agent.delete"
+  ]);
+  expect(rpcCalls[1].params).toEqual({
+    agentId: "agent-a",
+    restart: true
+  });
+});
+
+it("rejects model configuration during agent update", async () => {
+  const rpcCalls = [];
+  const service = new AgentService({
+    db: createDb(),
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        return { ok: true };
+      }
+    },
+    objectStorage: {}
+  });
+
+  await expectAsync(service.updateAgent(1, {
+    model_primary: "gpt-4.1-mini"
+  })).toBeRejectedWithError("当前版本不支持在编辑时配置模型");
+
+  expect(rpcCalls).toEqual([]);
+});
+
+it("updates agent-user bindings from users field", async () => {
+  const db = createDb();
+  db.permissions.push({
+    agent_id: 1,
+    aios_user_id: 11
+  });
+
+  const service = new AgentService({
+    db,
+    rpcClient: {
+      async call() {
+        return { ok: true };
+      }
+    },
+    objectStorage: {}
+  });
+
+  const updated = await service.updateAgent(1, {
+    users: ["lisi"]
+  });
+
+  expect(updated.permissions).toEqual([
+    { id: 12, username: "lisi" }
+  ]);
+});
+
+it("keeps agent-user bindings when update payload omits assignment fields", async () => {
+  const db = createDb();
+  db.permissions.push({
+    agent_id: 1,
+    aios_user_id: 11
+  });
+
+  const service = new AgentService({
+    db,
+    rpcClient: {
+      async call() {
+        return { ok: true };
+      }
+    },
+    objectStorage: {}
+  });
+
+  const updated = await service.updateAgent(1, {
+    agent_name: "Agent A Updated"
+  });
+
+  expect(updated.agent_name).toBe("Agent A Updated");
+  expect(updated.permissions).toEqual([
+    { id: 11, username: "zhangsan" }
+  ]);
+});
+
+it("deletes local record when remote agent is already missing", async () => {
+  const db = createDb();
+  db.insertedRows.push({
+    id: 1,
+    slug: "agent-a",
+    agent_name: "Agent A",
+    description: "",
+    docs_content: "",
+    template_name: "default",
+    status: "normal",
+    tags_json: "[]",
+    daily_limit: -1,
+    usage_snapshot_json: "{}",
+    remote_state_json: "{}",
+    created_at: "2026-05-26T00:00:00.000Z",
+    updated_at: "2026-05-26T00:00:00.000Z"
+  });
+
+  const service = new AgentService({
+    db,
+    rpcClient: {
+      async call(action) {
+        if (action === "agent.delete") {
+          const error = new Error("agent not found: agent-a");
+          error.status = 404;
+          error.code = "not_found";
+          throw error;
+        }
+        return { ok: true };
+      }
+    },
+    objectStorage: {}
+  });
+
+  const result = await service.deleteAgent(1);
+
+  expect(result).toEqual({ ok: true });
+  expect(db.insertedRows).toEqual([]);
+});
+
+it("imports AIOS users from newline separated content", () => {
+  const db = createDb();
+  const service = new AgentService({
+    db,
+    rpcClient: {},
+    objectStorage: {}
+  });
+
+  const result = service.importAiosUsers("zhangsan\nwangwu\nzhaoliu\n");
+
+  expect(result.total).toBe(3);
+  expect(result.created).toBe(2);
+  expect(result.items).toEqual([
+    { username: "zhangsan", existed: true },
+    { username: "wangwu", existed: false },
+    { username: "zhaoliu", existed: false }
+  ]);
+});