@flame0510/project-aether 1.1.9

package/app/api/cost-override/route.ts

@@ -0,0 +1,46 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { openDb } from '@/lib/db';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+const CREATE_TABLE = `CREATE TABLE IF NOT EXISTS cost_override
+  (month TEXT PRIMARY KEY, amount REAL, note TEXT, updated_at INTEGER)`;
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied;
+  try {
+    const db = openDb(false);
+    db.prepare(CREATE_TABLE).run();
+    const month = new Date().toISOString().slice(0, 7);
+    const row = db.prepare('SELECT * FROM cost_override WHERE month = ?').get(month);
+    db.close();
+    return NextResponse.json(row ?? { month, amount: null, note: null });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}
+
+export async function POST(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied;
+  try {
+    const body = (await request.json()) as { amount?: unknown; note?: string; month?: string };
+    const { amount, note, month } = body ?? {};
+    const m = month ?? new Date().toISOString().slice(0, 7);
+    const parsed = Number.parseFloat(String(amount));
+    if (amount === undefined || !Number.isFinite(parsed)) {
+      return NextResponse.json({ error: 'amount required' }, { status: 400 });
+    }
+    const db = openDb(false);
+    db.prepare(CREATE_TABLE).run();
+    db.prepare(
+      'INSERT OR REPLACE INTO cost_override (month, amount, note, updated_at) VALUES (?,?,?,?)',
+    ).run(m, parsed, note ?? null, Date.now());
+    db.close();
+    return NextResponse.json({ ok: true, month: m, amount: parsed });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/api/costs/route.ts

@@ -0,0 +1,84 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { openDb } from '@/lib/db';
+import { isBillableDollarModel } from '@/lib/billing';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+// In-memory cache: 30 second TTL for cost aggregation
+let costsCache: { data: unknown; ts: number } | null = null;
+const CACHE_TTL_MS = 30_000;
+
+interface ModelCostRow {
+  model: string | null;
+  cost_usd: number;
+  tokens_in: number;
+  tokens_out: number;
+}
+
+function sumBillableCosts(rows: ModelCostRow[]): number {
+  return rows.reduce(
+    (sum, row) => (isBillableDollarModel(row.model) ? sum + Number(row.cost_usd ?? 0) : sum),
+    0,
+  );
+}
+
+function getStartOfDaySeconds(): number {
+  const now = new Date();
+  now.setHours(0, 0, 0, 0);
+  return Math.floor(now.getTime() / 1000);
+}
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  // Return cached result if fresh
+  if (costsCache && Date.now() - costsCache.ts < CACHE_TTL_MS) {
+    return NextResponse.json(costsCache.data);
+  }
+
+  try {
+    const db = openDb();
+    const startOfDay = getStartOfDaySeconds();
+
+    const todayRows = db
+      .prepare(
+        `SELECT model,
+          COALESCE(SUM(cost_usd), 0) AS cost_usd,
+          COALESCE(SUM(tokens_in), 0) AS tokens_in,
+          COALESCE(SUM(tokens_out), 0) AS tokens_out
+         FROM sessions WHERE started_at >= ?
+         GROUP BY model ORDER BY cost_usd DESC`,
+      )
+      .all(startOfDay) as ModelCostRow[];
+
+    const allTimeRows = db
+      .prepare(
+        `SELECT model,
+          COALESCE(SUM(cost_usd), 0) AS cost_usd,
+          COALESCE(SUM(tokens_in), 0) AS tokens_in,
+          COALESCE(SUM(tokens_out), 0) AS tokens_out
+         FROM sessions
+         GROUP BY model ORDER BY cost_usd DESC`,
+      )
+      .all() as ModelCostRow[];
+
+    const today = sumBillableCosts(todayRows);
+    const sessionsAllTime = sumBillableCosts(allTimeRows);
+
+    const byModel = todayRows.filter((row) => isBillableDollarModel(row.model));
+
+    db.close();
+
+    const result = {
+      today,
+      allTime: sessionsAllTime,
+      allTimeSource: 'sessions_billable',
+      byModel,
+    };
+    costsCache = { data: result, ts: Date.now() };
+
+    return NextResponse.json(result);
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/api/credentials/[id]/reveal/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from 'next/server';
+import { getProfile, revealSecret } from '@/lib/credentials/vault';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+export async function POST(request: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const { id } = await params;
+    const profile = getProfile(id);
+    if (!profile) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+
+    const secret = revealSecret(id);
+    return NextResponse.json({ secret });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/api/credentials/[id]/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse } from 'next/server';
+import { getProfile, updateProfile, deleteProfile } from '@/lib/credentials/vault';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const { id } = await params;
+    const profile = getProfile(id);
+    if (!profile) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+    return NextResponse.json(profile);
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}
+
+export async function PATCH(request: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const { id } = await params;
+    const body = await request.json() as { label?: string; secret?: Record<string, string> };
+    const { label, secret } = body;
+
+    if (!label) {
+      return NextResponse.json({ error: 'label is required' }, { status: 400 });
+    }
+
+    updateProfile(id, label, secret ?? {});
+    return NextResponse.json({ ok: true });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}
+
+export async function DELETE(request: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const { id } = await params;
+    deleteProfile(id);
+    return NextResponse.json({ ok: true });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/api/credentials/[id]/sync/route.ts

@@ -0,0 +1,58 @@
+import { NextResponse } from 'next/server';
+import { getProfile, markSynced } from '@/lib/credentials/vault';
+import { syncProfileToAgents, cleanAgentProviders } from '@/lib/credentials/delivery';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+export async function POST(request: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const { id } = await params;
+    const profile = getProfile(id);
+    if (!profile) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+
+    const body = await request.json().catch(() => ({})) as { containers?: string[] };
+    const selectedContainers = body.containers;
+
+    const results = await syncProfileToAgents(id, profile.providerId, selectedContainers);
+
+    const anyError = results.some((r) => r.status === 'error');
+    markSynced(id, anyError ? 'error' : 'active');
+
+    return NextResponse.json({ results });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}
+
+/**
+ * DELETE /api/credentials/[id]/sync
+ * De-sync a credential from a single container (removes it without touching others).
+ * Body: { container: "prometheus" }
+ */
+export async function DELETE(request: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const { id } = await params;
+    const profile = getProfile(id);
+    if (!profile) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+
+    const body = await request.json().catch(() => ({})) as { container?: string };
+    const container = body.container;
+    if (!container) {
+      return NextResponse.json({ error: 'container is required' }, { status: 400 });
+    }
+
+    cleanAgentProviders(container, profile.providerId);
+    markSynced(id, 'active');
+
+    return NextResponse.json({ ok: true });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,246 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { listProfiles, getSecret } from '@/lib/credentials/vault';
+import {
+  listAgentContainers,
+  execInContainer,
+  cliInstalled,
+  providerTokenHash,
+  profileTokenHash,
+  detectTrello,
+  detectNotion,
+} from '@/lib/credentials/detect';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+interface DetectedStatus {
+  container: string;
+  agentId: string;
+  displayName?: string;
+  githubLoggedIn: boolean;
+  githubUser: string;
+  githubCliInstalled: boolean;
+  vercelLoggedIn: boolean;
+  vercelUser: string;
+  vercelTeam: string;
+  vercelCliInstalled: boolean;
+  supabaseLoggedIn: boolean;
+  supabaseLinked: boolean;
+  supabaseProjectRef: string;
+  supabaseCliInstalled: boolean;
+  trelloLoggedIn: boolean;
+  trelloCliInstalled: boolean;
+  notionLoggedIn: boolean;
+  toolsMdHasMarkers: boolean;
+  matchedProfiles: { profileId: string; providerId: string; label: string }[];
+}
+
+interface DetectionError {
+  container: string;
+  agentId: string;
+  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] ?? '' };
+}
+
+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;
+}
+
+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: '' };
+}
+
+/**
+ * Extract just the username from 'vercel whoami' output (strip header lines).
+ */
+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;
+}
+
+/**
+ * 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 });
+    }
+  }
+
+  return matched;
+}
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const url = new URL(request.url);
+    const filterAgent = url.searchParams.get('agent');
+    let containers = listAgentContainers();
+
+    if (filterAgent) {
+      containers = containers.filter((c) => c.name === filterAgent);
+      if (containers.length === 0) {
+        return NextResponse.json({ error: `Agent "${filterAgent}" not found` }, { status: 404 });
+      }
+    }
+
+    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,
+        });
+      }
+    }
+
+    return NextResponse.json({ agents: results });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/api/credentials/route.ts

@@ -0,0 +1,33 @@
+import { type NextRequest } from "next/server";
+import { NextResponse } from 'next/server';
+import { listProfiles, createProfile } from '@/lib/credentials/vault';
+import { CREDENTIAL_PROVIDERS } from '@/lib/credentials/providers';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  try {
+    const profiles = listProfiles();
+    return NextResponse.json({ profiles, providers: CREDENTIAL_PROVIDERS });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  try {
+    const body = await request.json() as { providerId?: string; label?: string; secret?: Record<string, string> };
+    const { providerId, label, secret } = body;
+
+    if (!providerId || !label || !secret) {
+      return NextResponse.json({ error: 'providerId, label, and secret are required' }, { status: 400 });
+    }
+
+    const id = createProfile(providerId, label, secret);
+    return NextResponse.json({ id }, { status: 201 });
+  } catch (e: unknown) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/api/crons/[id]/route.ts

@@ -0,0 +1,69 @@
+import { NextResponse, type NextRequest } from 'next/server';
+
+import { patchCronJob, removeCronJob } from '@/lib/openclaw-cron';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+const CONTAINER_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
+
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+
+  const { id } = await params;
+  let body: Record<string, unknown>;
+  try {
+    body = (await request.json()) as Record<string, unknown>;
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const allowed: Record<string, unknown> = {};
+  if (typeof body.enabled === 'boolean') allowed.enabled = body.enabled;
+  if (typeof body.containerName === 'string') {
+    if (!CONTAINER_NAME_RE.test(body.containerName)) {
+      return NextResponse.json({ error: 'Invalid containerName format' }, { status: 400 });
+    }
+    allowed.containerName = body.containerName;
+  }
+
+  if (Object.keys(allowed).length === 0) {
+    return NextResponse.json({ error: 'No patchable fields provided' }, { status: 400 });
+  }
+
+  const result = patchCronJob(id, allowed);
+  if (!result.ok) {
+    const status = result.error?.includes('not found') ? 404
+      : result.error?.includes('gateway') || result.error?.includes('Failed') ? 502
+      : 500;
+    return NextResponse.json({ error: result.error }, { status });
+  }
+
+  return NextResponse.json(result.job);
+}
+
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+
+  const { id } = await params;
+  const { searchParams } = new URL(request.url);
+  const containerName = searchParams.get('containerName') ?? undefined;
+
+  if (containerName !== undefined && !CONTAINER_NAME_RE.test(containerName)) {
+    return NextResponse.json({ error: 'Invalid containerName format' }, { status: 400 });
+  }
+
+  const result = removeCronJob(id, containerName);
+  if (!result.ok) {
+    const status = result.error?.includes('not found') ? 404 : 502;
+    return NextResponse.json({ error: result.error }, { status });
+  }
+
+  return NextResponse.json({ ok: true });
+}

package/app/api/crons/route.ts

@@ -0,0 +1,12 @@
+import { type NextRequest } from "next/server";
+import { NextResponse } from 'next/server';
+
+import { listOpenClawCronJobs } from '@/lib/openclaw-cron';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const result = await listOpenClawCronJobs();
+  return NextResponse.json(result.jobs);
+}

package/app/api/crons/runs/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse, type NextRequest } from 'next/server';
+
+import { getCronRuns } from '@/lib/openclaw-cron';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+export const maxDuration = 60; // docker exec + gateway API call can take up to 15s
+
+const CONTAINER_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
+
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request); if (denied) return denied as any;
+  const { searchParams } = new URL(request.url);
+  const containerName = searchParams.get('containerName');
+  const jobId = searchParams.get('jobId');
+  const limit = Math.min(parseInt(searchParams.get('limit') ?? '20', 10) || 20, 100);
+
+  if (!containerName || !CONTAINER_NAME_RE.test(containerName)) {
+    return NextResponse.json({ error: 'Missing or invalid containerName' }, { status: 400 });
+  }
+  if (!jobId || typeof jobId !== 'string' || jobId.length < 8) {
+    return NextResponse.json({ error: 'Missing or invalid jobId' }, { status: 400 });
+  }
+
+  const result = getCronRuns(containerName, jobId, limit);
+  if (!result.ok) {
+    return NextResponse.json({ error: result.error, entries: [] }, { status: 502 });
+  }
+
+  return NextResponse.json({ entries: result.entries });
+}

package/app/api/debug/route.ts

@@ -0,0 +1,11 @@
+import { type NextRequest } from "next/server";
+import { NextResponse } from 'next/server';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export async function GET(request: NextRequest) {
+  return NextResponse.json({
+    hasPassword: !!process.env.REV4A_PASSWORD,
+    hasJwtSecret: !!process.env.REV4A_JWT_SECRET,
+    hasToken: !!process.env.REV4A_TOKEN,
+  });
+}