@chrysb/alphaclaw 0.3.2-beta.3 → 0.3.2

package/lib/public/js/components/watchdog-tab.js

@@ -366,7 +366,7 @@ export const WatchdogTab = ({
                       detail=${`${formatBytes(r.disk?.usedBytes)} / ${formatBytes(r.disk?.totalBytes)}`}
                     />
                     <${ResourceBar}
-                      label=${`CPU${r.cpu?.cores ? ` (${r.cpu.cores} core${r.cpu.cores > 1 ? "s" : ""})` : ""}`}
+                      label=${`CPU${r.cpu?.cores ? ` (${r.cpu.cores} vCPU)` : ""}`}
                       percent=${r.cpu?.percent}
                       detail=${r.cpu?.percent != null
                         ? `${r.cpu.percent}%`

package/lib/server/system-resources.js

@@ -11,17 +11,54 @@ const readCgroupFile = (filePath) => {
   }
 };
 
+const readFirstCgroupFile = (paths) => {
+  for (const filePath of paths) {
+    const value = readCgroupFile(filePath);
+    if (value != null) return value;
+  }
+  return null;
+};
+
+const countCpuSet = (cpuSet) => {
+  if (!cpuSet) return null;
+  let count = 0;
+  const parts = String(cpuSet)
+    .split(",")
+    .map((part) => part.trim())
+    .filter(Boolean);
+  for (const part of parts) {
+    const [startRaw, endRaw] = part.split("-");
+    const start = Number.parseInt(startRaw, 10);
+    const end = endRaw == null ? start : Number.parseInt(endRaw, 10);
+    if (Number.isNaN(start) || Number.isNaN(end)) continue;
+    count += Math.max(0, end - start + 1);
+  }
+  return count > 0 ? count : null;
+};
+
 const parseCgroupMemory = () => {
-  const current = readCgroupFile("/sys/fs/cgroup/memory.current");
-  const max = readCgroupFile("/sys/fs/cgroup/memory.max");
+  const current = readFirstCgroupFile([
+    "/sys/fs/cgroup/memory.current",
+    "/sys/fs/cgroup/memory/memory.usage_in_bytes",
+  ]);
+  const max = readFirstCgroupFile([
+    "/sys/fs/cgroup/memory.max",
+    "/sys/fs/cgroup/memory/memory.limit_in_bytes",
+  ]);
   if (!current) return null;
   const usedBytes = Number.parseInt(current, 10);
   if (Number.isNaN(usedBytes)) return null;
-  const limitBytes =
+  const parsedLimit =
     max && max !== "max" ? Number.parseInt(max, 10) : null;
+  const limitBytes = Number.isNaN(parsedLimit) ? null : parsedLimit;
+  // Cgroup v1 uses huge sentinel values to mean "no limit".
+  const unlimited =
+    limitBytes == null ||
+    limitBytes <= 0 ||
+    limitBytes >= 9_000_000_000_000_000_000;
   return {
     usedBytes,
-    totalBytes: Number.isNaN(limitBytes) ? null : limitBytes,
+    totalBytes: unlimited ? null : limitBytes,
   };
 };
 
@@ -41,6 +78,54 @@ const parseCgroupCpu = () => {
   };
 };
 
+const parseCgroupCpuV1 = () => {
+  const usageNs = readFirstCgroupFile([
+    "/sys/fs/cgroup/cpuacct/cpuacct.usage",
+    "/sys/fs/cgroup/cpu/cpuacct.usage",
+  ]);
+  if (!usageNs) return null;
+  const usageNsParsed = Number.parseInt(usageNs, 10);
+  if (Number.isNaN(usageNsParsed)) return null;
+  return {
+    usageUsec: Math.floor(usageNsParsed / 1000),
+    userUsec: null,
+    systemUsec: null,
+  };
+};
+
+const getAllocatedCpuCores = () => {
+  const cpuMax = readCgroupFile("/sys/fs/cgroup/cpu.max");
+  if (cpuMax) {
+    const [quotaRaw, periodRaw] = cpuMax.split(/\s+/);
+    const quota = Number.parseInt(quotaRaw, 10);
+    const period = Number.parseInt(periodRaw, 10);
+    if (quotaRaw !== "max" && !Number.isNaN(quota) && !Number.isNaN(period) && period > 0) {
+      return quota / period;
+    }
+  }
+
+  const quotaV1 = readFirstCgroupFile([
+    "/sys/fs/cgroup/cpu/cpu.cfs_quota_us",
+    "/sys/fs/cgroup/cpuacct/cpu.cfs_quota_us",
+  ]);
+  const periodV1 = readFirstCgroupFile([
+    "/sys/fs/cgroup/cpu/cpu.cfs_period_us",
+    "/sys/fs/cgroup/cpuacct/cpu.cfs_period_us",
+  ]);
+  if (quotaV1 && periodV1) {
+    const quota = Number.parseInt(quotaV1, 10);
+    const period = Number.parseInt(periodV1, 10);
+    if (!Number.isNaN(quota) && !Number.isNaN(period) && quota > 0 && period > 0) {
+      return quota / period;
+    }
+  }
+
+  const cpuSet =
+    readCgroupFile("/sys/fs/cgroup/cpuset.cpus.effective") ||
+    readCgroupFile("/sys/fs/cgroup/cpuset.cpus");
+  return countCpuSet(cpuSet);
+};
+
 const readProcStatus = (pid) => {
   try {
     const status = fs.readFileSync(`/proc/${pid}/status`, "utf8");
@@ -98,6 +183,8 @@ let prevCpuSnapshot = null;
 let prevCpuSnapshotAt = 0;
 
 const getSystemResources = ({ gatewayPid = null } = {}) => {
+  const hostCores = os.cpus().length || 1;
+  const allocatedCores = getAllocatedCpuCores() || hostCores;
   const cgroupMem = parseCgroupMemory();
   const mem = {
     usedBytes: cgroupMem?.usedBytes ?? process.memoryUsage().rss,
@@ -106,7 +193,7 @@ const getSystemResources = ({ gatewayPid = null } = {}) => {
 
   const diskUsage = readDiskUsage();
 
-  const cgroupCpu = parseCgroupCpu();
+  const cgroupCpu = parseCgroupCpu() || parseCgroupCpuV1();
   let cpuPercent = null;
   if (cgroupCpu?.usageUsec != null) {
     const now = Date.now();
@@ -115,15 +202,15 @@ const getSystemResources = ({ gatewayPid = null } = {}) => {
       if (elapsedMs > 0) {
         const usageDeltaUs = cgroupCpu.usageUsec - prevCpuSnapshot.usageUsec;
         const elapsedUs = elapsedMs * 1000;
-        cpuPercent = Math.min(100, Math.max(0, (usageDeltaUs / elapsedUs) * 100));
+        const rawPercent = (usageDeltaUs / elapsedUs) * 100;
+        cpuPercent = Math.min(100, Math.max(0, rawPercent / allocatedCores));
       }
     }
     prevCpuSnapshot = cgroupCpu;
     prevCpuSnapshotAt = now;
   } else {
     const load = os.loadavg();
-    const cpus = os.cpus().length || 1;
-    cpuPercent = Math.min(100, Math.max(0, (load[0] / cpus) * 100));
+    cpuPercent = Math.min(100, Math.max(0, (load[0] / allocatedCores) * 100));
   }
 
   const alphaclawRss = process.memoryUsage().rss;
@@ -148,7 +235,8 @@ const getSystemResources = ({ gatewayPid = null } = {}) => {
     },
     cpu: {
       percent: cpuPercent != null ? Math.round(cpuPercent * 10) / 10 : null,
-      cores: os.cpus().length,
+      cores: Math.round(allocatedCores * 10) / 10,
+      hostCores,
     },
     processes: {
       alphaclaw: { rssBytes: alphaclawRss },

package/lib/setup/core-prompts/AGENTS.md

@@ -32,6 +32,24 @@ Changes committed ([abc1234](commit url)): <-- linked commit hash
 • path/or/resource (new|edit|delete) — brief description
 ```
 
+### Release Flow (Beta -> Production)
+
+Use this release flow when promoting tested beta builds to production:
+
+1. Ensure `main` is clean and synced, and tests pass.
+2. Publish beta iterations as needed:
+   - `npm version prerelease --preid=beta`
+   - `git push && git push --tags`
+   - `npm publish --tag beta`
+3. For beta template testing, pin exact beta in template `package.json` (for example `0.3.2-beta.4`) to avoid Docker layer cache reusing old installs.
+4. When ready for production, publish a stable release version (for example `0.3.2`):
+   - `npm version 0.3.2`
+   - `git push && git push --tags`
+   - `npm publish` (publishes to `latest`)
+5. Return templates to production channel:
+   - `@chrysb/alphaclaw: "latest"`
+6. Optionally keep beta branch/tag flows active for next release cycle.
+
 ### Telegram Notice Format (AlphaClaw)
 
 Use this format for any Telegram notices sent from AlphaClaw services (watchdog, system alerts, repair notices):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.3.2-beta.3",
+  "version": "0.3.2",
   "publishConfig": {
     "access": "public"
   },