@flame0510/project-aether 1.1.15 → 1.3.0

package/app/api/credentials/detect/route.ts

@@ -2,17 +2,22 @@ import { NextResponse, type NextRequest } from 'next/server';
 import { listProfiles, getSecret } from '@/lib/credentials/vault';
 import {
   listAgentContainers,
-  execInContainer,
-  cliInstalled,
+  probeContainer,
   providerTokenHash,
   profileTokenHash,
-  detectTrello,
-  detectNotion,
+  vercelCurrentTeam,
+  supabaseProjectRef,
+  TOKEN_FIELD,
+  type ContainerProbe,
 } from '@/lib/credentials/detect';
+import { mapWithConcurrency } from '@/lib/docker-exec';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
 
 export const dynamic = 'force-dynamic';
 
+/** Containers probed at once. Each is a single `docker exec`. */
+const AGENT_QUERY_CONCURRENCY = 6;
+
 interface DetectedStatus {
   container: string;
   agentId: string;
@@ -33,6 +38,12 @@ interface DetectedStatus {
   notionLoggedIn: boolean;
   toolsMdHasMarkers: boolean;
   matchedProfiles: { profileId: string; providerId: string; label: string }[];
+  /**
+   * Providers with a token present in the container, whether or not it belongs
+   * to a stored profile. A provider listed here but absent from
+   * `matchedProfiles` holds a credential nobody in the vault accounts for.
+   */
+  installedProviders: string[];
 }
 
 interface DetectionError {
@@ -41,125 +52,106 @@ interface DetectionError {
   error: string;
 }
 
-function detectSupabase(container: string): { loggedIn: boolean; linked: boolean; projectRef: string } {
-  if (!cliInstalled(container, 'supabase')) {
-    return { loggedIn: false, linked: false, projectRef: '' };
-  }
-
-  // Verify login by calling the Supabase API (analogous to gh auth status / vercel whoami)
-  const raw = execInContainer(
-    container,
-    'supabase projects list --output json 2>&1',
-    (r) => r.trim(),
-    '',
-  );
-
-  // Unauthorized → not logged in
-  if (!raw || raw.includes('Unauthorized')) {
-    return { loggedIn: false, linked: false, projectRef: '' };
-  }
-
-  // Check if a linked project exists in the workspace
-  let linked = false;
-  let projectRef = '';
-  const linkedRef = execInContainer(
-    container,
-    'cat /data/supabase/config.toml 2>/dev/null | grep project_id | head -1 | sed "s/.*= *\"//;s/\".*//"',
-    (r) => r.trim(),
-    '',
-  );
-  if (linkedRef && linkedRef.length > 0) {
-    linked = true;
-    projectRef = linkedRef;
-  }
-
-  return { loggedIn: true, linked, projectRef };
-}
-
-function detectGithub(container: string): { loggedIn: boolean; user: string } {
-  if (!cliInstalled(container, 'gh')) {
-    return { loggedIn: false, user: '' };
-  }
-
-  const raw = execInContainer(
-    container,
-    'gh auth status 2>&1',
-    (r) => r,
-    '',
-  );
-  if (!raw || raw.includes('not logged into any GitHub hosts')) {
-    return { loggedIn: false, user: '' };
-  }
-  const match = raw.match(/Logged in to github\.com as (\S+)/);
-  return { loggedIn: !!match, user: match?.[1] ?? '' };
+/** Last non-empty line of `vercel whoami` — the rest is header noise. */
+function extractUsername(raw: string): string {
+  const lines = raw.split('\n').filter((l) => l.trim());
+  return lines[lines.length - 1]?.trim() || raw.trim();
 }
 
-function detectToolsMd(container: string): boolean {
-  const raw = execInContainer(
-    container,
-    `grep -c 'REV4A:INTEGRATIONS:START' /root/.openclaw/workspace/TOOLS.md 2>/dev/null || echo 0`,
-    (r) => r.trim(),
-    '0',
-  );
-  return raw === '1' || parseInt(raw, 10) > 0;
+/**
+ * Stored profiles with their token hashes, computed once per request.
+ *
+ * This used to run inside the per-container loop: `listProfiles()` plus one
+ * `getSecret()` per profile, each opening its own SQLite connection, repeated
+ * for every agent. Nothing in it depends on the container, so it is hoisted.
+ */
+interface HashedProfile {
+  profileId: string;
+  providerId: string;
+  label: string;
+  tokenHash: string;
 }
 
-function detectVercel(container: string): { loggedIn: boolean; user: string; team: string } {
-  if (!cliInstalled(container, 'vercel')) {
-    return { loggedIn: false, user: '', team: '' };
-  }
-
-  const whoami = execInContainer(
-    container,
-    'vercel whoami 2>&1 || true',
-    (r) => r.trim(),
-    '',
-  );
-  if (whoami && !whoami.includes('Error:') && !whoami.includes('Not authorized')) {
-    const teamRaw = execInContainer(
-      container,
-      "cat /root/.local/share/com.vercel.cli/config.json 2>/dev/null | grep 'currentTeam' | head -1 | sed 's/.*: *\"//;s/\".*//'",
-      (r) => r.trim(),
-      '',
-    );
-    return { loggedIn: true, user: extractUsername(whoami), team: teamRaw };
-  }
-
-  return { loggedIn: false, user: '', team: '' };
+function loadHashedProfiles(): HashedProfile[] {
+  return listProfiles()
+    .map((p) => ({
+      profileId: p.id,
+      providerId: p.providerId,
+      label: p.label,
+      tokenHash: profileTokenHash(getSecret(p.id), p.providerId),
+    }))
+    .filter((p) => p.tokenHash);
 }
 
 /**
- * Extract just the username from 'vercel whoami' output (strip header lines).
+ * Hash of whatever token each provider currently has installed in the container.
+ *
+ * Computed for every provider, not only those with a stored profile. The probe
+ * has already fetched all of these files in its single exec, so the extra work
+ * is a handful of SHA-256 over short strings — and restricting it would hide the
+ * case that matters most: a token present in the container that matches nothing
+ * in the vault, which is what a credential edited after syncing looks like.
  */
-function extractUsername(raw: string): string {
-  const lines = raw.split('\n').filter(Boolean);
-  // Return the last non-empty line (the actual username)
-  return lines[lines.length - 1]?.trim() || raw;
+function installedHashes(probe: ContainerProbe): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const providerId of Object.keys(TOKEN_FIELD)) {
+    const h = providerTokenHash(probe, providerId);
+    if (h) out.set(providerId, h);
+  }
+  return out;
 }
 
-/**
- * Match detected state to stored credential profiles by comparing token hashes.
- * `hashes` maps a providerId to the hash of the token currently installed in the
- * container. A profile matches when its own token hashes to the same value.
- * Providers whose token cannot be read yield '' and therefore never match.
- */
-function matchProfiles(
-  hashes: Record<string, string>,
-): { profileId: string; providerId: string; label: string }[] {
-  const profiles = listProfiles();
-  const matched: { profileId: string; providerId: string; label: string }[] = [];
-
-  for (const profile of profiles) {
-    const installedHash = hashes[profile.providerId];
-    if (!installedHash) continue;
-
-    const storedHash = profileTokenHash(getSecret(profile.id), profile.providerId);
-    if (storedHash && storedHash === installedHash) {
-      matched.push({ profileId: profile.id, providerId: profile.providerId, label: profile.label });
-    }
-  }
+function matchProfiles(installed: Map<string, string>, profiles: HashedProfile[]) {
+  return profiles
+    .filter((p) => installed.get(p.providerId) === p.tokenHash)
+    .map(({ profileId, providerId, label }) => ({ profileId, providerId, label }));
+}
 
-  return matched;
+function shape(container: string, agentId: string, probe: ContainerProbe, profiles: HashedProfile[]): DetectedStatus {
+  const installed = installedHashes(probe);
+  // `gh` changed the wording: 2.97 prints "…github.com account <user>", older
+  // builds print "…as <user>". The image installs it unpinned from apt, so both
+  // are accepted rather than tracking whichever one ships today.
+  const ghMatch = /Logged in to github\.com (?:as|account) (\S+)/.exec(probe.ghStatus);
+  const githubLoggedIn =
+    probe.cli.gh && !probe.ghStatus.includes('not logged into any GitHub hosts') && !!ghMatch;
+
+  const whoami = probe.vercelWhoami.trim();
+  const vercelLoggedIn =
+    probe.cli.vercel && !!whoami && !whoami.includes('Error:') && !whoami.includes('Not authorized');
+
+  const projects = probe.supabaseProjects.trim();
+  // The exit status is the signal, not the wording. Matching on 'Unauthorized'
+  // recognised only the one failure whose text happened to say so; a missing
+  // token and an unreachable network both printed something else and passed.
+  const supabaseLoggedIn = probe.cli.supabase && probe.supabaseRc === 0 && !!projects;
+  const projectRef = supabaseLoggedIn ? supabaseProjectRef(probe) : '';
+
+  return {
+    container,
+    agentId,
+    displayName: probe.agentName || undefined,
+    githubLoggedIn,
+    githubUser: ghMatch?.[1] ?? '',
+    githubCliInstalled: probe.cli.gh,
+    vercelLoggedIn,
+    vercelUser: vercelLoggedIn ? extractUsername(probe.vercelWhoami) : '',
+    vercelTeam: vercelLoggedIn ? vercelCurrentTeam(probe) : '',
+    vercelCliInstalled: probe.cli.vercel,
+    supabaseLoggedIn,
+    supabaseLinked: !!projectRef,
+    supabaseProjectRef: projectRef,
+    supabaseCliInstalled: probe.cli.supabase,
+    // Presence of the config file is the login signal for both — neither ships a
+    // status command. An empty file now counts as absent, where `test -f` used
+    // to accept it.
+    trelloLoggedIn: !!probe.files.trelloConfig.trim(),
+    trelloCliInstalled: probe.cli.trello,
+    notionLoggedIn: !!probe.files.notionConfig.trim(),
+    toolsMdHasMarkers: probe.toolsMdMarkers > 0,
+    matchedProfiles: matchProfiles(installed, profiles),
+    installedProviders: [...installed.keys()],
+  };
 }
 
 export async function GET(request: NextRequest): Promise<NextResponse> {
@@ -167,8 +159,8 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
   try {
     const url = new URL(request.url);
     const filterAgent = url.searchParams.get('agent');
-    let containers = listAgentContainers();
 
+    let containers = await listAgentContainers();
     if (filterAgent) {
       containers = containers.filter((c) => c.name === filterAgent);
       if (containers.length === 0) {
@@ -176,70 +168,28 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
       }
     }
 
-    const results: (DetectedStatus | DetectionError)[] = [];
-
-    for (const { name, agentId } of containers) {
-      try {
-        const { loggedIn: githubLoggedIn, user: githubUser } = detectGithub(name);
-        const { loggedIn: trelloLoggedIn } = detectTrello(name);
-        const { loggedIn: notionLoggedIn } = detectNotion(name);
-        const { loggedIn: vercelLoggedIn, user: vercelUser, team: vercelTeam } = detectVercel(name);
-        const { loggedIn: supabaseLoggedIn, linked: supabaseLinked, projectRef: supabaseProjectRef } = detectSupabase(name);
-
-        const githubCliInstalled = cliInstalled(name, 'gh');
-        const vercelCliInstalled = cliInstalled(name, 'vercel');
-        const supabaseCliInstalled = cliInstalled(name, 'supabase');
-        const trelloCliInstalled = cliInstalled(name, 'trello');
-        const toolsMdHasMarkers = detectToolsMd(name);
-
-        // Read AGENT_NAME env for display name (may differ from container name)
-        const displayName = execInContainer(
-          name,
-          'printenv AGENT_NAME',
-          (r) => r.trim(),
-          '',
-        ) || undefined;
-
-        // Precise profile matching by token hash — one source of truth for all providers.
-        const matchedProfiles = matchProfiles({
-          'github-pat': providerTokenHash(name, 'github-pat'),
-          vercel: providerTokenHash(name, 'vercel'),
-          supabase: providerTokenHash(name, 'supabase'),
-          trello: providerTokenHash(name, 'trello'),
-          notion: providerTokenHash(name, 'notion'),
-        });
-
-        results.push({
-          container: name,
-          agentId,
-          displayName,
-          githubLoggedIn,
-          githubUser,
-          githubCliInstalled,
-          vercelLoggedIn,
-          vercelUser,
-          vercelTeam,
-          vercelCliInstalled,
-          supabaseLoggedIn,
-          supabaseLinked,
-          supabaseProjectRef,
-          supabaseCliInstalled,
-          trelloLoggedIn,
-          trelloCliInstalled,
-          notionLoggedIn,
-          toolsMdHasMarkers,
-          matchedProfiles,
-        });
-      } catch (e: unknown) {
-        results.push({
-          container: name,
-          agentId,
-          error: (e as Error).message,
-        });
-      }
-    }
+    const profiles = loadHashedProfiles();
+
+    // The callback swallows its own failures: mapWithConcurrency is fail-fast,
+    // so letting one unreachable container reject would discard the results
+    // already computed for every other agent.
+    const agents = await mapWithConcurrency<{ name: string; agentId: string }, DetectedStatus | DetectionError>(
+      containers,
+      AGENT_QUERY_CONCURRENCY,
+      async ({ name, agentId }) => {
+        try {
+          const probe = await probeContainer(name);
+          if (!probe.ok) {
+            return { container: name, agentId, error: 'Container did not respond' };
+          }
+          return shape(name, agentId, probe, profiles);
+        } catch (e: unknown) {
+          return { container: name, agentId, error: (e as Error).message };
+        }
+      },
+    );
 
-    return NextResponse.json({ agents: results });
+    return NextResponse.json({ agents });
   } catch (e: unknown) {
     return NextResponse.json({ error: (e as Error).message }, { status: 500 });
   }

package/app/api/credentials/route.ts

@@ -7,6 +7,9 @@ import { requireAuthJWT } from '@/lib/rev4a-auth';
 export const dynamic = 'force-dynamic';
 
 export async function GET(request: NextRequest): Promise<NextResponse> {
+  // requireAuthJWT was imported for the POST below and never applied here,
+  // leaving this the only unauthenticated route in the credentials feature.
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
   try {
     const profiles = listProfiles();
     return NextResponse.json({ profiles, providers: CREDENTIAL_PROVIDERS });

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

@@ -5,7 +5,7 @@
  * Uses base64-safe write — no heredoc shell escaping issues.
  *
  * Body:
- *   { "containerName": "openclaw-atlas", "model": "rev4a/deepseek-v4-flash", "fallbacks": ["rev4a/deepseek-v4-pro"] }
+ *   { "containerName": "openclaw-atlas", "model": "rev4a/deepseek-flash", "fallbacks": ["rev4a/deepseek-v4-pro"] }
  */
 import { NextRequest, NextResponse } from 'next/server';
 import { execSync } from 'child_process';
@@ -56,6 +56,21 @@ function readFileFromContainer(container: string, remotePath: string): string {
   }
 }
 
+/**
+ * Fallbacks already on a model entry, for a request that did not send any.
+ *
+ * `fallbacks` omitted and `fallbacks: []` are different requests. The first means
+ * "leave them alone", the second "clear them". This route used to treat both as
+ * `[]`, so any caller that sent only `model` silently erased the list.
+ */
+function existingFallbacks(model: unknown): string[] {
+  if (model && typeof model === 'object') {
+    const f = (model as { fallbacks?: unknown }).fallbacks;
+    if (Array.isArray(f)) return f.filter((x): x is string => typeof x === 'string');
+  }
+  return [];
+}
+
 export async function PUT(request: NextRequest) {
   const denied = await requireAuthJWT(request); if (denied) return denied as any;
   try {
@@ -99,8 +114,8 @@ export async function PUT(request: NextRequest) {
     const mainAgent = list.find((a) => a.id === 'main');
     if (mainAgent) {
       const primary = ensureRev4aPrefix(body.model);
-      let fallbacks = dedupe(ensureRev4aPrefixes(body.fallbacks || []));
-      // Remove the primary model dai fallback
+      let fallbacks = dedupe(ensureRev4aPrefixes(body.fallbacks ?? existingFallbacks(mainAgent.model)));
+      // The primary never doubles as its own fallback.
       fallbacks = fallbacks.filter((fb) => fb !== primary);
       mainAgent.model = {
         primary,
@@ -111,7 +126,7 @@ export async function PUT(request: NextRequest) {
     const defaults = (agents.defaults || {}) as Record<string, unknown>;
     {
       const primary = ensureRev4aPrefix(body.model);
-      let fallbacks = dedupe(ensureRev4aPrefixes(body.fallbacks || []));
+      let fallbacks = dedupe(ensureRev4aPrefixes(body.fallbacks ?? existingFallbacks(defaults.model)));
       fallbacks = fallbacks.filter((fb) => fb !== primary);
       defaults.model = {
         primary,
@@ -144,8 +159,10 @@ export async function PUT(request: NextRequest) {
       status: 'ok',
       agent: safeContainer,
       model: {
-        primary: body.model,
-        fallbacks: body.fallbacks || [],
+        // Report what was written, not what was asked: both prefixed, and the
+        // fallbacks as preserved or replaced.
+        primary: (defaults.model as { primary: string }).primary,
+        fallbacks: (defaults.model as { fallbacks: string[] }).fallbacks,
       },
       verify: { ok: verifyOk, bytes: verifyBytes },
     });

package/app/api/gateway/provider/keys.ts

@@ -15,8 +15,16 @@ function ensureDir(): void {
   }
 }
 
+/** Best-effort: files written before 0600 was enforced are world-readable. */
+function tightenMode(): void {
+  try {
+    if ((fs.statSync(KEYS_PATH).mode & 0o077) !== 0) fs.chmodSync(KEYS_PATH, 0o600);
+  } catch { /* absent, or not ours to change */ }
+}
+
 export function readProviderKeys(): ProviderKeys {
   ensureDir();
+  tightenMode();
   try {
     const raw = fs.readFileSync(KEYS_PATH, 'utf-8');
     return JSON.parse(raw);
@@ -34,5 +42,9 @@ export function readProviderKeys(): ProviderKeys {
 
 export function writeProviderKeys(keys: ProviderKeys): void {
   ensureDir();
-  fs.writeFileSync(KEYS_PATH, JSON.stringify(keys, null, 2), 'utf-8');
+  // Every upstream credential and the gateway password live here: owner-only, like
+  // the .env file. `mode` applies only when the file is created, so an existing
+  // file is tightened explicitly.
+  fs.writeFileSync(KEYS_PATH, JSON.stringify(keys, null, 2), { encoding: 'utf-8', mode: 0o600 });
+  fs.chmodSync(KEYS_PATH, 0o600);
 }

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

@@ -8,7 +8,7 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { execSync } from 'child_process';
 import { readProviderKeys, writeProviderKeys } from './keys';
-import { syncAllAgents } from '../sync';
+import { dockerUnreachableReason, syncAllAgents, type SyncOutcome } from '../sync';
 import { detectProviderGatewayUrl } from '@/lib/docker-utils';
 import { getPricing } from '@/lib/model-pricing';
 import { loadModelsConfig, toggleModelOverride, type ModelConfigEntry } from '@/lib/model-catalogue';
@@ -192,6 +192,20 @@ export async function GET(request: NextRequest) {
   return NextResponse.json({ providers });
 }
 
+/**
+ * Run the sync without letting an unexpected throw turn a committed change into a
+ * 500. `syncAllAgents` already reports Docker and per-container failures as data;
+ * this only guards the rest.
+ */
+function runSync(): SyncOutcome {
+  try {
+    return syncAllAgents();
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, activeModels: 0, total: 0, synced: [], stopped: [], failed: [], configError: msg, summary: `Not applied to any agent: ${msg}.` };
+  }
+}
+
 export async function POST(request: NextRequest) {
   const denied = await requireAuthJWT(request);
   if (denied) return denied;
@@ -199,8 +213,12 @@ export async function POST(request: NextRequest) {
     const body: { provider?: string; apiKey?: string; _syncOnly?: boolean } = await request.json();
 
     if (body._syncOnly) {
-      const syncResults = syncAllAgents();
-      return NextResponse.json({ status: 'ok', sync: syncResults });
+      // Here the sync *is* the operation, so its outcome is the status.
+      const sync = runSync();
+      return NextResponse.json(
+        sync.ok ? { status: 'ok', sync } : { status: 'error', error: sync.summary, sync },
+        { status: sync.ok ? 200 : 502 },
+      );
     }
 
     const providerName = body.provider;
@@ -210,15 +228,11 @@ export async function POST(request: NextRequest) {
     const apiKeyValue = body.apiKey;
     const isRemove = !apiKeyValue || apiKeyValue.trim() === '';
     setProviderApiKey(providerName, isRemove ? null : apiKeyValue!.trim());
-    let syncResults: string[] = [];
-    try {
-      syncResults = syncAllAgents();
-    } catch (se) {
-      syncResults = [`Sync error: ${se instanceof Error ? se.message : String(se)}`];
-    }
+    // The key is saved whatever the sync does next; report the two separately.
+    const sync = runSync();
     return NextResponse.json({
       status: 'ok', provider: providerName, configured: !isRemove,
-      sync: syncResults,
+      sync,
     });
   } catch (e: unknown) {
     return NextResponse.json({ status: 'error', error: e instanceof Error ? e.message : String(e) }, { status: 500 });
@@ -238,9 +252,26 @@ export async function PUT(request: NextRequest) {
     const idx = models.findIndex((m) => m.id === modelId);
     if (idx === -1) return NextResponse.json({ status: 'error', error: `Model not found: ${modelId}` }, { status: 404 });
 
+    // Refuse up front when the sync cannot happen at all. Saving anyway would leave
+    // the checkbox on /gateway saying one thing and every agent holding another.
+    // Only a whole-fleet outage is refused this way: once Docker answers, a container
+    // that fails individually is reported in `sync`, because undoing the override
+    // would not undo the containers that did receive it. Provider key saves are not
+    // gated like this — the first-run wizard saves keys without reading the response
+    // and may run before Docker is up, so a refusal there would be silent.
+    const unreachable = dockerUnreachableReason();
+    if (unreachable) {
+      return NextResponse.json({
+        status: 'error',
+        error: `Not changed: Docker is unreachable (${unreachable}). Nothing was saved, so the Gateway still matches the agents.`,
+      }, { status: 503 });
+    }
+
     toggleModelOverride(modelId, enabled);
-    const syncResults = syncAllAgents();
-    return NextResponse.json({ status: 'ok', modelId, enabled, provider: models[idx].provider, sync: syncResults });
+    // `status` is the toggle, committed at this point. `sync` is whether the fleet
+    // got it — reported alongside, not folded into `status`.
+    const sync = runSync();
+    return NextResponse.json({ status: 'ok', modelId, enabled, provider: models[idx].provider, sync });
   } catch (e: unknown) {
     return NextResponse.json({ status: 'error', error: e instanceof Error ? e.message : String(e) }, { status: 500 });
   }