aios-management-web 0.1.0

package/server/test/kernel-reset-service.test.js

@@ -0,0 +1,112 @@
+import { KernelResetService } from "../src/services/kernel-reset-service.js";
+
+it("resets kernel in agent-ontology-template order", async () => {
+  const calls = [];
+  const service = new KernelResetService({
+    rpcClient: {
+      async call(action, params) {
+        calls.push({ action, params });
+
+        if (action === "agent.list") {
+          return {
+            items: [
+              { agentId: "agent-a" },
+              { agentId: "agent-b" }
+            ]
+          };
+        }
+
+        if (action === "ontology.list") {
+          return {
+            items: [
+              { name: "crm" },
+              { name: "builtin-crm", "is-built-in": true }
+            ]
+          };
+        }
+
+        if (action === "agent.template.list") {
+          return {
+            items: [
+              { templateName: "default" },
+              { templateName: "sales" },
+              { templateName: "builtin-template", "is-built-in": true }
+            ]
+          };
+        }
+
+        return {};
+      }
+    }
+  });
+
+  const result = await service.resetKernel();
+
+  expect(result).toEqual({
+    deletedAgents: ["agent-a", "agent-b"],
+    deletedOntologies: ["crm"],
+    deletedTemplates: ["default", "sales"],
+    dryRun: false
+  });
+  expect(calls).toEqual([
+    { action: "agent.list", params: {} },
+    { action: "ontology.list", params: {} },
+    { action: "agent.template.list", params: {} },
+    { action: "agent.delete", params: { agentId: "agent-a" } },
+    { action: "agent.delete", params: { agentId: "agent-b" } },
+    { action: "apps.delete", params: { systemId: "crm" } },
+    { action: "agent.template.delete", params: { templateName: "default" } },
+    { action: "agent.template.delete", params: { templateName: "sales" } }
+  ]);
+});
+
+it("supports dry-run without executing delete commands", async () => {
+  const calls = [];
+  const service = new KernelResetService({
+    rpcClient: {
+      async call(action, params) {
+        calls.push({ action, params });
+
+        if (action === "agent.list") {
+          return {
+            items: [{ agentId: "agent-a" }]
+          };
+        }
+
+        if (action === "ontology.list") {
+          return {
+            items: [
+              { name: "crm" },
+              { name: "builtin-crm", "is-built-in": true }
+            ]
+          };
+        }
+
+        if (action === "agent.template.list") {
+          return {
+            items: [
+              { templateName: "default" },
+              { templateName: "builtin-template", "is-built-in": true }
+            ]
+          };
+        }
+
+        throw new Error(`Unexpected action: ${action}`);
+      }
+    }
+  });
+
+  const result = await service.resetKernel({ dryRun: true });
+
+  expect(result).toEqual({
+    deletedAgents: ["agent-a"],
+    deletedOntologies: ["crm"],
+    deletedTemplates: ["default"],
+    dryRun: true
+  });
+  expect(calls).toEqual([
+    { action: "agent.list", params: {} },
+    { action: "ontology.list", params: {} },
+    { action: "agent.template.list", params: {} }
+  ]);
+});

package/server/test/management-rpc-client.test.js

@@ -0,0 +1,105 @@
+import { ManagementRpcClient } from "../src/infra/mqtt/management-rpc-client.js";
+import { createFakeDb, createFakeMqttFactory } from "../fakes.js";
+
+it("publishes a request and resolves the matching response", async () => {
+  const env = {
+    mqtt: {
+      brokerUrl: "mqtt://broker",
+      username: "user",
+      password: "pass",
+      adminInboundTopic: "admin/in",
+      adminOutboundTopic: "admin/out"
+    }
+  };
+  const db = createFakeDb();
+  const mqttFactory = createFakeMqttFactory();
+  const rpcClient = new ManagementRpcClient({ env, db, mqttFactory });
+
+  await rpcClient.start();
+  const client = mqttFactory.clients[0];
+
+  const pending = rpcClient.call("agent.list", { includeDisabled: true }, 1000);
+  const published = client.publishes[0];
+  const request = JSON.parse(published.payload);
+
+  client.emit(
+    "message",
+    env.mqtt.adminOutboundTopic,
+    Buffer.from(
+      JSON.stringify({
+        requestId: request.requestId,
+        ok: true,
+        result: { items: [{ agentId: "alpha" }] }
+      })
+    )
+  );
+
+  await expectAsync(pending).toBeResolved();
+  expect(await pending).toEqual({ items: [{ agentId: "alpha" }] });
+  expect(db.statements.some((item) => item.sql.includes("INSERT INTO management_requests"))).toBeTrue();
+  expect(db.statements.some((item) => item.sql.includes("UPDATE management_requests"))).toBeTrue();
+
+  await rpcClient.stop();
+});
+
+it("marks timed out requests as failed", async () => {
+  const env = {
+    mqtt: {
+      brokerUrl: "mqtt://broker",
+      adminInboundTopic: "admin/in",
+      adminOutboundTopic: "admin/out"
+    }
+  };
+  const db = createFakeDb();
+  const mqttFactory = createFakeMqttFactory();
+  const rpcClient = new ManagementRpcClient({ env, db, mqttFactory });
+
+  await rpcClient.start();
+
+  try {
+    await rpcClient.call("agent.usage", { agentId: "alpha" }, 10);
+    fail("Expected call to time out");
+  } catch (error) {
+    expect(error.message).toContain("超时");
+    expect(error.details).toEqual(jasmine.objectContaining({
+      timeout: true,
+      action: "agent.usage"
+    }));
+  }
+
+  const failureUpdate = db.statements.find((item) => item.sql.includes("UPDATE management_requests"));
+  expect(failureUpdate).toBeDefined();
+  const [errorJson] = failureUpdate.args;
+  expect(JSON.parse(errorJson).message).toContain("超时");
+
+  await rpcClient.stop();
+});
+
+it("uses management timeout from env by default", async () => {
+  const env = {
+    managementTimeoutMs: 10,
+    mqtt: {
+      brokerUrl: "mqtt://broker",
+      adminInboundTopic: "admin/in",
+      adminOutboundTopic: "admin/out"
+    }
+  };
+  const db = createFakeDb();
+  const mqttFactory = createFakeMqttFactory();
+  const rpcClient = new ManagementRpcClient({ env, db, mqttFactory });
+
+  await rpcClient.start();
+
+  try {
+    await rpcClient.call("agent.list", { includeDisabled: true });
+    fail("Expected call to time out");
+  } catch (error) {
+    expect(error.message).toContain("超时");
+    expect(error.details).toEqual(jasmine.objectContaining({
+      timeout: true,
+      action: "agent.list"
+    }));
+  }
+
+  await rpcClient.stop();
+});

package/server/test/portal-service-access-tokens.test.js

@@ -0,0 +1,121 @@
+import { PortalService } from "../src/services/portal-service.js";
+
+function createDb({ count = 1, exists = true } = {}) {
+  const rows = new Map();
+  const deleted = [];
+  const inserted = [];
+
+  return {
+    deleted,
+    inserted,
+    prepare(sql) {
+      if (sql.includes("SELECT token, created_at, updated_at") && sql.includes("FROM access_tokens") && sql.includes("WHERE token = ?")) {
+        return {
+          get(token) {
+            return rows.get(token) || null;
+          }
+        };
+      }
+
+      if (sql.includes("SELECT token FROM access_tokens WHERE token = ?")) {
+        return {
+          get(token) {
+            return exists || rows.has(token) ? { token } : null;
+          }
+        };
+      }
+
+      if (sql.includes("SELECT COUNT(*) AS count FROM access_tokens")) {
+        return {
+          get() {
+            return { count };
+          }
+        };
+      }
+
+      if (sql.includes("INSERT INTO access_tokens")) {
+        return {
+          run(token, createdAt, updatedAt) {
+            const row = { token, created_at: createdAt, updated_at: updatedAt };
+            rows.set(token, row);
+            inserted.push(row);
+            return {};
+          }
+        };
+      }
+
+      if (sql.includes("DELETE FROM access_tokens WHERE token = ?")) {
+        return {
+          run(token) {
+            deleted.push(token);
+            rows.delete(token);
+            return {};
+          }
+        };
+      }
+
+      if (sql.includes("SELECT token, created_at, updated_at") && sql.includes("FROM access_tokens")) {
+        return {
+          all() {
+            return Array.from(rows.values());
+          }
+        };
+      }
+
+      return {
+        get() {
+          return null;
+        },
+        all() {
+          return [];
+        },
+        run() {
+          return {};
+        }
+      };
+    }
+  };
+}
+
+it("creates a random access token in database", () => {
+  const db = createDb({ exists: false });
+  const service = new PortalService({
+    db,
+    objectStorage: {},
+    rpcClient: {},
+    authService: {}
+  });
+
+  const created = service.createAccessToken();
+
+  expect(created.token.startsWith("sk-")).toBeTrue();
+  expect(db.inserted.length).toBe(1);
+  expect(db.inserted[0].token).toBe(created.token);
+});
+
+it("deletes an access token when more than one token remains", () => {
+  const db = createDb({ count: 2, exists: true });
+  const service = new PortalService({
+    db,
+    objectStorage: {},
+    rpcClient: {},
+    authService: {}
+  });
+
+  const result = service.deleteAccessToken("sk-demo");
+
+  expect(result).toEqual({ ok: true });
+  expect(db.deleted).toEqual(["sk-demo"]);
+});
+
+it("rejects deleting the last access token", () => {
+  const db = createDb({ count: 1, exists: true });
+  const service = new PortalService({
+    db,
+    objectStorage: {},
+    rpcClient: {},
+    authService: {}
+  });
+
+  expect(() => service.deleteAccessToken("sk-demo")).toThrowError("至少需要保留一个访问令牌");
+});

package/server/test/portal-service-alignment.test.js

@@ -0,0 +1,318 @@
+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-portal-test-"));
+process.env.AIOS_WEB_DATA_DIR = dataDir;
+const { PortalService } = await import("../src/services/portal-service.js");
+
+function createDb() {
+  const statements = [];
+  return {
+    statements,
+    prepare(sql) {
+      return {
+        run: (...args) => {
+          statements.push({ sql, args });
+          return { lastInsertRowid: 1 };
+        },
+        get: () => null,
+        all: () => []
+      };
+    }
+  };
+}
+
+it("returns dashboard placeholders before agent and usage startup sync complete", () => {
+  const scalarValues = new Map([
+    ["SELECT status, last_success_at FROM agent_sync_state WHERE id = 1", { status: "running", last_success_at: null }],
+    ["SELECT status, last_success_at FROM usage_refresh_state WHERE id = 1", { status: "idle", last_success_at: null }],
+    ["SELECT COUNT(*) AS count FROM agents", { count: 0 }],
+    ["SELECT COUNT(*) AS count FROM agent_templates", { count: 2 }],
+    ["SELECT COUNT(*) AS count FROM skills", { count: 3 }],
+    ["SELECT COUNT(*) AS count FROM business_systems", { count: 4 }],
+    ["SELECT COALESCE(SUM(COALESCE(json_extract(usage_snapshot_json, '$.usage.daily'), 0)), 0) AS total FROM agents", { total: 0 }]
+  ]);
+  const db = {
+    prepare(sql) {
+      const normalized = sql.replace(/\s+/g, " ").trim();
+      return {
+        get: () => scalarValues.get(normalized) || null,
+        all: () => [],
+        run: () => ({ lastInsertRowid: 1 })
+      };
+    }
+  };
+  const service = new PortalService({
+    db,
+    objectStorage: {},
+    rpcClient: {},
+    authService: {}
+  });
+
+  const dashboard = service.getDashboard();
+
+  expect(dashboard.stats).toEqual({
+    agents: null,
+    templates: 2,
+    skills: 3,
+    systems: 4,
+    today_tokens: null
+  });
+});
+
+it("returns dashboard metrics after agent and usage startup sync complete", () => {
+  const scalarValues = new Map([
+    ["SELECT status, last_success_at FROM agent_sync_state WHERE id = 1", { status: "success", last_success_at: "2026-05-27T08:00:00.000Z" }],
+    ["SELECT status, last_success_at FROM usage_refresh_state WHERE id = 1", { status: "success", last_success_at: "2026-05-27T08:01:00.000Z" }],
+    ["SELECT COUNT(*) AS count FROM agents", { count: 5 }],
+    ["SELECT COUNT(*) AS count FROM agent_templates", { count: 2 }],
+    ["SELECT COUNT(*) AS count FROM skills", { count: 3 }],
+    ["SELECT COUNT(*) AS count FROM business_systems", { count: 4 }],
+    ["SELECT COALESCE(SUM(COALESCE(json_extract(usage_snapshot_json, '$.usage.daily'), 0)), 0) AS total FROM agents", { total: 123 }]
+  ]);
+  const db = {
+    prepare(sql) {
+      const normalized = sql.replace(/\s+/g, " ").trim();
+      return {
+        get: () => scalarValues.get(normalized) || null,
+        all: () => [],
+        run: () => ({ lastInsertRowid: 1 })
+      };
+    }
+  };
+  const service = new PortalService({
+    db,
+    objectStorage: {},
+    rpcClient: {},
+    authService: {}
+  });
+
+  const dashboard = service.getDashboard();
+
+  expect(dashboard.stats).toEqual({
+    agents: 5,
+    templates: 2,
+    skills: 3,
+    systems: 4,
+    today_tokens: 123
+  });
+});
+
+it("requires slug for global skill installation", async () => {
+  const db = createDb();
+  const rpcCalls = [];
+  const service = new PortalService({
+    db,
+    objectStorage: {
+      async uploadAdminArtifact() {
+        return {
+          bucket: "admin-in",
+          objectKey: "skill/demo.zip"
+        };
+      }
+    },
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        return {};
+      }
+    },
+    authService: {}
+  });
+
+  const zipBuffer = Buffer.from("PK\u0005\u0006" + "\u0000".repeat(18), "binary");
+  try {
+    await service.createSkill({
+      payload: {
+        slug: ""
+      },
+      file: {
+        buffer: zipBuffer,
+        originalname: "demo.zip",
+        mimetype: "application/zip",
+        size: zipBuffer.length
+      },
+      createdBy: 1
+    });
+    fail("Expected createSkill to reject");
+  } catch (error) {
+    expect(error.message).toContain("技能ID");
+  }
+  expect(rpcCalls.length).toBe(0);
+});
+
+it("installs uploaded global skill through skills.global.install.local", async () => {
+  const db = createDb();
+  const rpcCalls = [];
+  const service = new PortalService({
+    db,
+    objectStorage: {
+      async uploadAdminArtifact() {
+        return {
+          bucket: "admin-in",
+          objectKey: "skill/demo.zip"
+        };
+      }
+    },
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        return {};
+      }
+    },
+    authService: {}
+  });
+  service.listSkills = () => [{ id: 1 }];
+
+  const zip = new (await import("adm-zip")).default();
+  zip.addFile("SKILL.md", Buffer.from("# Demo Skill\n", "utf8"));
+
+  const result = await service.createSkill({
+    payload: {
+      slug: "skill-a"
+    },
+    file: {
+      buffer: zip.toBuffer(),
+      originalname: "demo.zip",
+      mimetype: "application/zip",
+      size: zip.toBuffer().length
+    },
+    createdBy: 1
+  });
+
+  expect(result).toEqual({ id: 1 });
+  expect(rpcCalls.length).toBe(1);
+  expect(rpcCalls[0].action).toBe("skills.global.install.local");
+  expect(rpcCalls[0].params).toEqual({
+    slug: "skill-a",
+    bucket: "admin-in",
+    objectKey: "skill/demo.zip",
+    force: false
+  });
+});
+
+it("deletes installed global skill through skills.global.delete using skill slug only", async () => {
+  const rpcCalls = [];
+  const db = {
+    prepare(sql) {
+      return {
+        run: () => ({ changes: 1 }),
+        get: () => {
+          if (sql.includes("SELECT * FROM skills WHERE id = ?")) {
+	            return {
+	              id: 1,
+	              slug: "skill-a",
+	              remote_status: "installed"
+	            };
+          }
+          return null;
+        },
+        all: () => []
+      };
+    }
+  };
+  const service = new PortalService({
+    db,
+    objectStorage: {},
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        return {};
+      }
+    },
+    authService: {}
+  });
+
+  const result = await service.deleteSkill(1);
+
+  expect(result).toEqual({ ok: true });
+  expect(rpcCalls).toEqual([{
+    action: "skills.global.delete",
+    params: { slug: "skill-a" }
+  }]);
+});
+
+it("rejects deleting built-in templates", async () => {
+  const rpcCalls = [];
+  const db = {
+    prepare(sql) {
+      return {
+        run: () => ({ changes: 1 }),
+        get: () => {
+          if (sql.includes("SELECT * FROM agent_templates WHERE template_name = ?")) {
+            return {
+              template_name: "default",
+              is_builtin: 1
+            };
+          }
+          return null;
+        },
+        all: () => []
+      };
+    }
+  };
+  const service = new PortalService({
+    db,
+    objectStorage: {},
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        return {};
+      }
+    },
+    authService: {}
+  });
+
+  try {
+    await service.deleteTemplate("default");
+    fail("Expected deleteTemplate to reject");
+  } catch (error) {
+    expect(error.status).toBe(409);
+    expect(error.code).toBe("conflict");
+  }
+  expect(rpcCalls).toEqual([]);
+});
+
+it("rejects deleting built-in global skills", async () => {
+  const rpcCalls = [];
+  const db = {
+    prepare(sql) {
+      return {
+        run: () => ({ changes: 1 }),
+        get: () => {
+          if (sql.includes("SELECT * FROM skills WHERE id = ?")) {
+	            return {
+	              id: 1,
+	              slug: "skill-a",
+	              remote_status: "installed",
+	              is_builtin: 1
+            };
+          }
+          return null;
+        },
+        all: () => []
+      };
+    }
+  };
+  const service = new PortalService({
+    db,
+    objectStorage: {},
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        return {};
+      }
+    },
+    authService: {}
+  });
+
+  try {
+    await service.deleteSkill(1);
+    fail("Expected deleteSkill to reject");
+  } catch (error) {
+    expect(error.status).toBe(409);
+    expect(error.code).toBe("conflict");
+  }
+  expect(rpcCalls).toEqual([]);
+});