@flame0510/project-aether 1.1.13 → 1.1.15

package/app/api/gateway/agent/route.ts

@@ -126,12 +126,14 @@ export async function PUT(request: NextRequest) {
       { timeout: 15000, maxBuffer: 1024 * 1024, input: newConfig },
     );
 
-    // Restart gateway to pick up the changes
-    try {
-      execSync(`docker exec ${safeContainer} openclaw gateway restart`, { timeout: 15000, maxBuffer: 64 * 1024 });
-    } catch {
-      // restart failure is non-fatal, config was written
-    }
+    // No gateway restart: the Gateway watches openclaw.json and hot-applies this.
+    // Confirmed against a live agent by writing the file exactly the way this
+    // route does — the container logged:
+    //   [reload] config change detected; evaluating reload (agents.defaults.model.primary)
+    //   [reload] config hot reload applied (agents.defaults.model.primary)
+    // OpenClaw's docs put `agents` in the no-restart column, and gateway.reload
+    // defaults to `hybrid`, which restarts on its own for the sections that do
+    // need it. The restart here cost ~7.5s of fully blocked event loop.
 
     // Verify
     const verifyRaw = readFileFromContainer(safeContainer, '/root/.openclaw/openclaw.json');

package/app/api/gateway/route.ts

@@ -2,23 +2,42 @@ import { type NextRequest } from "next/server";
 /**
  * Gateway Status API
  *
- * Aggregates live model/provider state from Rev4a agent containers.
- * Only queries containers with AGENT_ID label — no hardcoded container names.
+ * Reports the per-agent model settings the Gateway page needs to render its
+ * agent cards and pre-fill the "edit default model" form. Only containers with
+ * an AGENT_ID label are considered — no hardcoded container names.
  *
  * GET /api/gateway
+ *
+ * This used to shell out to the OpenClaw CLI inside every container, twice:
+ * `openclaw models status --json` (~5.7s) and `openclaw models list --json`
+ * (~4.4s), serially, with execSync — so ~10s per agent with the event loop
+ * frozen throughout, and roughly 70s on a seven-agent host.
+ *
+ * Both were avoidable. `models list` produced a model catalogue and alias map
+ * that no line of the UI ever read: the page takes its model list from
+ * /api/gateway/provider, which reads local files. And `models status` returned,
+ * for the two fields actually used, exactly what sits in the agent's own
+ * openclaw.json — verified field by field against a live agent. So the CLI was
+ * being booted for five seconds to read a file that `cat` returns in 260ms.
+ *
+ * The response shape is unchanged so the page keeps working untouched; the
+ * fields that came only from the discarded CLI output are now reported empty
+ * rather than computed at great cost and thrown away.
  */
 import { NextResponse } from 'next/server';
-import { execSync } from 'child_process';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
+import { dockerExecNoFail, mapWithConcurrency } from '@/lib/docker-exec';
+
+const execFileAsync = promisify(execFile);
 
 export const dynamic = 'force-dynamic';
 
-interface GatewayModel {
-  key: string;
-  provider: string;
-  model: string;
-  available: boolean;
-}
+/** Agents queried at once. Each is a `docker exec … cat`, cheap but still a process. */
+const AGENT_QUERY_CONCURRENCY = 8;
+
+const AGENT_CONFIG_PATH = '/root/.openclaw/openclaw.json';
 
 interface GatewayProvider {
   provider: string;
@@ -40,93 +59,78 @@ interface GatewayAgentStatus {
   error?: string;
 }
 
-interface ApiKeyStatus {
-  provider: string;
-  configured: boolean;
-}
-
-/** Run a command inside a Docker container */
-function dockerExec(container: string, cmd: string, timeout = 15000): string {
-  try {
-    return execSync(
-      `docker exec ${container} sh -c ${JSON.stringify(cmd)}`,
-      { timeout, maxBuffer: 1024 * 1024, encoding: 'utf-8' },
-    );
-  } catch {
-    return '';
-  }
+interface AgentRef {
+  agentId: string;
+  containerName: string;
+  state: string;
 }
 
-/** Get Docker containers with AGENT_ID label — only Rev4a-managed agents */
-function getAgents(): { agentId: string; containerName: string; state: string }[] {
+/**
+ * Containers carrying an AGENT_ID label, with the label read straight out of
+ * `docker ps` rather than a follow-up `docker inspect` per container.
+ */
+async function getAgents(): Promise<AgentRef[]> {
   try {
-    const raw = execSync(
-      `docker ps --filter "label=AGENT_ID" --format '{{.Label "AGENT_ID"}}|{{.Names}}|{{.State}}'`,
-      { timeout: 5000, maxBuffer: 64 * 1024, encoding: 'utf-8' },
-    ).trim();
-    if (!raw) return [];
-    return raw.split('\n').map((line) => {
-      const [agentId, containerName, state] = line.split('|');
-      return { agentId, containerName, state };
-    });
+    const { stdout } = await execFileAsync('docker', [
+      'ps', '--filter', 'label=AGENT_ID',
+      '--format', '{{.Label "AGENT_ID"}}\t{{.Names}}\t{{.State}}',
+    ], { encoding: 'utf-8', timeout: 5000 });
+
+    return stdout.trim().split('\n')
+      .map((line) => {
+        const [agentId, containerName, state] = line.split('\t');
+        if (!containerName?.trim()) return null;
+        return {
+          agentId: agentId?.trim() || containerName.trim(),
+          containerName: containerName.trim(),
+          state: state?.trim() || 'unknown',
+        };
+      })
+      .filter(Boolean) as AgentRef[];
   } catch {
     return [];
   }
 }
 
-/** Query an agent container for model status */
-function getAgentStatus(agent: { agentId: string; containerName: string; state: string }): GatewayAgentStatus | null {
-  const raw = dockerExec(agent.containerName, 'openclaw models status --json', 8000);
-  if (!raw) return null;
-  try {
-    const data = JSON.parse(raw);
-    const authProviders: Record<string, unknown>[] = data.auth?.providers ?? [];
-    const providers: GatewayProvider[] = authProviders.map((p: Record<string, unknown>) => ({
-      provider: String(p.provider ?? ''),
-      kind: String((p.effective as Record<string, unknown>)?.kind ?? ''),
-      detail: String((p.effective as Record<string, unknown>)?.detail ?? ''),
-      profiles: Number((p.profiles as Record<string, unknown>)?.count ?? 0),
-      labels: (p.profiles as Record<string, unknown>)?.labels as string[] ?? [],
-    }));
-
-    const aliasesRaw = data.aliases ?? {};
-    const aliases: Record<string, string> = {};
-    for (const [k, v] of Object.entries(aliasesRaw)) {
-      aliases[k] = String(v);
-    }
+/**
+ * Read an agent's model settings out of its openclaw.json.
+ *
+ * `agents.defaults.model` is the same value `openclaw models status` reports as
+ * `defaultModel`/`fallbacks`. The CLI additionally resolves an `imageModel`
+ * default when the config sets none, but the base image defines no such default
+ * (verified: `imageModel: null`), and agent creation always writes an explicit
+ * model — so there is no case where the file and the CLI would disagree.
+ */
+async function readAgentStatus(agent: AgentRef): Promise<GatewayAgentStatus> {
+  const raw = await dockerExecNoFail(
+    agent.containerName,
+    ['cat', AGENT_CONFIG_PATH],
+    { timeoutMs: 8000 },
+  );
+
+  const base: GatewayAgentStatus = {
+    agentId: agent.agentId,
+    containerName: agent.containerName,
+    state: agent.state,
+    defaultModel: '',
+    fallbacks: [],
+    allowed: [],
+    aliases: {},
+    providers: [],
+  };
+
+  if (!raw) return { ...base, error: 'config unreadable' };
 
+  try {
+    const config = JSON.parse(raw) as Record<string, any>;
+    const model = config?.agents?.defaults?.model ?? {};
     return {
-      agentId: agent.agentId,
-      containerName: agent.containerName,
-      state: agent.state,
-      defaultModel: String(data.defaultModel ?? ''),
-      fallbacks: (data.fallbacks ?? []).map(String),
-      allowed: (data.allowed ?? []).map(String),
-      aliases,
-      providers,
+      ...base,
+      defaultModel: typeof model.primary === 'string' ? model.primary : '',
+      fallbacks: Array.isArray(model.fallbacks) ? model.fallbacks.map(String) : [],
     };
   } catch {
-    return null;
-  }
-}
-
-/** Get available models from an agent */
-function getAgentModels(container: string): GatewayModel[] {
-  const raw = dockerExec(container, 'openclaw models list --json', 8000);
-  if (!raw) return [];
-  try {
-    const parsed = JSON.parse(raw);
-    const models: Record<string, unknown>[] = parsed.models ?? parsed ?? [];
-    return models
-      .filter((m: Record<string, unknown>) => m.available !== false && !m.missing)
-      .map((m: Record<string, unknown>) => ({
-        key: String(m.key ?? ''),
-        provider: String(m.key ?? '').split('/')[0] || 'unknown',
-        model: String(m.name ?? String(m.key ?? '').split('/').slice(1).join('/')),
-        available: m.available !== false,
-      }));
-  } catch {
-    return [];
+    return { ...base, error: 'config unparseable' };
   }
 }
 
@@ -136,64 +140,24 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
   try {
     const timestamp = Date.now();
 
-    // Only Rev4a-managed agents (AGENT_ID label)
-    const agentsRaw = getAgents();
-    const agents = agentsRaw
-      .map((a) => getAgentStatus(a))
-      .filter(Boolean) as GatewayAgentStatus[];
-
-    // Aggregate models from all agents (deduplicated by key)
-    const modelMap = new Map<string, GatewayModel>();
-    for (const agent of agents) {
-      for (const m of getAgentModels(agent.containerName)) {
-        if (!modelMap.has(m.key)) modelMap.set(m.key, m);
-      }
-    }
-    const allModels = Array.from(modelMap.values());
-    const availableModels = allModels.filter((m) => m.available);
-
-    // Aggregate aliases from all agents
-    const combinedAliases: Record<string, string[]> = {};
-    for (const agent of agents) {
-      for (const [alias, model] of Object.entries(agent.aliases)) {
-        if (!combinedAliases[alias]) combinedAliases[alias] = [];
-        if (!combinedAliases[alias].includes(model)) {
-          combinedAliases[alias].push(model);
-        }
-      }
-    }
+    const refs = await getAgents();
+    const agents = await mapWithConcurrency(refs, AGENT_QUERY_CONCURRENCY, readAgentStatus);
 
     // First agent is the "primary" for core model settings
     const primaryAgent = agents[0] ?? null;
 
-    // API keys from the first agent's providers
-    const apiKeys: ApiKeyStatus[] = [];
-    if (primaryAgent) {
-      for (const p of primaryAgent.providers) {
-        // We can't query apiKey presence from openclaw models status (it's redacted).
-        // Mark as configured if the provider appears in the auth list.
-        apiKeys.push({
-          provider: p.provider,
-          configured: p.profiles > 0,
-        });
-      }
-    }
-
-    // Models by provider
-    const byProvider = allModels.reduce<Record<string, number>>((acc, m) => {
-      acc[m.provider] = (acc[m.provider] ?? 0) + 1;
-      return acc;
-    }, {});
-
     return NextResponse.json({
       timestamp,
       gateway: 'Rev4a Model Gateway',
       status: 'online',
+      // The model catalogue lives in /api/gateway/provider, which reads the
+      // bundled config plus user overrides. Recomputing it per agent here cost
+      // 4.4s each and was never read.
       models: {
-        total: allModels.length,
-        available: availableModels.length,
-        byProvider: Object.entries(byProvider).map(([provider, count]) => ({ provider, count })),
-        list: allModels,
+        total: 0,
+        available: 0,
+        byProvider: [],
+        list: [],
       },
       agents: {
         total: agents.length,
@@ -207,16 +171,18 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
           providers: a.providers,
         })),
       },
-      aliases: combinedAliases,
+      aliases: {},
       coreModel: primaryAgent
         ? {
             defaultModel: primaryAgent.defaultModel,
             fallbacks: primaryAgent.fallbacks,
           }
         : null,
+      // Provider credential state comes from /api/gateway/provider (`configured`
+      // per provider), which reads provider-keys.json directly.
       apiKeys: {
-        configured: apiKeys.filter((k) => k.configured).map((k) => k.provider),
-        all: apiKeys,
+        configured: [],
+        all: [],
       },
     });
   } catch (e: unknown) {

package/app/api/gateway/sync.ts

@@ -79,16 +79,6 @@ function writeContainerJson(container: string, remotePath: string, data: Record<
   );
 }
 
-function restartContainerGateway(container: string): string | null {
-  try {
-    execSync(`docker exec ${container} openclaw gateway restart`, { timeout: 15000, maxBuffer: 64 * 1024 });
-    return null;
-  } catch (e: unknown) {
-    const err = e as { stdout?: string; stderr?: string; message?: string };
-    return err.stderr?.toString().trim() || err.message || 'unknown error';
-  }
-}
-
 /* ------------------------------------------------------------------ */
 /*  Sync functions                                                     */
 /* ------------------------------------------------------------------ */
@@ -181,9 +171,16 @@ function syncContainer(
 
   writeContainerJson(container, remotePath, config);
 
-  const gwError = restartContainerGateway(container);
-  if (gwError) {
-    return `${container}: file updated but gateway restart failed: ${gwError}`;
-  }
-  return `${container}: synced + restarted OK`;
+  // No gateway restart: this only writes models.providers.rev4a, and the Gateway
+  // watches openclaw.json and hot-applies it. OpenClaw's own config tooling says
+  // so out loud — "Change will apply without restarting the gateway" — and its
+  // docs put `models` in the no-restart column, with `gateway.reload` defaulting
+  // to `hybrid`, which additionally restarts by itself for the changes that do
+  // need it. Verified against a live agent: every agent here leaves
+  // `gateway.reload` unset, so they all run that default.
+  //
+  // The restart used to cost ~7.5s per container, serially — roughly 52s of
+  // fully blocked event loop on a seven-agent host, every time a provider key or
+  // model toggle was saved, to do something the Gateway had already done.
+  return `${container}: synced`;
 }

package/app/api/provider/upstream.ts

@@ -5,8 +5,6 @@
  * Used by both /api/provider/v1/chat/completions and /api/assistant
  * to avoid HTTP loopback (calling localhost from inside Next.js).
  */
-import { detectPublicHost } from '@/lib/docker-utils';
-
 export const dynamic = 'force-dynamic';
 
 export interface ProviderEnvConfig {
@@ -127,7 +125,18 @@ export async function callUpstream(
   }
 
   if (provider === 'openrouter') {
-    headers['HTTP-Referer'] = `http://${detectPublicHost()}:3740`;
+    // Attribution only: OpenRouter uses this pair to identify the app on its
+    // public leaderboard. It never resolves or contacts the URL, and it has no
+    // effect on routing, rate limits, pricing, or whether the call succeeds.
+    //
+    // This used to be `http://${detectPublicHost()}:3740`, which shelled out to
+    // curl synchronously — blocking the whole event loop for ~270ms before every
+    // OpenRouter call, and 55 of the 69 models enabled in the catalogue are
+    // OpenRouter ones. It also fragmented the attribution it was supposed to
+    // provide: every install reported a different host, so each one showed up as
+    // a separate app. A per-install address was never the right value here —
+    // X-Title, the other half of the same label, was always a constant.
+    headers['HTTP-Referer'] = 'https://rev4a.app';
     headers['X-Title'] = 'Rev4a Gateway';
   }
 

package/app/api/skills/route.js

@@ -1,11 +1,19 @@
 import { NextResponse } from 'next/server';
 import fs from 'fs';
 import path from 'path';
-import { execSync, execFileSync } from 'child_process';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
 import { SHARED_SKILLS_DIR } from '@/lib/rev4a-paths';
+import { dockerExecShellNoFail, mapWithConcurrency } from '@/lib/docker-exec';
+
+const execFileAsync = promisify(execFile);
 
 const CONTAINER_BUNDLED_SKILLS_DIR = '/usr/local/lib/node_modules/openclaw/skills';
+const WORKSPACE_SKILLS_DIR = '/root/.openclaw/workspace/skills';
+
+/** Agents read at once — each is a single bulk `docker exec`. */
+const AGENT_QUERY_CONCURRENCY = 6;
 
 function readSkillMeta(skillDir, name, type, agentId) {
   const skillMdPath = path.join(skillDir, name, 'SKILL.md');
@@ -41,22 +49,19 @@ function readSkillMeta(skillDir, name, type, agentId) {
  * Discover agent containers with AGENT_ID label.
  * Returns [{ containerName, agentId }]
  */
-function discoverAgentContainers() {
+async function discoverAgentContainers() {
   try {
-    // Get container names with AGENT_ID label
-    const namesRaw = execFileSync('docker', [
-      'ps', '--filter', 'label=AGENT_ID', '--format', '{{.Names}}'
-    ], { encoding: 'utf8', timeout: 5000 }).trim();
-    if (!namesRaw) return [];
-
-    return namesRaw.split('\n').map(name => {
-      const containerName = name.trim();
-      if (!containerName) return null;
-      // Get agent ID from label using docker inspect
-      const agentId = execFileSync('docker', [
-        'inspect', containerName, '--format', '{{index .Config.Labels "AGENT_ID"}}'
-      ], { encoding: 'utf8', timeout: 5000 }).trim();
-      return { containerName, agentId: agentId || containerName };
+    // `docker ps` prints labels itself, so the AGENT_ID comes back with the name.
+    // This used to follow up with a `docker inspect` per container to read that
+    // same label — N+1 process spawns for data the first call already had.
+    const { stdout } = await execFileAsync('docker', [
+      'ps', '--filter', 'label=AGENT_ID', '--format', '{{.Label "AGENT_ID"}}\t{{.Names}}'
+    ], { encoding: 'utf8', timeout: 5000 });
+
+    return stdout.trim().split('\n').map(line => {
+      const [agentId, containerName] = line.split('\t');
+      if (!containerName?.trim()) return null;
+      return { containerName: containerName.trim(), agentId: agentId?.trim() || containerName.trim() };
     }).filter(Boolean);
   } catch {
     return [];
@@ -64,42 +69,44 @@ function discoverAgentContainers() {
 }
 
 /**
- * Read skill directories from a container agent's workspace via docker exec.
- * Returns an array of skill names found.
+ * Read every SKILL.md under `dir` in one shot.
+ *
+ * The previous approach ran `docker exec … cat` once per skill. With 52 bundled
+ * skills in the base image that was 52 sequential process spawns at ~260ms each
+ * — roughly 13s of blocked event loop to read 52 text files sitting in the same
+ * container.
+ *
+ * The shell loop emits `path\0content\0` pairs. NUL is the delimiter precisely
+ * because it cannot occur inside the text files being read, so no SKILL.md can
+ * forge a record boundary — a risk any printable separator would carry.
+ *
+ * Returns a Map of skill name → SKILL.md contents.
  */
-function readContainerSkillDirs(containerName) {
-  const workspaceSkillsPath = '/root/.openclaw/workspace/skills';
-  try {
-    // Check if the skills directory exists
-    execFileSync('docker', ['exec', containerName, 'test', '-d', workspaceSkillsPath], {
-      encoding: 'utf8', timeout: 5000
-    });
-
-    // List subdirectories (each is a potential skill)
-    const raw = execFileSync('docker', ['exec', containerName, 'ls', '-1', workspaceSkillsPath], {
-      encoding: 'utf8', timeout: 5000
-    }).trim();
-
-    if (!raw) return [];
-
-    return raw.split('\n').map(line => line.trim()).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Read SKILL.md content from inside a container.
- */
-function readContainerSkillMd(containerName, skillName) {
-  const filePath = `/root/.openclaw/workspace/skills/${skillName}/SKILL.md`;
-  try {
-    return execFileSync('docker', ['exec', containerName, 'cat', filePath], {
-      encoding: 'utf8', timeout: 5000
-    });
-  } catch {
-    return null;
+async function readSkillsBulk(containerName, dir) {
+  const script =
+    `for d in ${dir}/*/; do ` +
+    `[ -f "$d/SKILL.md" ] || continue; ` +
+    `n=$(basename "$d"); ` +
+    `printf '%s\\0' "$n"; ` +
+    `cat "$d/SKILL.md"; ` +
+    `printf '\\0'; ` +
+    `done`;
+
+  const raw = await dockerExecShellNoFail(containerName, script, {
+    timeoutMs: 15000,
+    maxBuffer: 8 * 1024 * 1024,
+  });
+
+  const out = new Map();
+  if (!raw) return out;
+
+  const parts = raw.split('\0');
+  // Pairs of name, content — a trailing empty element from the final NUL is fine.
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    const name = parts[i].trim();
+    if (name) out.set(name, parts[i + 1]);
   }
+  return out;
 }
 
 /**
@@ -136,66 +143,51 @@ export async function GET(request) {
     }
   } catch {}
 
-  // 2. Agent container skills (workspace-local)
-  const agents = discoverAgentContainers();
-  for (const agent of agents) {
-    const dirs = readContainerSkillDirs(agent.containerName);
-    for (const dir of dirs) {
-      const content = readContainerSkillMd(agent.containerName, dir);
-      if (content) {
-        const { description, version } = parseSkillContent(content);
-        skills.push({
-          name: dir,
-          type: 'workspace',
-          agentId: agent.agentId,
-          containerName: agent.containerName,
-          path: `/root/.openclaw/workspace/skills/${dir}`,
-          skillMdPath: `/root/.openclaw/workspace/skills/${dir}/SKILL.md`,
-          hasSkillMd: true,
-          description,
-          version,
-        });
-      }
+  // 2. Agent container skills (workspace-local) — one bulk read per agent,
+  //    agents queried concurrently.
+  const agents = await discoverAgentContainers();
+  const perAgent = await mapWithConcurrency(agents, AGENT_QUERY_CONCURRENCY, (agent) =>
+    readSkillsBulk(agent.containerName, WORKSPACE_SKILLS_DIR),
+  );
+
+  for (const [i, found] of perAgent.entries()) {
+    const agent = agents[i];
+    for (const [name, content] of found) {
+      const { description, version } = parseSkillContent(content);
+      skills.push({
+        name,
+        type: 'workspace',
+        agentId: agent.agentId,
+        containerName: agent.containerName,
+        path: `${WORKSPACE_SKILLS_DIR}/${name}`,
+        skillMdPath: `${WORKSPACE_SKILLS_DIR}/${name}/SKILL.md`,
+        hasSkillMd: true,
+        description,
+        version,
+      });
     }
   }
 
-  // 3. Bundled skills (read-only) — discover from any agent container
+  // 3. Bundled skills (read-only) — identical in every agent, so the first
+  //    container that answers is enough. One bulk read instead of 52 `cat`s.
   try {
-    let bundledDirNames = [];
-    let bundledSourceContainer = null;
-
-    if (agents.length > 0) {
-      for (const agent of agents) {
-        try {
-          const raw = execFileSync('docker', [
-            'exec', agent.containerName, 'ls', '-1', CONTAINER_BUNDLED_SKILLS_DIR
-          ], { encoding: 'utf8', timeout: 5000 }).trim();
-          if (raw) {
-            bundledDirNames = raw.split('\n').map(l => l.trim()).filter(Boolean);
-            bundledSourceContainer = agent.containerName;
-            break;
-          }
-        } catch { /* try next container */ }
-      }
-    }
+    for (const agent of agents) {
+      const found = await readSkillsBulk(agent.containerName, CONTAINER_BUNDLED_SKILLS_DIR);
+      if (found.size === 0) continue; // container not ready — try the next one
 
-    for (const name of bundledDirNames) {
-      try {
-        const skillMdPath = `${CONTAINER_BUNDLED_SKILLS_DIR}/${name}/SKILL.md`;
-        const content = execFileSync('docker', [
-          'exec', bundledSourceContainer, 'cat', skillMdPath
-        ], { encoding: 'utf8', timeout: 5000 });
+      for (const [name, content] of found) {
         const { description, version } = parseSkillContent(content);
         skills.push({
           name,
           type: 'bundled',
           path: `${CONTAINER_BUNDLED_SKILLS_DIR}/${name}`,
-          skillMdPath,
+          skillMdPath: `${CONTAINER_BUNDLED_SKILLS_DIR}/${name}/SKILL.md`,
           hasSkillMd: true,
           description,
           version,
         });
-      } catch { /* skip this skill */ }
+      }
+      break;
     }
   } catch {}