aios-management-web 0.1.0

package/server/test/portal-service-management-logs.test.js

@@ -0,0 +1,114 @@
+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(rows) {
+  return {
+    prepare(sql) {
+      return {
+        get() {
+          if (sql.includes("COUNT(*) AS count FROM management_requests")) {
+            return { count: rows.length };
+          }
+          return null;
+        },
+        all(limit, offset) {
+          if (sql.includes("FROM management_requests")) {
+            return rows.slice(offset, offset + limit);
+          }
+          return [];
+        },
+        run() {
+          return { lastInsertRowid: 1 };
+        }
+      };
+    }
+  };
+}
+
+it("lists kernel management requests with parsed payloads and response time", () => {
+  const service = new PortalService({
+    db: createDb([
+      {
+        id: 2,
+        request_id: "req-2",
+        action: "gateway.status",
+        params_json: "{\"verbose\":true}",
+        ok: 1,
+        result_json: "{\"status\":\"ok\"}",
+        error_json: null,
+        created_at: "2026-05-28T01:00:00.000Z",
+        completed_at: "2026-05-28T01:00:01.250Z"
+      },
+      {
+        id: 1,
+        request_id: "req-1",
+        action: "agent.list",
+        params_json: "{}",
+        ok: 0,
+        result_json: null,
+        error_json: "{\"message\":\"failed\"}",
+        created_at: "2026-05-28T00:00:00.000Z",
+        completed_at: "2026-05-28T00:00:00.400Z"
+      }
+    ]),
+    objectStorage: {},
+    rpcClient: {},
+    authService: {}
+  });
+
+  const result = service.listManagementRequests({ page: 1, pageSize: 1 });
+
+  expect(result.total).toBe(2);
+  expect(result.page).toBe(1);
+  expect(result.pageSize).toBe(1);
+  expect(result.items).toEqual([
+    jasmine.objectContaining({
+      request_id: "req-2",
+      action: "gateway.status",
+      ok: true,
+      params: { verbose: true },
+      result: { status: "ok" },
+      error: null,
+      response_time_ms: 1250
+    })
+  ]);
+});
+
+it("keeps pending requests unresolved and returns null duration when incomplete", () => {
+  const service = new PortalService({
+    db: createDb([
+      {
+        id: 3,
+        request_id: "req-pending",
+        action: "diagnostics.run",
+        params_json: "{\"deep\":true}",
+        ok: null,
+        result_json: null,
+        error_json: null,
+        created_at: "2026-05-28T02:00:00.000Z",
+        completed_at: null
+      }
+    ]),
+    objectStorage: {},
+    rpcClient: {},
+    authService: {}
+  });
+
+  const result = service.listManagementRequests();
+
+  expect(result.items).toEqual([
+    jasmine.objectContaining({
+      request_id: "req-pending",
+      ok: null,
+      params: { deep: true },
+      result: null,
+      error: null,
+      response_time_ms: null
+    })
+  ]);
+});

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

@@ -0,0 +1,23 @@
+import { parseResetKernelArgs } from "../../scripts/reset-kernel.js";
+
+it("parses dry-run and confirm flags for kernel reset cli", () => {
+  expect(parseResetKernelArgs([])).toEqual({
+    dryRun: false,
+    confirmed: false
+  });
+
+  expect(parseResetKernelArgs(["--dry-run"])).toEqual({
+    dryRun: true,
+    confirmed: false
+  });
+
+  expect(parseResetKernelArgs(["--confirm-reset"])).toEqual({
+    dryRun: false,
+    confirmed: true
+  });
+
+  expect(parseResetKernelArgs(["--confirm-reset", "--dry-run"])).toEqual({
+    dryRun: true,
+    confirmed: true
+  });
+});

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

@@ -0,0 +1,59 @@
+import { createServiceApiAuthMiddleware } from "../src/api/middleware/internal.js";
+
+function runMiddleware(middleware, { headers = {}, remoteAddress = "" } = {}) {
+  return new Promise((resolve) => {
+    middleware({
+      headers,
+      socket: {
+        remoteAddress
+      }
+    }, {}, (error) => resolve(error ?? null));
+  });
+}
+
+it("bypasses service api auth for localhost requests", async () => {
+  const middleware = createServiceApiAuthMiddleware({
+    hasAccessToken() {
+      return false;
+    }
+  });
+
+  const ipv4Error = await runMiddleware(middleware, {
+    remoteAddress: "127.0.0.1"
+  });
+  expect(ipv4Error).toBeNull();
+
+  const ipv6Error = await runMiddleware(middleware, {
+    remoteAddress: "::1"
+  });
+  expect(ipv6Error).toBeNull();
+});
+
+it("requires bearer token for non-local service api requests", async () => {
+  const middleware = createServiceApiAuthMiddleware({
+    hasAccessToken(token) {
+      return token === "sk-abcdef";
+    }
+  });
+
+  const missingError = await runMiddleware(middleware, {
+    remoteAddress: "10.0.0.8"
+  });
+  expect(missingError.status).toBe(401);
+
+  const invalidError = await runMiddleware(middleware, {
+    remoteAddress: "10.0.0.8",
+    headers: {
+      authorization: "Bearer sk-other"
+    }
+  });
+  expect(invalidError.status).toBe(403);
+
+  const okError = await runMiddleware(middleware, {
+    remoteAddress: "10.0.0.8",
+    headers: {
+      authorization: "Bearer sk-abcdef"
+    }
+  });
+  expect(okError).toBeNull();
+});

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

@@ -0,0 +1,265 @@
+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-system-test-"));
+process.env.AIOS_WEB_DATA_DIR = dataDir;
+const { SystemService } = await import("../src/services/system-service.js");
+
+function createDb({ currentSystem = null, createdSystem = null } = {}) {
+  const statements = [];
+  return {
+    statements,
+    prepare(sql) {
+      return {
+        run: (...args) => {
+          statements.push({ sql, args });
+          return { lastInsertRowid: 1 };
+        },
+        get: (...args) => {
+          if (sql.includes("FROM artifacts")) {
+            return currentSystem?.ontology_artifact_id ? {
+              bucket: "admin-in",
+              object_key: "ontology/existing.zip"
+            } : null;
+          }
+          if (sql.includes("WHERE application_name = ?")) {
+            return null;
+          }
+          if (sql.includes("FROM business_systems s") || sql.includes("SELECT * FROM business_systems WHERE id = ?")) {
+            if (Number(args[0]) === 1 && createdSystem) {
+              return createdSystem;
+            }
+            return currentSystem;
+          }
+          return null;
+        },
+        all: () => []
+      };
+    }
+  };
+}
+
+it("maps website fields to management-service apps.create params", async () => {
+  const createdSystem = {
+    id: 1,
+    provider: "hzg",
+    application_name: "demo-app",
+    description: "desc",
+    ontology_artifact_id: 9,
+    scheme: "https",
+    host: "example.com",
+    port: 443,
+    status: "active",
+    last_connectivity_test_status: "unknown",
+    last_connectivity_test_result_json: "{}",
+    updated_at: "2026-05-27T00:00:00.000Z"
+  };
+  const db = createDb({ createdSystem });
+  const rpcCalls = [];
+  const objectStorage = {
+    async uploadAdminArtifact() {
+      return {
+        bucket: "admin-in",
+        objectKey: "ontology/demo.zip"
+      };
+    }
+  };
+  const service = new SystemService({
+    db,
+    objectStorage,
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        if (action === "apps.list") {
+          return {
+            items: [{
+              id: "demo-app"
+            }]
+          };
+        }
+        return {};
+      }
+    }
+  });
+
+  const zipBuffer = Buffer.from("PK\u0005\u0006" + "\u0000".repeat(18), "binary");
+
+  await expectAsync(service.createSystem({
+    payload: {
+      provider: "hzg",
+      application_name: "demo-app"
+    },
+    file: null,
+    createdBy: 1
+  })).toBeRejectedWithError(/协议/);
+
+  service.persistOntologyArtifact = async () => ({
+    id: 9,
+    bucket: "admin-in",
+    objectKey: "ontology/demo.zip"
+  });
+
+  const result = await service.createSystem({
+    payload: {
+      provider: "hzg",
+      application_name: "demo-app",
+      description: "desc",
+      scheme: "https",
+      host: "example.com",
+      port: 443,
+      status: "active"
+    },
+    file: {
+      buffer: zipBuffer,
+      originalname: "demo.zip",
+      mimetype: "application/zip",
+      size: zipBuffer.length
+    },
+    createdBy: 1
+  });
+
+  expect(result.system.application_name).toBe("demo-app");
+  expect(result.system.base_url).toBe("https://example.com:443/demo-app");
+  expect(result.kernelOntologyDeleted).toBe(true);
+  expect(result.deletedKernelOntologyNames).toEqual(["demo-app"]);
+  expect(rpcCalls.length).toBe(3);
+  expect(rpcCalls[0]).toEqual({
+    action: "apps.list",
+    params: {}
+  });
+  expect(rpcCalls[1]).toEqual({
+    action: "apps.delete",
+    params: {
+      systemId: "demo-app"
+    }
+  });
+  expect(rpcCalls[2].action).toBe("apps.create");
+  expect(rpcCalls[2].params).toEqual({
+    systemId: "demo-app",
+    name: "demo-app",
+    provider: "hzg",
+    ontologyName: "demo-app",
+    description: "desc",
+    applicationEndpoint: "https://example.com:443/demo-app",
+    sessionServiceEndpoint: "https://example.com:443/demo-app",
+    status: "active",
+    bucket: "admin-in",
+    objectKey: "ontology/demo.zip",
+    replaceOntology: true
+  });
+});
+
+it("maps scheme/host/port fields to apps.update params", async () => {
+  const currentSystem = {
+    id: 1,
+    provider: "hzg",
+    application_name: "demo-app",
+    description: "old desc",
+    ontology_artifact_id: 7,
+    scheme: "https",
+    host: "old.example.com",
+    port: 443,
+    status: "disabled"
+  };
+  const updatedSystem = {
+    ...currentSystem,
+    description: "new desc",
+    host: "new.example.com",
+    status: "active"
+  };
+  const db = createDb({ currentSystem, createdSystem: updatedSystem });
+  const rpcCalls = [];
+  const service = new SystemService({
+    db,
+    objectStorage: {},
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        if (action === "apps.list") {
+          return {
+            items: [{
+              id: "demo-app"
+            }]
+          };
+        }
+        return {};
+      }
+    }
+  });
+
+  const result = await service.updateSystem(1, {
+    payload: {
+      description: "new desc",
+      host: "new.example.com",
+      status: "active"
+    },
+    file: null,
+    createdBy: 1
+  });
+
+  expect(result.system.application_name).toBe("demo-app");
+  expect(result.kernelOntologyDeleted).toBe(true);
+  expect(result.deletedKernelOntologyNames).toEqual(["demo-app"]);
+  expect(rpcCalls.length).toBe(3);
+  expect(rpcCalls[0]).toEqual({
+    action: "apps.list",
+    params: {}
+  });
+  expect(rpcCalls[1]).toEqual({
+    action: "apps.delete",
+    params: {
+      systemId: "demo-app"
+    }
+  });
+  expect(rpcCalls[2].action).toBe("apps.create");
+  expect(rpcCalls[2].params).toEqual({
+    systemId: "demo-app",
+    name: "demo-app",
+    provider: "hzg",
+    ontologyName: "demo-app",
+    description: "new desc",
+    applicationEndpoint: "https://new.example.com:443/demo-app",
+    sessionServiceEndpoint: "https://new.example.com:443/demo-app",
+    status: "active",
+    bucket: "admin-in",
+    objectKey: "ontology/existing.zip",
+    replaceOntology: true
+  });
+});
+
+it("rejects deleting built-in ontology systems", async () => {
+  const currentSystem = {
+    id: 1,
+    provider: "hzg",
+    application_name: "demo-app",
+    description: "desc",
+    ontology_artifact_id: 7,
+    scheme: "https",
+    host: "example.com",
+    port: 443,
+    status: "active",
+    is_builtin: 1
+  };
+  const db = createDb({ currentSystem });
+  const rpcCalls = [];
+  const service = new SystemService({
+    db,
+    objectStorage: {},
+    rpcClient: {
+      async call(action, params) {
+        rpcCalls.push({ action, params });
+        return {};
+      }
+    }
+  });
+
+  try {
+    await service.deleteSystem(1);
+    fail("Expected deleteSystem to reject");
+  } catch (error) {
+    expect(error.status).toBe(409);
+    expect(error.code).toBe("conflict");
+  }
+  expect(rpcCalls).toEqual([]);
+});

package/server/test/topic-ping-service.test.js

@@ -0,0 +1,182 @@
+import { EventEmitter } from "node:events";
+
+const { TopicPingService } = await import("../src/services/topic-ping-service.js");
+
+class MockMqttClient extends EventEmitter {
+  constructor() {
+    super();
+    this.subscriptions = [];
+    this.publications = [];
+  }
+
+  subscribe(topic, _options, callback) {
+    this.subscriptions.push(topic);
+    callback?.(null);
+  }
+
+  publish(topic, payload, _options, callback) {
+    this.publications.push({ topic, payload: JSON.parse(payload) });
+    callback?.(null);
+    queueMicrotask(() => {
+      const prompt = this.publications[0].payload.text;
+      const token = (prompt.match(/PONG ([A-Z0-9]+)/i)?.[1] || "").toUpperCase();
+      this.emit("message", this.subscriptions[0], Buffer.from(JSON.stringify({
+        sessionId: this.publications[0].payload.sessionId,
+        kind: "final",
+        text: `PONG ${token}`
+      }), "utf8"));
+    });
+  }
+
+  end(_force, _options, callback) {
+    callback?.();
+  }
+}
+
+it("pings admin topics and returns response time", async () => {
+  const client = new MockMqttClient();
+  const service = new TopicPingService({
+    db: {
+      prepare() {
+        return {
+          get() {
+            return null;
+          }
+        };
+      }
+    },
+    env: {
+      mqtt: {
+        brokerUrl: "mqtt://broker",
+        username: "",
+        password: "",
+        adminInboundTopic: "aios/admin/inbound",
+        adminOutboundTopic: "aios/admin/outbound",
+        agentInboundTopicTemplate: "aios/agent/{agentId}/inbound",
+        agentOutboundTopicTemplate: "aios/agent/{agentId}/outbound"
+      }
+    },
+    mqttFactory: {
+      connect() {
+        queueMicrotask(() => client.emit("connect"));
+        return client;
+      }
+    }
+  });
+
+  const result = await service.pingAdmin(1000);
+
+  expect(result.ok).toBe(true);
+  expect(result.inboundTopic).toBe("aios/admin/inbound");
+  expect(result.outboundTopic).toBe("aios/admin/outbound");
+  expect(typeof result.responseTimeMs).toBe("number");
+  expect(client.subscriptions).toEqual(["aios/admin/outbound"]);
+  expect(client.publications[0].topic).toBe("aios/admin/inbound");
+});
+
+it("waits until agent ping succeeds", async () => {
+  const service = new TopicPingService({
+    db: {
+      prepare() {
+        return {
+          get() {
+            return {
+              slug: "agent-a",
+              remote_state_json: JSON.stringify({
+                inboundTopic: "aios/agent/agent-a/inbound",
+                outboundTopic: "aios/agent/agent-a/outbound"
+              })
+            };
+          }
+        };
+      }
+    },
+    env: {
+      mqtt: {
+        brokerUrl: "mqtt://broker",
+        agentInboundTopicTemplate: "aios/agent/{agentId}/inbound",
+        agentOutboundTopicTemplate: "aios/agent/{agentId}/outbound"
+      }
+    }
+  });
+
+  let attempt = 0;
+  service.pingAgent = async () => {
+    attempt += 1;
+    if (attempt < 3) {
+      throw new Error("not ready");
+    }
+    return { ok: true, responseTimeMs: 12 };
+  };
+
+  const result = await service.waitForAgentReady("agent-a", {
+    timeoutMs: 1000,
+    intervalMs: 1,
+    pingTimeoutMs: 100
+  });
+
+  expect(result.ok).toBe(true);
+  expect(result.responseTimeMs).toBe(12);
+  expect(result.waitedMs).toEqual(jasmine.any(Number));
+  expect(attempt).toBe(3);
+});
+
+it("waits until agent runtime becomes active without pinging the model", async () => {
+  const listeners = new Map();
+  const service = new TopicPingService({
+    db: {
+      prepare() {
+        return {
+          get() {
+            return {
+              slug: "agent-a",
+              remote_state_json: JSON.stringify({
+                inboundTopic: "aios/agent/agent-a/inbound",
+                outboundTopic: "aios/agent/agent-a/outbound"
+              })
+            };
+          }
+        };
+      }
+    },
+    env: {
+      mqtt: {
+        brokerUrl: "mqtt://broker",
+        agentInboundTopicTemplate: "aios/agent/{agentId}/inbound",
+        agentOutboundTopicTemplate: "aios/agent/{agentId}/outbound"
+      }
+    },
+    rpcClient: {
+      on(event, handler) {
+        listeners.set(event, handler);
+      },
+      off(event, handler) {
+        if (listeners.get(event) === handler) {
+          listeners.delete(event);
+        }
+      }
+    }
+  });
+
+  setTimeout(() => {
+    listeners.get("outbound_message")?.({
+      requestId: "req-1",
+      ok: true,
+      request: {
+        action: "agent.create",
+        params: {
+          agentId: "agent-a"
+        }
+      }
+    });
+  }, 5);
+
+  const result = await service.waitForAgentRuntimeReady("agent-a", {
+    timeoutMs: 200
+  });
+
+  expect(result.ok).toBe(true);
+  expect(result.inboundTopic).toBe("aios/agent/agent-a/inbound");
+  expect(result.outboundTopic).toBe("aios/agent/agent-a/outbound");
+  expect(result.waitedMs).toEqual(jasmine.any(Number));
+});