ugly-app 0.1.518 → 0.1.521

package/src/cli/serverLogQueryApi.ts

@@ -1,68 +1,7 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { getUglyBotUrl } from '../shared/uglyBotUrl.js';
-import { readUglyAppConfig } from './uglyappConfig.js';
+import { pgQuery } from '../server/Pg.js';
+import { closePg, initPg } from '../server/NodePool.js';
 
-interface AuthConfig {
-  token: string;
-  userId: string;
-  serverUrl: string;
-}
-
-function readAuth(): AuthConfig {
-  const authPath = path.join(os.homedir(), '.ugly-bot', 'auth.json');
-  if (!fs.existsSync(authPath)) {
-    throw new Error('Not logged in. Run: ugly-app login');
-  }
-  return JSON.parse(fs.readFileSync(authPath, 'utf-8')) as AuthConfig;
-}
-
-/** Returns the currently-logged-in developer's userId, used as devTunnelId for error:dev. */
-export function getCurrentDevTunnelId(): string {
-  return readAuth().userId;
-}
-
-function getAppApiUrl(): string {
-  return getUglyBotUrl();
-}
-
-function getProjectId(): string | undefined {
-  const config = readUglyAppConfig(process.cwd());
-  return config?.projectId ?? undefined;
-}
-
-async function adminRequest<T>(
-  op: string,
-  input: Record<string, unknown>,
-): Promise<T> {
-  const auth = readAuth();
-  const appApiUrl = getAppApiUrl();
-  const res = await fetch(`${appApiUrl}/request`, {
-    method: 'POST',
-    headers: {
-      'Authorization': `Bearer ${auth.token}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({ function: op, input }),
-  });
-
-  if (!res.ok) {
-    const body = await res.text().catch(() => '');
-    if (res.status === 401) {
-      throw new Error(
-        'Authentication failed — token may be expired. Run: ugly-app login',
-      );
-    }
-    throw new Error(`${op} failed: ${res.status} ${body}`);
-  }
-
-  // app's /request route sends the raw handler return value via res.json(result)
-  // (see app/server/backend/Request.ts:510). Don't unwrap a `.result` field —
-  // it doesn't exist.
-  const data = (await res.json()) as T;
-  return data;
-}
+type AdminCollection = 'errorLog' | 'perfLog' | 'feedbackReport';
 
 function formatTimestamp(created: unknown): string {
   if (created instanceof Date) {
@@ -79,44 +18,47 @@ function formatTimestamp(created: unknown): string {
 
 function formatErrorDoc(doc: Record<string, unknown>): string {
   const ts = formatTimestamp(doc['created']);
-  const level = String(doc['level'] ?? 'error').toUpperCase().padEnd(5);
-  const source = doc['source'] ? `[${doc['source']}]` : '';
-  const message = String(doc['message'] ?? '');
-  const userId = doc['userId'] ? ` user:${doc['userId']}` : '';
-  const stack = doc['stack']
-    ? `\n  ${String(doc['stack']).split('\n').slice(0, 3).join('\n  ')}`
+  const data = (doc['data'] ?? {}) as Record<string, unknown>;
+  const level = String(data['level'] ?? 'error').toUpperCase().padEnd(5);
+  const source = data['source'] ? `[${data['source']}]` : '';
+  const message = String(data['message'] ?? '');
+  const userId = data['userId'] ? ` user:${data['userId']}` : '';
+  const stack = data['stack']
+    ? `\n  ${String(data['stack']).split('\n').slice(0, 3).join('\n  ')}`
     : '';
   return `${ts} ${level} ${source} ${message}${userId}${stack}`;
 }
 
 function formatPerfDoc(doc: Record<string, unknown>): string {
   const ts = formatTimestamp(doc['created']);
-  const op = String(doc['operation'] ?? '');
-  const ms = doc['durationMs'] != null ? `${doc['durationMs']}ms` : '';
-  const userId = doc['userId'] ? ` user:${doc['userId']}` : '';
+  const data = (doc['data'] ?? {}) as Record<string, unknown>;
+  const op = String(data['operation'] ?? '');
+  const ms = data['durationMs'] != null ? `${data['durationMs']}ms` : '';
+  const userId = data['userId'] ? ` user:${data['userId']}` : '';
   return `${ts} ${op} ${ms}${userId}`;
 }
 
 function formatFeedbackDoc(doc: Record<string, unknown>): string {
   const ts = formatTimestamp(doc['created']);
-  const type = String(doc['type'] ?? '').toUpperCase().padEnd(7);
-  const message = String(doc['description'] ?? doc['message'] ?? '');
+  const data = (doc['data'] ?? {}) as Record<string, unknown>;
+  const type = String(data['type'] ?? '').toUpperCase().padEnd(7);
+  const message = String(data['description'] ?? data['message'] ?? '');
   const lines = [`${ts} [${type}] ${message}`];
 
-  if (doc['status']) lines.push(`  Status: ${doc['status']}`);
-  if (doc['userId']) lines.push(`  User: ${doc['userId']}`);
-  if (doc['url']) lines.push(`  URL: ${doc['url']}`);
-  if (doc['screenshotUri']) lines.push(`  Screenshot: ${doc['screenshotUri']}`);
+  if (data['status']) lines.push(`  Status: ${data['status']}`);
+  if (data['userId']) lines.push(`  User: ${data['userId']}`);
+  if (data['url']) lines.push(`  URL: ${data['url']}`);
+  if (data['screenshotUri']) lines.push(`  Screenshot: ${data['screenshotUri']}`);
 
-  const ctx = doc['context'];
+  const ctx = data['context'];
   if (ctx && typeof ctx === 'object') {
     const ctxStr = JSON.stringify(ctx);
     if (ctxStr !== '{}') lines.push(`  Context: ${ctxStr}`);
   }
 
-  if (doc['resolution']) lines.push(`  Resolution: ${doc['resolution']}`);
+  if (data['resolution']) lines.push(`  Resolution: ${data['resolution']}`);
 
-  const previousLogs = doc['logs'] ?? doc['previousLogs'];
+  const previousLogs = data['logs'] ?? data['previousLogs'];
   if (Array.isArray(previousLogs) && previousLogs.length > 0) {
     lines.push(`  Console logs (${previousLogs.length}):`);
     for (const entry of previousLogs as Record<string, unknown>[]) {
@@ -136,74 +78,49 @@ const formatters: Record<string, (doc: Record<string, unknown>) => string> = {
   feedbackReport: formatFeedbackDoc,
 };
 
-type AdminCollection = 'errorLog' | 'perfLog' | 'feedbackReport';
-
+/**
+ * Query a log collection from the project's own Postgres. DATABASE_URL must
+ * point at the DB you want to inspect (local dev DB or a production Neon DB
+ * — set DATABASE_URL accordingly before running the command).
+ */
 export async function queryServerLogsApi(
   collection: AdminCollection,
   options: {
     limit?: number;
     level?: string;
     json?: boolean;
-    /** When set, filter errorLog rows by devTunnelId (string) or 'none' for deployed-only. */
-    devTunnelId?: string | 'none';
   },
 ): Promise<void> {
   const limit = options.limit ?? 50;
-  const projectId = getProjectId();
-
-  let items: Record<string, unknown>[];
 
-  if (collection === 'errorLog') {
-    const input: Record<string, unknown> = { limit };
-    if (options.level) input['level'] = options.level;
-    if (projectId) input['projectId'] = projectId;
-    if (options.devTunnelId !== undefined) {
-      input['devTunnelId'] = options.devTunnelId;
+  await initPg();
+  try {
+    const params: unknown[] = [limit];
+    let where = '';
+    if (collection === 'errorLog' && options.level) {
+      where = `WHERE data->'meta'->>'level' = $2`;
+      params.push(options.level);
     }
-    const result = await adminRequest<{ errors: Record<string, unknown>[]; nextCursor: number | null }>(
-      'errorLogGetList',
-      input,
+    const res = await pgQuery<Record<string, unknown>>(
+      `SELECT _id, data, created FROM "${collection}" ${where} ORDER BY created DESC LIMIT $1`,
+      params,
     );
-    items = result.errors;
-  } else if (collection === 'feedbackReport') {
-    const input: Record<string, unknown> = { limit };
-    if (projectId) input['projectId'] = projectId;
-    if (options.devTunnelId !== undefined) {
-      input['devTunnelId'] = options.devTunnelId;
-    }
-    const result = await adminRequest<{
-      items: Record<string, unknown>[];
-      nextCursor: number | null;
-    }>('adminFeedbackList', input);
-    items = result.items;
-  } else {
-    // perfLog
-    const input: Record<string, unknown> = { limit };
-    if (projectId) input['projectId'] = projectId;
-    if (options.devTunnelId !== undefined) {
-      input['devTunnelId'] = options.devTunnelId;
-    }
-    const result = await adminRequest<{
-      items: Record<string, unknown>[];
-      nextCursor: number | null;
-    }>('perfLogGetList', input);
-    items = result.items;
-  }
+    const items = res.rows.slice().reverse();
 
-  // Reverse so oldest first (server returns newest first)
-  items.reverse();
-
-  if (items.length === 0) {
-    console.log(`No entries found in ${collection}.`);
-    return;
-  }
+    if (items.length === 0) {
+      console.log(`No entries found in ${collection}.`);
+      return;
+    }
 
-  for (const doc of items) {
-    if (options.json) {
-      console.log(JSON.stringify(doc));
-    } else {
-      const fmt = formatters[collection] ?? formatErrorDoc;
-      console.log(fmt(doc));
+    for (const doc of items) {
+      if (options.json) {
+        console.log(JSON.stringify(doc));
+      } else {
+        const fmt = formatters[collection] ?? formatErrorDoc;
+        console.log(fmt(doc));
+      }
     }
+  } finally {
+    closePg();
   }
 }

package/src/cli/version.ts

@@ -1,2 +1,2 @@
 // Auto-generated by prebuild — do not edit manually
-export const CLI_VERSION = "0.1.518";
+export const CLI_VERSION = "0.1.521";

package/src/client/auth/MagicLinkCallback.tsx

@@ -19,6 +19,7 @@ export function MagicLinkCallback() {
     const params = new URLSearchParams(window.location.search);
     const id = params.get('id');
     const sig = params.get('sig');
+    const returnTo = params.get('returnTo') ?? '';
     if (!id || !sig) {
       setState('error');
       return;
@@ -28,15 +29,22 @@ export function MagicLinkCallback() {
         const r = await fetch('/auth/magic-link/verify', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ id, sig }),
+          body: JSON.stringify({ id, sig, returnTo }),
         });
         if (!r.ok) {
           setState('error');
           return;
         }
+        // Server returns a same-origin-validated `returnTo` in the
+        // success body — trust that over the raw URL parameter so a
+        // tampered click-through can't post-redirect off-site.
+        const data = (await r.json().catch(() => ({}))) as {
+          returnTo?: string;
+        };
+        const dest = data.returnTo || returnTo || '/';
         setState('success');
         setTimeout(() => {
-          window.location.href = '/';
+          window.location.href = dest;
         }, 500);
       } catch {
         setState('error');

package/src/client/auth/MagicLinkForm.tsx

@@ -16,10 +16,16 @@ export function MagicLinkForm() {
     if (!email) return;
     setState('requesting');
     try {
+      // Capture where the user is right now so the verify step can
+      // resume on the same page (with query string + hash preserved).
+      // Server-side `validateReturnTo` strips off-origin URLs to `/`,
+      // so this is safe to send even when the user follows a deep link.
+      const returnTo =
+        typeof window !== 'undefined' ? window.location.href : '';
       const r = await fetch('/auth/magic-link/request', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ email }),
+        body: JSON.stringify({ email, returnTo }),
       });
       if (!r.ok) {
         setState('error');

package/src/server/App.ts

@@ -1466,7 +1466,6 @@ export function createApp<
         const { createServer: createViteServer } = await import("vite");
         type PluginOption = import("vite").PluginOption;
         const hmrEnabled = process.env["UGLY_APP_HMR"] !== "false";
-        const { tunnelPlugin } = await import("../vite/tunnelPlugin.js");
         // Park Vite's dep-optimization cache OUTSIDE the project tree.
         // Default is `<cwd>/node_modules/.vite/` — fine for direct
         // `npm run dev`, lethal under ugly-studio's per-session
@@ -1603,7 +1602,7 @@ export function createApp<
               target: "esnext",
             },
           },
-          plugins: [...userPlugins, tunnelPlugin()],
+          plugins: userPlugins,
           appType: "custom",
         });
         expressApp.use(vite.middlewares);

package/src/server/Email.ts

@@ -59,8 +59,14 @@ export function configureEmail(config: EmailConfig): void {
 }
 
 function resolveConfig(): { url: string; token: string; timeoutMs: number } {
-  const url =
+  const raw =
     _config.url ?? process.env['EMAIL_PROXY_URL'] ?? DEFAULT_EMAIL_PROXY_URL;
+  // Match the AI/push proxy convention: EMAIL_PROXY_URL is the BASE
+  // (e.g. `https://ugly.bot/v1/email`) and the client appends the
+  // endpoint suffix. Tolerate the legacy form that includes `/send`
+  // so existing deploys keep working without an env-var rotation.
+  const stripped = raw.replace(/\/+$/, '');
+  const url = stripped.endsWith('/send') ? stripped : `${stripped}/send`;
   const token = _config.token ?? process.env['EMAIL_PROXY_TOKEN'] ?? '';
   const timeoutMs = _config.timeoutMs ?? 30_000;
   return { url, token, timeoutMs };

package/src/server/Logging.ts

@@ -5,11 +5,10 @@ import path from 'node:path';
 import type { TypedDB } from '../shared/DB.js';
 import type { StorageClient } from './Storage.js';
 // Note: ./Pg.js and ./PostgresDoc.js are loaded LAZILY inside
-// `insertLogRows` only. Hosts that route logging via EVENT_LOG_URL
-// (e.g. Ugly Studio's sidecar) never need the pg driver — keeping these
-// imports lazy stops the ~80ms `pg` module load on `import './Logging.js'`.
-// `randomId` from PostgresDoc.js is small and inlined below so we
-// don't transitively load the whole collection ORM either.
+// `insertLogRows` only. Keeping these imports lazy stops the ~80ms `pg`
+// module load on `import './Logging.js'` for code paths that never log.
+// `randomId` from PostgresDoc.js is small and inlined below so we don't
+// transitively load the whole collection ORM either.
 const RANDOM_ID_ALPHABET =
   'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW';
 function randomId(): string {
@@ -22,73 +21,23 @@ function randomId(): string {
   return out;
 }
 
-// ─── Data-proxy capture forwarding ──────────────────────────────────────────
+// ─── Log persistence ────────────────────────────────────────────────────────
 //
-// errorLog and perfLog writes go through the data-proxy's restricted-collection
-// RPCs (db.captureError / db.capturePerf). The data-proxy stamps projectId from
-// the JWT (claims.sub) and devTunnelId from the JWT (claims.devTunnelId), so
-// nothing the client sends can spoof identity. There is no project/userId
-// argument to these helpers — both come from the JWT the StorageClient holds.
+// errorLog, perfLog, and feedbackReport writes go directly to the project's
+// own Postgres. Each project owns these tables in its own DB (created by
+// bootstrap.ts on startup). Hosts like Ugly Studio that want to surface logs
+// query the project's DB through their own channels.
 //
-// studioSessionId is different: it's a sub-partition inside one developer's
-// dev tunnel (so N coding-agent sessions from the same user can show only
-// their own logs in the ugly-studio panels / AI tools). It is NOT a security
-// gate — devTunnelId already isolates between users. We read it from
-// `UGLY_STUDIO_SESSION_ID`, an env var ugly-studio sets on every per-session
-// `npm run dev` child it spawns (see studio/server/devServerMulti.ts
-// startInstance). Absent = legacy single-session dev, no stamp.
+// studioSessionId sub-partitions logs by ugly-studio coding-agent session so
+// per-session panels / AI tools can scope what they show. We read it from
+// `UGLY_STUDIO_SESSION_ID`, set by Studio on every per-session `npm run dev`
+// child (see studio/server/devServerMulti.ts startInstance). Absent = no stamp.
 
 function getStudioSessionId(): string | undefined {
   const raw = process.env['UGLY_STUDIO_SESSION_ID'];
   return raw && raw.length > 0 ? raw : undefined;
 }
 
-/**
- * HTTPS event-log forwarding. When `EVENT_LOG_URL` is set (e.g. ugly-studio's
- * sidecar boot, which sets EVENT_LOG_URL=https://api.ugly.bot/v1/events and
- * EVENT_LOG_TOKEN=<jwt>) we POST batches to `${EVENT_LOG_URL}/${kind}` with
- * a bearer token, bypassing the direct-PG path entirely. The receiving
- * ugly.bot route stamps projectId + devTunnelId from the JWT.
- *
- * When EVENT_LOG_URL is unset we fall back to the legacy direct-PG path
- * which is gated on NODE_ENV=production (so local `npm run dev` and tests
- * still drop entries on the floor — keeps shared errorLog/perfLog tables
- * free of dev noise).
- */
-const EVENT_LOG_URL = process.env['EVENT_LOG_URL'] ?? '';
-const EVENT_LOG_TOKEN = process.env['EVENT_LOG_TOKEN'] ?? '';
-const HTTPS_LOG_ENABLED = EVENT_LOG_URL.length > 0;
-const LOG_TO_REMOTE =
-  HTTPS_LOG_ENABLED || process.env['NODE_ENV'] === 'production';
-
-async function sendBatchOverHttps(
-  kind: 'error' | 'perf' | 'feedback',
-  entries: unknown[],
-): Promise<void> {
-  if (!HTTPS_LOG_ENABLED) return;
-  if (entries.length === 0) return;
-  const url = `${EVENT_LOG_URL.replace(/\/+$/, '')}/${kind}`;
-  try {
-    const res = await globalThis.fetch(url, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${EVENT_LOG_TOKEN}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ entries }),
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => '');
-      console.warn(
-        `[Logging] HTTPS ${kind} batch failed (${res.status}): ${text.slice(0, 200)}`,
-      );
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.warn(`[Logging] HTTPS ${kind} batch network error: ${msg}`);
-  }
-}
-
 interface PendingErrorEntry {
   level: string;
   message: string;
@@ -125,22 +74,9 @@ async function insertLogRows(
   entries: Record<string, unknown>[],
 ): Promise<void> {
   if (entries.length === 0) return;
-  // Prefer HTTPS forwarding when configured (Studio sidecar, hosts without
-  // direct PG access). ugly.bot stamps projectId+devTunnelId from the JWT.
-  if (HTTPS_LOG_ENABLED) {
-    const kind: 'error' | 'perf' | 'feedback' =
-      collection === 'errorLog'
-        ? 'error'
-        : collection === 'perfLog'
-          ? 'perf'
-          : 'feedback';
-    await sendBatchOverHttps(kind, entries);
-    return;
-  }
-  // Best-effort row inserts. If the table doesn't exist yet (e.g. before
-  // db:init / db:migrate ran), pg throws — we swallow because logging
-  // must never throw. `pgQuery` is loaded lazily so hosts routing logs
-  // via `EVENT_LOG_URL` (e.g. Ugly Studio) never pay the pg load cost.
+  // Best-effort row inserts into the project's own Postgres. If the table
+  // doesn't exist yet (e.g. before bootstrap created it), pg throws — we
+  // swallow because logging must never throw.
   const { pgQuery } = await import('./Pg.js');
   for (const entry of entries) {
     const now = new Date();
@@ -166,7 +102,6 @@ async function insertLogRows(
 }
 
 async function flushErrorEntries(): Promise<void> {
-  if (!LOG_TO_REMOTE) return;
   if (_pendingErrorEntries.length === 0) return;
   const batch = _pendingErrorEntries.splice(0, 50);
   try {
@@ -194,7 +129,6 @@ function sendErrorToApi(
     context?: Record<string, unknown> | null;
   },
 ): void {
-  if (!LOG_TO_REMOTE) return;
   const studioSessionId = getStudioSessionId();
   _pendingErrorEntries.push({
     level,
@@ -214,8 +148,7 @@ function sendErrorToApi(
 /**
  * Capture a batch of client-originated error entries (e.g. browser errors
  * forwarded via an HTTP endpoint). Buffers them into the same queue that
- * server-side console errors use; the data-proxy stamps projectId +
- * devTunnelId from the JWT on flush.
+ * server-side console errors use and flushes to the project's own Postgres.
  */
 export function captureClientErrors(
   entries: {
@@ -230,7 +163,6 @@ export function captureClientErrors(
     context?: Record<string, unknown> | null;
   }[],
 ): void {
-  if (!LOG_TO_REMOTE) return;
   const studioSessionId = getStudioSessionId();
   for (const e of entries) {
     _pendingErrorEntries.push({
@@ -264,7 +196,6 @@ const _perfLogBuffer: PerfLogEntry[] = [];
 let _perfLogFlushTimer: ReturnType<typeof setInterval> | null = null;
 
 function flushPerfLogBuffer(): void {
-  if (!LOG_TO_REMOTE) return;
   if (_perfLogBuffer.length === 0) return;
   const entries = _perfLogBuffer.splice(0, _perfLogBuffer.length);
   void insertLogRows(
@@ -285,12 +216,10 @@ function ensurePerfLogFlushTimer(): void {
 }
 
 /**
- * Record a perf entry. Buffered and flushed to the data-proxy on a 5s timer
- * (or immediately when the buffer reaches 50). The data-proxy stamps
- * projectId + devTunnelId from its JWT.
+ * Record a perf entry. Buffered and flushed to the project's own Postgres on
+ * a 5s timer (or immediately when the buffer reaches 50).
  */
 export function recordPerf(operation: string, durationMs: number, userId = ''): void {
-  if (!LOG_TO_REMOTE) return;
   const studioSessionId = getStudioSessionId();
   _perfLogBuffer.push({
     operation,
@@ -304,7 +233,6 @@ export function recordPerf(operation: string, durationMs: number, userId = ''):
 
 /** Force-flush any buffered perf entries to Postgres. */
 export async function flushPerf(): Promise<void> {
-  if (!LOG_TO_REMOTE) return;
   if (_perfLogBuffer.length === 0) return;
   const entries = _perfLogBuffer.splice(0, _perfLogBuffer.length);
   await insertLogRows(
@@ -314,9 +242,8 @@ export async function flushPerf(): Promise<void> {
 }
 
 /**
- * Send a feedback entry to the data-proxy. The proxy stamps projectId and
- * devTunnelId from the JWT — the caller can't spoof identity. All
- * descriptive fields default to null when omitted.
+ * Persist a feedback entry to the project's own Postgres. All descriptive
+ * fields default to null when omitted.
  */
 export async function recordFeedback(input: {
   type: 'bug' | 'design' | 'feature';
@@ -410,9 +337,6 @@ export function createLogger(
     },
 
     async feedback({ type, message, screenshotTempKey }) {
-      // The data-proxy capture RPC stamps projectId + devTunnelId from the JWT.
-      // We send a minimal feedbackReport-shaped entry; nullable schema fields
-      // default to null on the read side.
       let screenshotUri: string | null = null;
       if (screenshotTempKey) {
         try {

package/src/server/adapter/workers/cf-types.ts

@@ -86,6 +86,14 @@ export interface WorkersEnv {
    */
   UGLY_APP_AUTH_MODE?: 'uglybot' | 'self';
 
+  /**
+   * When `'1'`, magic-link request handler logs the verify URL to the
+   * worker console AND returns it inside `{ debug: { link } }` so dev /
+   * E2E flows can complete sign-in without a working email proxy.
+   * NEVER set in production.
+   */
+  UGLY_APP_MAGIC_LINK_DEBUG?: string;
+
   // Per-app project id (used to namespace DO ids)
   PROJECT_ID: string;
 

package/src/server/adapter/workers/createWorkersApp.ts

@@ -1229,6 +1229,7 @@ function ensureAdapter(env: WorkersEnv): void {
       'SEARCH_PROXY_URL',
       'SEARCH_PROXY_TOKEN',
       'UGLY_APP_AUTH_MODE',
+      'UGLY_APP_MAGIC_LINK_DEBUG',
       'AUTH_SECRET',
       'DATABASE_URL',
       'PROJECT_ID',