@flame0510/project-aether 1.1.13 → 1.1.14

package/app/components/Skeleton.tsx

@@ -95,6 +95,77 @@ export function CodeSkeleton({ lines = 12 }: { lines?: number }) {
   );
 }
 
+/**
+ * Cron job rows — mirrors the real row in the scheduled-jobs column so the
+ * layout doesn't jump when the data lands: same 12px/14px padding, same divider,
+ * same title/description/badge header, schedule line, and NEXT RUN / LAST RUN
+ * grid. Widths vary per row so it reads as a list rather than a stack of bars.
+ */
+export function CronJobsSkeleton({ rows = 5 }: { rows?: number }) {
+  const shapes = [
+    { title: '58%', desc: '82%', badge: 54, expr: '34%' },
+    { title: '42%', desc: null, badge: 40, expr: '28%' },
+    { title: '66%', desc: '71%', badge: 62, expr: '40%' },
+    { title: '50%', desc: null, badge: 46, expr: '31%' },
+    { title: '61%', desc: '64%', badge: 58, expr: '36%' },
+    { title: '45%', desc: null, badge: 50, expr: '26%' },
+  ];
+
+  return (
+    <div aria-hidden="true">
+      {shapes.slice(0, rows).map((s, i) => (
+        <div key={i} style={{ padding: '12px 14px', borderBottom: '1px solid var(--border)' }}>
+          {/* Header: title + optional description on the left, agent pill right */}
+          <div style={{ display: 'flex', alignItems: 'flex-start', justifyContent: 'space-between', marginBottom: 6, gap: 8 }}>
+            <div style={{ flex: 1, minWidth: 0 }}>
+              <Skeleton width={s.title} height={12} accent />
+              {s.desc && <Skeleton width={s.desc} height={9} style={{ marginTop: 4 }} />}
+            </div>
+            <Skeleton width={s.badge} height={13} style={{ flexShrink: 0 }} />
+          </div>
+
+          {/* Schedule line: label + cron expression */}
+          <div style={{ display: 'flex', alignItems: 'center', gap: 6, marginBottom: 8 }}>
+            <Skeleton width={46} height={9} />
+            <Skeleton width={s.expr} height={10} />
+          </div>
+
+          {/* NEXT RUN / LAST RUN grid */}
+          <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '4px 12px' }}>
+            {[0, 1].map((c) => (
+              <div key={c}>
+                <Skeleton width={52} height={8} style={{ marginBottom: 3 }} />
+                <Skeleton width="72%" height={10} />
+              </div>
+            ))}
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+/**
+ * Cron run-history entries — one timestamp line plus a status/duration row,
+ * matching the entries the runs column renders once a job is selected.
+ */
+export function CronRunsSkeleton({ rows = 6 }: { rows?: number }) {
+  const widths = ['64%', '48%', '71%', '55%', '60%', '44%'];
+  return (
+    <div aria-hidden="true">
+      {widths.slice(0, rows).map((w, i) => (
+        <div key={i} style={{ padding: '10px 12px', borderBottom: '1px solid var(--border)' }}>
+          <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 8, marginBottom: 5 }}>
+            <Skeleton width={w} height={10} />
+            <Skeleton width={38} height={11} style={{ flexShrink: 0 }} />
+          </div>
+          <Skeleton width="30%" height={9} />
+        </div>
+      ))}
+    </div>
+  );
+}
+
 /* ─── Legacy aliases (used by existing components) ────────────────────────── */
 /** Stack of horizontal skeleton lines */
 export function SkeletonLines({ count = 3, width }: { count?: number; width?: string | number }) {

package/app/crons/PageClient.tsx

@@ -3,7 +3,7 @@
 import { useEffect, useState, useRef } from 'react';
 import { useResponsive } from '../design-system';
 import { Button, Pill } from '../components/ui';
-import { SkeletonLines } from '../components/Skeleton';
+import { CronJobsSkeleton, CronRunsSkeleton } from '../components/Skeleton';
 import { apiFetch } from '@/lib/apiFetch';
 import { useRev4aTimezone } from '@/lib/hooks/useRev4aTimezone';
 import { formatDateTimeInTimezone } from '@/lib/timezone';
@@ -266,9 +266,28 @@ export default function CronsPage() {
 
   useEffect(() => {
     const controller = new AbortController();
-    void load(controller.signal);
-    const t = setInterval(() => { if (!controller.signal.aborted) void load(controller.signal); }, 15_000);
-    return () => { controller.abort(); clearInterval(t); };
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    // Chained setTimeout rather than setInterval, deliberately.
+    //
+    // GET /api/crons runs `openclaw cron list --json` inside every agent
+    // container. That command takes ~5s per agent and the route walks them in
+    // sequence, so the response time scales with the number of agents and is
+    // already well past 15s on a multi-agent host. setInterval fires on schedule
+    // whether or not the previous call has come back, so those requests pile up
+    // — and since the route blocks the server's event loop while it runs, the
+    // whole dashboard stops answering for as long as this page stays open.
+    //
+    // Scheduling the next run only once the current one has settled turns the
+    // delay into a gap between polls instead of a deadline, so the loop can
+    // never outrun the endpoint no matter how slow it gets.
+    const poll = async () => {
+      await load(controller.signal);
+      if (!controller.signal.aborted) timer = setTimeout(poll, 15_000);
+    };
+    void poll();
+
+    return () => { controller.abort(); if (timer) clearTimeout(timer); };
   }, []);
 
   return (
@@ -278,7 +297,9 @@ export default function CronsPage() {
         <span className="crons-header__meta">{runs.length} runs loaded</span>
       </div>
 
-      {loading && <SkeletonLines count={4} />}
+      {/* No loader here: the skeleton lives inside each column, so the page keeps
+          its real layout while loading instead of showing a stack of bars above
+          two empty panels. */}
 
       {/* Agent filter bar */}
       {agentFilters.length > 1 && (
@@ -307,9 +328,12 @@ export default function CronsPage() {
         {/* Scheduled jobs */}
         <section style={{ width: isMobile ? '100%' : '40%', borderRight: isMobile ? 'none' : '1px solid var(--border)', display: isMobile && tab !== 'jobs' ? 'none' : 'flex', flexDirection: 'column', minHeight: 0 }}>
           <div style={{ padding: '8px 12px', borderBottom: '1px solid var(--border)', fontSize: 10, color: '#555', flexShrink: 0 }}>
-            SCHEDULED JOBS ({filteredJobs.length})
+            {/* Hide the count on the cold load — "(0)" beside a skeleton reads as
+                "no jobs", which is precisely what isn't known yet. */}
+            SCHEDULED JOBS{loading && filteredJobs.length === 0 ? '' : ` (${filteredJobs.length})`}
           </div>
           <div style={{ flex: 1, overflowY: 'auto' }}>
+            {loading && filteredJobs.length === 0 && <CronJobsSkeleton />}
             {filteredJobs.length === 0 && !loading && (
               <div style={{ padding: '20px 12px', fontSize: 11, color: '#555' }}>No scheduled jobs found</div>
             )}
@@ -471,10 +495,11 @@ export default function CronsPage() {
             RUN HISTORY {selectedJob ? `— ${selectedJob.name ?? selectedJob.id?.slice(0, 8) ?? ''}` : ''}
           </div>
           <div style={{ flex: 1, overflowY: 'auto' }}>
+            {loading && !selectedJob && <CronRunsSkeleton />}
             {!selectedJob && !loading && (
               <div style={{ padding: '20px 12px', fontSize: 11, color: '#555' }}>Select a cron job to view its run history</div>
             )}
-            {selectedJob && runsLoading && <SkeletonLines count={3} />}
+            {selectedJob && runsLoading && <CronRunsSkeleton />}
             {selectedJob && !runsLoading && runsError && (
               <div style={{ padding: '20px 12px', fontSize: 11, color: 'var(--red)' }}>{runsError}</div>
             )}

package/docs/ARCHITECTURE.md

@@ -147,7 +147,6 @@ and guaranteed at runtime by `applyRuntimeConfig()`.
 AGENT_NAME=<agent-name>
 AGENT_TEMPLATE=<template>
 OPENCLAW_GATEWAY_TOKEN=<shared agent token>
-AGENT_HOSTNAME=<host-ip>:<portStart>
 TZ=Europe/Rome
 ```
 

package/docs/dev/API-REFERENCE.md

@@ -548,9 +548,9 @@ List running agent containers (Docker containers with `AGENT_ID` label) with ful
     "ports": "",
     "ip": "172.19.0.5",
     "created": "2026-07-01T16:58:42.876829416Z",
-    "env": ["AGENT_ID=prometheus", "AGENT_HOSTNAME=<agent-name>.<your-domain>.com"],
+    "env": ["AGENT_ID=prometheus", "AGENT_TEMPLATE=prometheus"],
     "authToken": "***",
-    "traefikUrl": "http://187.77.156.41:3033#token=asdfghjkl"
+    "controlPort": "3033"
   }
 ]
 
@@ -589,7 +589,7 @@ Create a new agent container from a template.
 **Every agent is created with a host port mapping:**
 - Port block: `-p <start>-<end>:3000-<3000+offset>` — maps a range of host ports to the same range starting at container port 3000
 - Single port: `-p <port>:3000` — maps a single host port to container port 3000
-- URL format: `http://<host-ip>:<portStart>#token=...`
+- Control UI URL: composed by the browser as `http://<window.location.hostname>:<port>#token=<controlToken>` — the server returns the parts, not the URL
 - Port 3740 is reserved for Rev4a
 
 **Response:**
@@ -600,7 +600,7 @@ Create a new agent container from a template.
   "name": "my-agent",
   "image": "openclaw-agent-base:latest",
   "network": "rev4a-network",
-  "traefikUrl": "http://187.77.156.41:3700#token=asdfghjkl",
+  "controlToken": "asdfghjkl",
   "port": 3700,
   "portEnd": 3709,
   "isBlock": true,

package/lib/channelManager.ts

@@ -97,6 +97,28 @@ function findContainerById(agentId: string): string | null {
 
 // ── Public API ───────────────────────────────
 
+/**
+ * Read the Telegram channel out of an already-parsed openclaw.json.
+ *
+ * Pure — no container access — so callers that have obtained the config some
+ * other way (in bulk, asynchronously) can share the same interpretation instead
+ * of reimplementing it.
+ */
+export function parseTelegramChannel(config: Record<string, unknown>): TelegramChannel | null {
+  const telegram = (config.channels as Record<string, unknown>)?.telegram as Record<string, unknown> | undefined;
+  if (!telegram || telegram.enabled === false) return null;
+
+  const botToken = (telegram.botToken ?? '') as string;
+  if (typeof botToken !== 'string' || botToken.length === 0) return null;
+
+  return {
+    connected: true,
+    botToken: maskToken(botToken),
+    dmPolicy: (telegram.dmPolicy ?? 'pairing') as string,
+    allowFrom: (Array.isArray(telegram.allowFrom) ? telegram.allowFrom : []) as string[],
+  };
+}
+
 export function getChannels(agentId: string): AgentChannels {
   const container = findContainerById(agentId);
   const result: AgentChannels = { agentId, telegram: null };
@@ -106,22 +128,7 @@ export function getChannels(agentId: string): AgentChannels {
   const config = readConfigJson(container);
   if (!config) return result;
 
-  // ── Telegram ──
-  const telegram = (config.channels as Record<string, unknown>)?.telegram as Record<string, unknown> | undefined;
-  if (telegram && telegram.enabled !== false) {
-    const botToken = (telegram.botToken ?? '') as string;
-    const hasToken = typeof botToken === 'string' && botToken.length > 0;
-
-    if (hasToken) {
-      result.telegram = {
-        connected: true,
-        botToken: maskToken(botToken),
-        dmPolicy: (telegram.dmPolicy ?? 'pairing') as string,
-        allowFrom: (Array.isArray(telegram.allowFrom) ? telegram.allowFrom : []) as string[],
-      };
-    }
-  }
-
+  result.telegram = parseTelegramChannel(config);
   return result;
 }
 

package/lib/docker-exec.ts

@@ -0,0 +1,195 @@
+/**
+ * Running commands inside agent containers, without blocking the server.
+ *
+ * Every route that needed something from a container used to call `execSync` or
+ * `execFileSync` directly. Those are synchronous: while one runs, Node's single
+ * thread does nothing else — no other request is served, no agent's stream
+ * advances. Node's own guidance names `execSync` in a server as a
+ * denial-of-service vector, and the numbers here bear that out: a bare
+ * `docker exec … echo` costs ~260ms, and the OpenClaw CLI inside a container
+ * takes 2.5–6s per invocation because it boots a whole Node process.
+ *
+ * Routes that walk every agent multiplied that: `/api/crons` measured 19.2s on a
+ * seven-agent host, all of it with the event loop frozen.
+ *
+ * Everything here is async. The commands are still as slow as they were — that
+ * cost belongs to the OpenClaw CLI — but they no longer stop the rest of the
+ * server while they run.
+ */
+import { execFile, spawn } from 'child_process';
+import { promisify } from 'util';
+import { resolveDockerSocket } from '@/lib/docker-socket';
+
+const execFileAsync = promisify(execFile);
+
+/** Commands are expected to answer quickly; the OpenClaw CLI needs the headroom. */
+const DEFAULT_TIMEOUT_MS = 15_000;
+
+/** Matches what the previous callers passed, and covers `openclaw models list --json`. */
+const DEFAULT_MAX_BUFFER = 1024 * 1024;
+
+export interface DockerExecOptions {
+  timeoutMs?: number;
+  /** Extra environment for the command, passed as `-e KEY=VALUE`. */
+  env?: Record<string, string>;
+  maxBuffer?: number;
+  signal?: AbortSignal;
+}
+
+function baseArgs(container: string, opts?: DockerExecOptions): string[] {
+  const args = ['exec'];
+  for (const [k, v] of Object.entries(opts?.env ?? {})) args.push('-e', `${k}=${v}`);
+  args.push(container);
+  return args;
+}
+
+/**
+ * Run a command inside a container, passing argv directly.
+ *
+ * Prefer this over {@link dockerExecShell}: with no shell in between there is
+ * nothing to quote and nothing to escape, so a filename with a space or a quote
+ * cannot turn into a second command.
+ *
+ * Rejects when the command fails, the container is missing, or the timeout hits.
+ */
+export async function dockerExec(
+  container: string,
+  argv: string[],
+  opts?: DockerExecOptions,
+): Promise<string> {
+  if (!resolveDockerSocket()) throw new Error('Docker is not available');
+
+  const { stdout } = await execFileAsync(
+    'docker',
+    [...baseArgs(container, opts), ...argv],
+    {
+      encoding: 'utf-8',
+      timeout: opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      maxBuffer: opts?.maxBuffer ?? DEFAULT_MAX_BUFFER,
+      signal: opts?.signal,
+    },
+  );
+  return stdout;
+}
+
+/**
+ * Run a shell command inside a container. Only for commands that genuinely need
+ * a shell — pipes, redirection, globbing. Anything interpolated into `cmd` is
+ * shell syntax, so callers must quote it themselves.
+ */
+export async function dockerExecShell(
+  container: string,
+  cmd: string,
+  opts?: DockerExecOptions,
+): Promise<string> {
+  return dockerExec(container, ['sh', '-c', cmd], opts);
+}
+
+/**
+ * As {@link dockerExec}, but resolves to '' instead of rejecting.
+ *
+ * This is the shape most of the existing callers want: a container that is
+ * stopped, or an OpenClaw subcommand that isn't available on that agent, is a
+ * normal condition here — not something to fail a whole page over.
+ */
+export async function dockerExecNoFail(
+  container: string,
+  argv: string[],
+  opts?: DockerExecOptions,
+): Promise<string> {
+  try {
+    return await dockerExec(container, argv, opts);
+  } catch {
+    return '';
+  }
+}
+
+/** Shell variant of {@link dockerExecNoFail}. */
+export async function dockerExecShellNoFail(
+  container: string,
+  cmd: string,
+  opts?: DockerExecOptions,
+): Promise<string> {
+  return dockerExecNoFail(container, ['sh', '-c', cmd], opts);
+}
+
+/**
+ * Run a command inside a container and write `input` to its stdin.
+ *
+ * This uses `spawn` rather than `execFile` on purpose: `promisify(exec)` and
+ * `promisify(execFile)` silently ignore an `input` option — the process starts,
+ * stdin is never written, and the command hangs or reads nothing, with no error
+ * to point at. `openclaw config patch --stdin` is the case that needs this.
+ */
+export function dockerExecWithInput(
+  container: string,
+  argv: string[],
+  input: string,
+  opts?: DockerExecOptions,
+): Promise<string> {
+  if (!resolveDockerSocket()) return Promise.reject(new Error('Docker is not available'));
+
+  return new Promise((resolve, reject) => {
+    const child = spawn('docker', ['exec', '-i', ...baseArgs(container, opts).slice(1), ...argv], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error(`docker exec timed out after ${opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`));
+    }, opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+
+    child.stdout.on('data', (c) => { stdout += c; });
+    child.stderr.on('data', (c) => { stderr += c; });
+    child.on('error', (err) => { clearTimeout(timer); reject(err); });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve(stdout);
+      else reject(new Error(stderr.trim() || `docker exec exited with code ${code}`));
+    });
+
+    child.stdin.on('error', () => { /* the close handler reports the real failure */ });
+    child.stdin.end(input);
+  });
+}
+
+/**
+ * Map over items with a cap on how many run at once.
+ *
+ * The point of making these calls async is to run an agent fleet's worth of them
+ * concurrently instead of one after another. Doing that with a bare
+ * `Promise.all` would spawn one `docker exec` per agent simultaneously, which is
+ * fine for seven agents and not fine for seventy — each one is a process, and
+ * the Docker daemon serialises past a point anyway. The cap keeps the win
+ * without trading a frozen event loop for a swamped daemon.
+ *
+ * Results keep the order of `items`, regardless of completion order.
+ *
+ * Fail-fast, like `Promise.all`: if `fn` rejects for one item the whole call
+ * rejects. That is deliberate — silently swallowing failures here would hide
+ * real errors — but it means callers fanning out over an agent fleet should pass
+ * a function that handles its own failures (the `…NoFail` variants above, or an
+ * explicit try/catch), so one unreachable container can't blank an entire page.
+ */
+export async function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  limit: number,
+  fn: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+  if (items.length === 0) return [];
+  const results = new Array<R>(items.length);
+  let next = 0;
+
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+    while (true) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i], i);
+    }
+  });
+
+  await Promise.all(workers);
+  return results;
+}

package/lib/docker-utils.ts

@@ -1,54 +1,28 @@
-import { networkInterfaces } from 'os';
-
 /**
- * Detect the host's best public-facing IPv4 address for agent URLs.
+ * Docker-related host helpers.
+ *
+ * This module used to export `detectPublicHost()`, which shelled out to
+ * `curl icanhazip.com` via execSync to discover the machine's public IP, then
+ * fell back to `hostname -I` and finally the literal string 'localhost'. It was
+ * removed rather than optimised, because the caching it seemed to need would
+ * only have made a wrong answer stable:
  *
- * Priority:
- *   1. External IP detection via icanhazip.com (works from Docker containers)
- *   2. Hostname resolution (filters out 172.x Docker internal IPs)
- *   3. First non-internal IPv4 network interface
- *   4. 'localhost' fallback
+ *   - execSync blocks the entire event loop, so every call froze the whole
+ *     server — not just its own request — for ~270ms, and up to the 5s timeout
+ *     when the network hung. Node's own guidance names execSync in a server as
+ *     a denial-of-service vector.
+ *   - On macOS it never even worked: icanhazip answers with IPv6, which the
+ *     IPv4-only validation discarded, and `hostname -I` is a GNU-only flag. The
+ *     value that came back was the machine's `.local` mDNS name, reachable only
+ *     from the same LAN.
+ *   - It answered the wrong question. Callers needed "which URL should this
+ *     user's browser open", not "what is this machine's WAN address". Those
+ *     differ behind NAT, behind a reverse proxy, and over a tunnel.
+ *
+ * Agent URLs are now composed in the browser from the port returned by the API
+ * plus `window.location.hostname` — a hostname already proven to reach this
+ * server, since the dashboard is being served over it.
  */
-export function detectPublicHost(): string {
-  // 1. External detection (works from inside Docker containers)
-  try {
-    const { execSync } = require('child_process');
-    const ip = execSync(
-      'curl -fs --max-time 3 icanhazip.com 2>/dev/null || curl -fs --max-time 3 ifconfig.me 2>/dev/null',
-      { encoding: 'utf-8', timeout: 5000 },
-    ).trim();
-    if (ip && /^\d+\.\d+\.\d+\.\d+$/.test(ip) && !ip.startsWith('172.')) {
-      return ip;
-    }
-  } catch { /* ignore */ }
-
-  // 2. Hostname (often gives public IP on VPS, but Docker internal 172.x is filtered)
-  try {
-    const { execSync } = require('child_process');
-    const hostname = execSync('hostname -I 2>/dev/null || hostname 2>/dev/null', {
-      encoding: 'utf-8', timeout: 2000,
-    }).trim().split(/\s+/)[0];
-    if (hostname && hostname !== '127.0.0.1' && hostname !== '::1' && !hostname.startsWith('172.')) {
-      return hostname;
-    }
-  } catch { /* ignore */ }
-
-  // 3. Network interfaces (bare metal)
-  try {
-    const ifaces = networkInterfaces();
-    for (const [, addrs] of Object.entries(ifaces)) {
-      if (!addrs) continue;
-      for (const addr of addrs) {
-        if (addr.family === 'IPv4' && !addr.internal) {
-          return addr.address;
-        }
-      }
-    }
-  } catch { /* fall through */ }
-
-  // 4. Fallback
-  return 'localhost';
-}
 
 /**
  * Build the provider gateway base URL used to sync model config into agent