@flame0510/project-aether 1.1.12 → 1.1.14

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

@@ -12,6 +12,7 @@ import { syncAllAgents } from '../sync';
 import { detectProviderGatewayUrl } from '@/lib/docker-utils';
 import { getPricing } from '@/lib/model-pricing';
 import { loadModelsConfig, toggleModelOverride, type ModelConfigEntry } from '@/lib/model-catalogue';
+import { getLivePricing } from '@/lib/openrouter-pricing';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
 
 export const dynamic = 'force-dynamic';
@@ -136,8 +137,37 @@ function restartService(): { stdout: string; stderr: string } {
 /* ------------------------------------------------------------------ */
 
 export async function GET(request: NextRequest) {
-  const allModels = loadModelsConfig();
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied;
   const providerKeys = readProviderKeys();
+
+  // ?summary=1 — just "which providers have a key", no models, no pricing.
+  // The full response awaits live pricing from OpenRouter, a network round trip
+  // that costs ~2.4s cold. Callers that only need the boolean (the agents page,
+  // to decide whether to warn about a missing provider) must not pay for it, and
+  // must not be left guessing while it's in flight.
+  if (request.nextUrl.searchParams.get('summary') === '1') {
+    return NextResponse.json({
+      providers: Object.entries(PROVIDER_CONFIGS).map(([key, cfg]) => ({
+        provider: key,
+        label: cfg.label,
+        configured: !!providerKeys[key],
+      })),
+    });
+  }
+
+  const allModels = loadModelsConfig();
+
+  // Live prices overlaid on the static file, which drifts. Fetched regardless
+  // of whether OpenRouter is configured: the catalogue is public, and prices
+  // are most useful precisely to someone still deciding whether to enable it.
+  // Best-effort — an empty map means the static values stand in.
+  //
+  // Modality deliberately stays on the curated value: sync.ts provisions
+  // containers from it, so taking a different one upstream would advertise
+  // inputs the agent was never configured to accept.
+  const livePricing = await getLivePricing(allModels.map((m) => m.id));
+
   const providers = Object.entries(PROVIDER_CONFIGS).map(([key, cfg]) => {
     const providerModels = allModels.filter((m) => m.provider === key);
     return {
@@ -145,8 +175,14 @@ export async function GET(request: NextRequest) {
       baseUrl: cfg.baseUrl, docsUrl: cfg.docsUrl,
       models: providerModels.map((m) => {
         const entry: Record<string, unknown> = { id: m.id, name: m.name, enabled: m.enabled };
-        const p = getPricing(m.id);
-        if (p) entry.pricing = p;
+        const livePrice = livePricing.get(m.id);
+        if (livePrice) {
+          entry.pricing = livePrice;
+          entry.pricingLive = true;
+        } else {
+          const staticPrice = getPricing(m.id);
+          if (staticPrice) entry.pricing = staticPrice;
+        }
         if (m.modality) entry.modality = m.modality;
         return entry;
       }),
@@ -157,7 +193,8 @@ export async function GET(request: NextRequest) {
 }
 
 export async function POST(request: NextRequest) {
-  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied;
   try {
     const body: { provider?: string; apiKey?: string; _syncOnly?: boolean } = await request.json();
 
@@ -189,7 +226,8 @@ export async function POST(request: NextRequest) {
 }
 
 export async function PUT(request: NextRequest) {
-  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied;
   try {
     const body: { modelId?: string; enabled?: boolean } = await request.json();
     const { modelId, enabled } = body;

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,158 +59,105 @@ 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' };
   }
 }
 
 export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied;
   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,
@@ -205,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/models/route.ts

@@ -48,6 +48,8 @@ function loadModelsConfig(): ModelsConfigEntry[] {
 
 export async function GET(_req: NextRequest): Promise<NextResponse> {
   const request = _req;
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied;
   const allModels = loadModelsConfig();
   const providerKeys = readProviderKeys();
   const configured = new Set(Object.keys(providerKeys));

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/setup/agent-image/route.ts

@@ -12,9 +12,10 @@
  * Only one download at a time — returns 409 if already running.
  * Cleans up the docker process if the client disconnects.
  */
-import { NextResponse } from 'next/server';
+import { NextResponse, type NextRequest } from 'next/server';
 import { downloadAgentImage, getIsDownloading } from '@/lib/buildAgentImage';
 import { execSync } from 'child_process';
+import { requireAuthIfConfigured } from '@/lib/rev4a-auth';
 
 export const dynamic = 'force-dynamic';
 
@@ -30,7 +31,9 @@ function dockerOk(): boolean {
   }
 }
 
-export async function GET(): Promise<NextResponse> {
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthIfConfigured(request);
+  if (denied) return denied;
   if (!dockerOk()) {
     return NextResponse.json({ exists: false });
   }
@@ -55,7 +58,9 @@ export async function GET(): Promise<NextResponse> {
   }
 }
 
-export async function POST(): Promise<Response> {
+export async function POST(request: NextRequest): Promise<Response> {
+  const denied = await requireAuthIfConfigured(request);
+  if (denied) return denied;
   if (getIsDownloading()) {
     return new Response(
       JSON.stringify({ error: 'A download is already in progress' }),

package/app/api/setup/password/route.ts

@@ -15,6 +15,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as crypto from 'crypto';
 import { ENV_FILE } from '@/lib/rev4a-paths';
+import { isConfigured } from '@/lib/rev4a-auth';
 
 export const dynamic = 'force-dynamic';
 export const runtime = 'nodejs';
@@ -23,21 +24,33 @@ function generateSecret(len: number): string {
   return crypto.randomBytes(len).toString('base64url').slice(0, len);
 }
 
+/**
+ * True only if an actual assignment line for `key` exists — a commented-out
+ * or incidental mention (`# old REV4A_TOKEN=…`) does not count. A substring
+ * check here would report the key as present and skip generating it, leaving
+ * the instance without a usable secret.
+ */
+function hasEnvKey(content: string, key: string): boolean {
+  return content.split('\n').some((line) => line.trimStart().startsWith(`${key}=`));
+}
+
+/** Replace the assignment line for `key`, or append one if none exists. */
+function upsertEnvLine(content: string, key: string, value: string): string {
+  const lines = content.split('\n');
+  let replaced = false;
+  const updated = lines.map((line) => {
+    if (!replaced && line.trimStart().startsWith(`${key}=`)) {
+      replaced = true;
+      return `${key}=${value}`;
+    }
+    return line;
+  });
+  if (!replaced) updated.push(`${key}=${value}`);
+  return updated.join('\n');
+}
+
 export async function POST(request: Request): Promise<NextResponse> {
-  // Check both env and .env file (same fallback pattern as login/status routes)
-  let currentPassword = process.env.REV4A_PASSWORD;
-  if (typeof currentPassword !== 'string' || currentPassword.length === 0) {
-    try {
-      if (fs.existsSync(ENV_FILE)) {
-        const content = fs.readFileSync(ENV_FILE, 'utf-8');
-        const match = content.match(/^REV4A_PASSWORD=(.+)$/m);
-        if (match && match[1].trim()) {
-          currentPassword = match[1].trim();
-        }
-      }
-    } catch { /* ignore */ }
-  }
-  if (typeof currentPassword === 'string' && currentPassword.length > 0) {
+  if (isConfigured()) {
     return NextResponse.json(
       { error: 'Password is already configured. Use the Config page to change it.' },
       { status: 409 },
@@ -72,30 +85,12 @@ export async function POST(request: Request): Promise<NextResponse> {
       content = fs.readFileSync(ENV_FILE, 'utf-8');
     }
 
-    // Ensure password line
-    if (content.includes('REV4A_PASSWORD=')) {
-      content = content
-        .split('\n')
-        .map((line) =>
-          line.startsWith('REV4A_PASSWORD=')
-            ? 'REV4A_PASSWORD=' + body.password
-            : line,
-        )
-        .join('\n');
-    } else {
-      content += '\nREV4A_PASSWORD=' + body.password + '\n';
+    content = upsertEnvLine(content, 'REV4A_PASSWORD', body.password);
+    if (!hasEnvKey(content, 'REV4A_JWT_SECRET')) {
+      content = upsertEnvLine(content, 'REV4A_JWT_SECRET', generateSecret(64));
     }
-
-    // Generate JWT secret if missing
-    if (!content.includes('REV4A_JWT_SECRET=')) {
-      const secret = generateSecret(64);
-      content += '\nREV4A_JWT_SECRET=' + secret + '\n';
-    }
-
-    // Generate API token if missing
-    if (!content.includes('REV4A_TOKEN=')) {
-      const token = generateSecret(32);
-      content += '\nREV4A_TOKEN=' + token + '\n';
+    if (!hasEnvKey(content, 'REV4A_TOKEN')) {
+      content = upsertEnvLine(content, 'REV4A_TOKEN', generateSecret(32));
     }
 
     fs.writeFileSync(ENV_FILE, content.trim() + '\n', { encoding: 'utf-8', mode: 0o600 });

package/app/api/setup/restart/route.ts

@@ -12,15 +12,21 @@
  *   2. Otherwise send SIGTERM to the current process. The parent process
  *      manager (npx rev4a all or a shell wrapper) should restart it.
  */
-import { NextResponse } from 'next/server';
+import { NextResponse, type NextRequest } from 'next/server';
 import * as fs from 'fs';
 import { execSync } from 'child_process';
 import { ENV_FILE } from '@/lib/rev4a-paths';
+import { requireAuthIfConfigured } from '@/lib/rev4a-auth';
 
 export const dynamic = 'force-dynamic';
 export const runtime = 'nodejs';
 
-export async function POST(): Promise<NextResponse> {
+export async function POST(request: NextRequest): Promise<NextResponse> {
+  // Open only during initial setup (before a password exists). Once
+  // configured, this triggers a production service restart and must
+  // require a valid session like every other privileged route.
+  const denied = await requireAuthIfConfigured(request);
+  if (denied) return denied;
   try {
     if (!fs.existsSync(ENV_FILE)) {
       return NextResponse.json({ error: '.env file not found' }, { status: 500 });

package/app/api/skills/delete/route.js

@@ -3,8 +3,8 @@ import fs from 'fs';
 import path from 'path';
 import { execFileSync } from 'child_process';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
+import { SHARED_SKILLS_DIR } from '@/lib/rev4a-paths';
 
-const SHARED_SKILLS_DIR = '/docker/shared-skills';
 
 /**
  * DELETE /api/skills/delete

package/app/api/skills/promote/route.js

@@ -3,8 +3,8 @@ import fs from 'fs';
 import path from 'path';
 import { execSync, execFileSync } from 'child_process';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
+import { SHARED_SKILLS_DIR } from '@/lib/rev4a-paths';
 
-const SHARED_SKILLS_DIR = '/docker/shared-skills';
 
 /**
  * POST /api/skills/promote