aios-management-web 0.1.0

package/server/src/infra/providers/hzg-provider-client.js

@@ -0,0 +1,39 @@
+import { serviceUnavailable } from "../../utils/errors.js";
+
+export class HzgProviderClient {
+  constructor({
+    fetchImpl = globalThis.fetch
+  } = {}) {
+    this.fetchImpl = fetchImpl;
+  }
+
+  async createSessionCookie(baseUrl, sessionId) {
+    const url = `${String(baseUrl || "").replace(/\/$/, "")}/ServerCommand/`;
+    if (typeof this.fetchImpl !== "function") {
+      throw serviceUnavailable("Fetch is not available for session establishment");
+    }
+
+    const response = await this.fetchImpl(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ ManageThreadId: sessionId })
+    });
+
+    const setCookie = response.headers.get("set-cookie");
+    if (setCookie) {
+      return setCookie;
+    }
+
+    const body = await response.text();
+    try {
+      const parsed = JSON.parse(body);
+      if (parsed.cookie) {
+        return parsed.cookie;
+      }
+    } catch {}
+
+    throw serviceUnavailable("Failed to establish Huozige session cookie");
+  }
+}

package/server/src/infra/s3/object-storage.js

@@ -0,0 +1,97 @@
+import { GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { randomUUID } from "node:crypto";
+import { Readable } from "node:stream";
+
+import { serviceUnavailable } from "../../utils/errors.js";
+
+function sanitizeFileName(fileName) {
+  return fileName.replace(/[^A-Za-z0-9._-]+/g, "-");
+}
+
+async function bodyToBuffer(body) {
+  if (!body) {
+    throw serviceUnavailable("S3 object body is empty");
+  }
+
+  if (typeof body === "object" && typeof body.transformToByteArray === "function") {
+    return Buffer.from(await body.transformToByteArray());
+  }
+
+  if (body instanceof Readable) {
+    const chunks = [];
+    for await (const chunk of body) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+
+  if (body instanceof Uint8Array) {
+    return Buffer.from(body);
+  }
+
+  throw serviceUnavailable("Unsupported S3 object body type");
+}
+
+export class ObjectStorage {
+  constructor(env) {
+    this.env = env;
+    this.client = null;
+  }
+
+  isConfigured() {
+    return Boolean(
+      this.env.s3.endpoint &&
+        this.env.s3.accessKeyId &&
+        this.env.s3.secretAccessKey &&
+        this.env.s3.adminInboxBucket
+    );
+  }
+
+  getClient() {
+    if (!this.isConfigured()) {
+      throw serviceUnavailable("S3 artifact storage is not configured");
+    }
+
+    if (!this.client) {
+      this.client = new S3Client({
+        endpoint: this.env.s3.endpoint,
+        region: this.env.s3.region,
+        forcePathStyle: this.env.s3.forcePathStyle,
+        credentials: {
+          accessKeyId: this.env.s3.accessKeyId,
+          secretAccessKey: this.env.s3.secretAccessKey
+        }
+      });
+    }
+
+    return this.client;
+  }
+
+  async uploadAdminArtifact({ kind, file }) {
+    const objectKey = `${kind}/${new Date().toISOString().slice(0, 10)}/${randomUUID()}-${sanitizeFileName(file.originalname)}`;
+    await this.getClient().send(
+      new PutObjectCommand({
+        Bucket: this.env.s3.adminInboxBucket,
+        Key: objectKey,
+        Body: file.buffer,
+        ContentType: file.mimetype || "application/octet-stream"
+      })
+    );
+
+    return {
+      bucket: this.env.s3.adminInboxBucket,
+      objectKey
+    };
+  }
+
+  async downloadObject(bucket, objectKey) {
+    const response = await this.getClient().send(
+      new GetObjectCommand({
+        Bucket: bucket,
+        Key: objectKey
+      })
+    );
+
+    return await bodyToBuffer(response.Body);
+  }
+}

package/server/src/services/agent-quota.js

@@ -0,0 +1,54 @@
+export const AGENT_STATUSES = ["normal", "disabled", "overlimit"];
+
+const QUOTA_SPECS = [
+  { key: "daily", limitKey: "daily_limit", label: "daily" }
+];
+
+export function isAgentStatus(value) {
+  return AGENT_STATUSES.includes(value);
+}
+
+export function normalizeAgentStatus(value) {
+  return value === "disabled" ? "disabled" : "normal";
+}
+
+export function normalizeUsage(payload) {
+  if (!payload || typeof payload !== "object") {
+    return { daily: 0 };
+  }
+
+  const source = payload.usage || payload.tokens || payload;
+  return {
+    daily: Number(source.daily ?? source.day ?? source.dailyTokens ?? source.today ?? source.totalTokens ?? 0)
+  };
+}
+
+export function findQuotaViolation(agent, usage) {
+  for (const spec of QUOTA_SPECS) {
+    const limit = Number(agent?.[spec.limitKey] ?? -1);
+    const current = Number(usage?.[spec.key] ?? 0);
+    if (limit >= 0 && current >= limit) {
+      return {
+        period: spec.label,
+        limit,
+        current,
+        limitKey: spec.limitKey,
+        usageKey: spec.key
+      };
+    }
+  }
+
+  return null;
+}
+
+export function isOverLimit(agent, usage) {
+  return Boolean(findQuotaViolation(agent, usage));
+}
+
+export function statusAfterUsageRefresh(agent, usage) {
+  if (agent?.status === "disabled") {
+    return "disabled";
+  }
+
+  return isOverLimit(agent, usage) ? "overlimit" : "normal";
+}