ugly-app 0.1.783 → 0.1.784

package/src/cli/feedbackResolve.test.ts

@@ -1,56 +1,73 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-// The resolve path writes to Cloudflare D1 via execTelemetryD1 — mock it so the
-// unit test asserts the SQL/params contract without hitting the network.
-vi.mock('./telemetryD1.js', () => ({ execTelemetryD1: vi.fn() }));
-
-import { execTelemetryD1 } from './telemetryD1.js';
 import {
   parseBatchPayload,
   resolveFeedback,
   resolveFeedbackBatch,
+  type ResolveContext,
 } from './feedbackResolve.js';
 
-const mockExec = vi.mocked(execTelemetryD1);
+// The resolve path now POSTs to the deployed app's feedbackReportResolve request
+// (which updates D1 + emails the reporter from Worker context). Mock global fetch
+// so the unit test asserts the request contract without hitting the network.
+const ctx: ResolveContext = { appUrl: 'https://app.example', token: 'owner-tok' };
+
+function mockFetch(responses: { ok: boolean; body: unknown }[]): void {
+  const fn = vi.fn();
+  for (const r of responses) {
+    fn.mockResolvedValueOnce({
+      ok: r.ok,
+      status: r.ok ? 200 : 400,
+      text: async () => JSON.stringify(r.body),
+      json: async () => r.body,
+    });
+  }
+  globalThis.fetch = fn as never;
+}
 
 beforeEach(() => {
-  mockExec.mockReset();
+  vi.restoreAllMocks();
 });
 
 describe('resolveFeedback', () => {
-  it('UPDATEs feedback_report with status + resolution keyed by id', async () => {
-    mockExec.mockResolvedValue({ results: [], meta: { changes: 1 } });
-    await resolveFeedback({ feedbackId: 'fb-1', status: 'resolved', resolution: 'done' });
-    expect(mockExec).toHaveBeenCalledTimes(1);
-    const [sql, params] = mockExec.mock.calls[0]!;
-    expect(sql).toMatch(/UPDATE\s+feedback_report\s+SET\s+status\s*=\s*\?,\s*resolution\s*=\s*\?\s+WHERE\s+id\s*=\s*\?/i);
-    expect(params).toEqual(['resolved', 'done', 'fb-1']);
+  it('POSTs feedbackReportResolve with id/status/resolution + owner bearer', async () => {
+    mockFetch([{ ok: true, body: { ok: true, emailed: true } }]);
+    await resolveFeedback({ feedbackId: 'fb-1', status: 'resolved', resolution: 'done' }, ctx);
+    const [url, opts] = (globalThis.fetch as unknown as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(url).toBe('https://app.example/api/feedbackReportResolve');
+    expect((opts as { headers: Record<string, string> }).headers.Authorization).toBe('Bearer owner-tok');
+    expect(JSON.parse((opts as { body: string }).body)).toEqual({
+      input: { id: 'fb-1', status: 'resolved', resolution: 'done' },
+    });
   });
 
-  it('throws when no row matched the id (changes === 0)', async () => {
-    mockExec.mockResolvedValue({ results: [], meta: { changes: 0 } });
+  it('throws when the app reports no matching row (ok:false)', async () => {
+    mockFetch([{ ok: true, body: { ok: false, emailed: false } }]);
     await expect(
-      resolveFeedback({ feedbackId: 'missing', status: 'declined', resolution: 'n/a' }),
+      resolveFeedback({ feedbackId: 'missing', status: 'declined', resolution: 'n/a' }, ctx),
     ).rejects.toThrow(/no feedback_report row with id "missing"/);
   });
 
-  it('throws when D1 returns no meta', async () => {
-    mockExec.mockResolvedValue({ results: [], meta: null });
+  it('throws when the request fails (non-2xx)', async () => {
+    mockFetch([{ ok: false, body: { error: 'Not authorized' } }]);
     await expect(
-      resolveFeedback({ feedbackId: 'x', status: 'resolved', resolution: 'y' }),
+      resolveFeedback({ feedbackId: 'x', status: 'resolved', resolution: 'y' }, ctx),
     ).rejects.toThrow(/Failed to resolve feedback/);
   });
 });
 
 describe('resolveFeedbackBatch', () => {
   it('processes every item and reports partial failures without throwing', async () => {
-    mockExec
-      .mockResolvedValueOnce({ results: [], meta: { changes: 1 } }) // ok
-      .mockResolvedValueOnce({ results: [], meta: { changes: 0 } }); // missing row
-    const { successes, failures } = await resolveFeedbackBatch([
-      { id: 'a', status: 'resolved', resolution: 'r1' },
-      { id: 'b', status: 'resolved', resolution: 'r2' },
+    mockFetch([
+      { ok: true, body: { ok: true, emailed: true } }, // a: ok
+      { ok: true, body: { ok: false, emailed: false } }, // b: missing row
     ]);
+    const { successes, failures } = await resolveFeedbackBatch(
+      [
+        { id: 'a', status: 'resolved', resolution: 'r1' },
+        { id: 'b', status: 'resolved', resolution: 'r2' },
+      ],
+      ctx,
+    );
     expect(successes).toBe(1);
     expect(failures).toHaveLength(1);
     expect(failures[0]!.id).toBe('b');

package/src/cli/feedbackResolve.ts

@@ -1,4 +1,7 @@
-import { execTelemetryD1 } from './telemetryD1.js';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { resolveProdAuth } from './prodDb.js';
 
 export interface FeedbackResolveOptions {
   feedbackId: string;
@@ -12,47 +15,96 @@ export interface FeedbackResolveItem {
   resolution: string;
 }
 
+/** Where + how to reach the deployed app's `feedbackReportResolve` request. */
+export interface ResolveContext {
+  /** Deployed app base URL, e.g. https://code.ugly.bot */
+  appUrl: string;
+  /** Owner bearer token (ugly.bot user token) — verified by the Worker and gated
+   *  by resolvedIsAdmin (MAINTAIN_BOT_USER_ID or the ADMIN_USER_IDS allowlist). */
+  token: string;
+}
+
+/** Read the signed-in owner's ugly.bot token from `~/.ugly-bot/auth.json`. */
+function readOwnerToken(): string {
+  const file = path.join(os.homedir(), '.ugly-bot', 'auth.json');
+  try {
+    const data = JSON.parse(fs.readFileSync(file, 'utf-8')) as { token?: unknown };
+    return typeof data.token === 'string' ? data.token : '';
+  } catch {
+    return '';
+  }
+}
+
 /**
- * Update a single feedback report's status + resolution directly in the
- * project's PROD Cloudflare D1 (`feedback_report` table) — the same store the
- * `feedback` read CLI queries. The previous implementation POSTed
- * `{function:'feedbackReportResolve'}` to `ugly.bot/request`, an endpoint that
- * lived on the retired `app` monolith; the live ugly.bot is a billable-op proxy
- * that 400s ("Missing op"), so resolves silently failed for every child app.
+ * Resolve the deployed app URL (from publish state) + the owner token needed to
+ * authorize `feedbackReportResolve`. Throws with actionable guidance if either
+ * is missing.
  */
-async function resolveOne(item: FeedbackResolveItem): Promise<void> {
-  const { meta } = await execTelemetryD1(
-    'UPDATE feedback_report SET status = ?, resolution = ? WHERE id = ?',
-    [item.status, item.resolution, item.id],
-  );
-  if (!meta || (meta.changes ?? 0) === 0) {
+export function resolveProdResolveContext(): ResolveContext {
+  const auth = resolveProdAuth();
+  const appUrl = auth.wsUrl.replace(/^ws/, 'http').replace(/\/ws$/, '');
+  const token = readOwnerToken();
+  if (!token) {
+    throw new Error(
+      'Not signed in to ugly.bot — run `ugly-app login`. feedback:resolve needs your owner token to authorize the resolve on the deployed app.',
+    );
+  }
+  return { appUrl, token };
+}
+
+/**
+ * Resolve a single feedback report by calling the deployed app's admin
+ * `feedbackReportResolve` request. The Worker updates the `feedback_report` D1
+ * row (status + resolution + resolved_at) AND emails the reporter from the app's
+ * own domain — email must run in Worker context, so (unlike the old raw D1
+ * UPDATE) the resolve goes through the app rather than the Cloudflare D1 API.
+ */
+async function resolveOne(item: FeedbackResolveItem, ctx: ResolveContext): Promise<void> {
+  const res = await fetch(`${ctx.appUrl}/api/feedbackReportResolve`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${ctx.token}`,
+    },
+    body: JSON.stringify({
+      input: { id: item.id, status: item.status, resolution: item.resolution },
+    }),
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(
+      `resolve request failed (${res.status})${body ? ` — ${body.slice(0, 200)}` : ''}`,
+    );
+  }
+  const data = (await res.json().catch(() => ({}))) as { ok?: boolean };
+  if (!data.ok) {
     throw new Error(`no feedback_report row with id "${item.id}"`);
   }
 }
 
 export async function resolveFeedback(
   opts: FeedbackResolveOptions,
+  ctx: ResolveContext,
 ): Promise<void> {
   try {
-    await resolveOne({
-      id: opts.feedbackId,
-      status: opts.status,
-      resolution: opts.resolution,
-    });
+    await resolveOne(
+      { id: opts.feedbackId, status: opts.status, resolution: opts.resolution },
+      ctx,
+    );
   } catch (e) {
     throw new Error(`Failed to resolve feedback: ${(e as Error).message}`);
   }
 }
 
 /**
- * Resolve many feedback items over a single auth context. Process each
- * item even if earlier ones fail — partial failure is surfaced via the
- * returned `failures` array AND a non-zero exit at the CLI layer, never
- * silently swallowed (the bot-swarm cycle invariant is to fail loud, not
- * leave items at `status: new` for a duplicate-process next cycle).
+ * Resolve many feedback items over one auth context. Process each item even if
+ * earlier ones fail — partial failure is surfaced via the returned `failures`
+ * array AND a non-zero exit at the CLI layer, never silently swallowed (the
+ * bot-swarm cycle invariant is to fail loud, not leave items at `status: new`).
  */
 export async function resolveFeedbackBatch(
   items: FeedbackResolveItem[],
+  ctx: ResolveContext,
   onItem?: (
     item: FeedbackResolveItem,
     result: { ok: true } | { ok: false; error: string },
@@ -62,7 +114,7 @@ export async function resolveFeedbackBatch(
   let successes = 0;
   for (const item of items) {
     try {
-      await resolveOne(item);
+      await resolveOne(item, ctx);
       successes++;
       onItem?.(item, { ok: true });
     } catch (e) {
@@ -120,7 +172,9 @@ export async function readStdinToString(): Promise<string> {
   return new Promise((resolve, reject) => {
     let buf = '';
     process.stdin.setEncoding('utf-8');
-    process.stdin.on('data', (chunk: string) => { buf += chunk; });
+    process.stdin.on('data', (chunk: string) => {
+      buf += chunk;
+    });
     process.stdin.on('end', () => resolve(buf));
     process.stdin.on('error', reject);
     process.stdin.resume();

package/src/cli/index.ts

@@ -301,7 +301,9 @@ function parseSinceToMs(since: string): number | undefined {
 
 program
   .command('errors')
-  .description("Query error logs from this project's PROD Cloudflare D1 (errorLog)")
+  .description(
+    "Query (or, with --clear, delete) error logs from this project's PROD Cloudflare D1 (errorLog)",
+  )
   .option('--limit <n>', 'Max entries to show', '50')
   .option('--level <lvl>', 'Filter by level (log/info/warn/error/debug)')
   .option('--source <src>', "Filter by source (e.g. browser, server, coding-task)")
@@ -310,6 +312,11 @@ program
   .option('--since <dur>', 'Only errors newer than this (e.g. 30m, 24h, 7d)')
   .option('--grep <re>', 'Only show entries whose message matches this regex (client-side)')
   .option('--json', 'Output as JSON')
+  .option(
+    '--clear',
+    'Delete matching entries instead of printing them (scoped by --level/--source/--user/--since; clears everything if unscoped)',
+  )
+  .option('--yes', 'Skip the confirmation prompt when using --clear')
   .action(
     async (opts: {
       limit?: string;
@@ -320,6 +327,8 @@ program
       since?: string;
       grep?: string;
       json?: boolean;
+      clear?: boolean;
+      yes?: boolean;
     }) => {
       try {
         let sinceMs: number | undefined;
@@ -330,6 +339,47 @@ program
             process.exit(1);
           }
         }
+        if (opts.clear) {
+          const scope = [
+            opts.level ? `level=${opts.level}` : '',
+            opts.source ? `source=${opts.source}` : '',
+            opts.user ? `user=${opts.user}` : '',
+            opts.since ? `newer than ${opts.since}` : '',
+          ]
+            .filter(Boolean)
+            .join(', ');
+          const target = scope
+            ? `error_log entries matching: ${scope}`
+            : 'ALL error_log entries (nothing was scoped)';
+          if (!opts.yes) {
+            const { createInterface } = await import('readline');
+            const rl = createInterface({
+              input: process.stdin,
+              output: process.stdout,
+            });
+            const answer = await new Promise<string>((resolve) => {
+              rl.question(
+                `This will permanently delete ${target} from PROD Cloudflare D1. Continue? [y/N] `,
+                (a) => {
+                  rl.close();
+                  resolve(a.trim().toLowerCase());
+                },
+              );
+            });
+            if (answer !== 'y' && answer !== 'yes') {
+              console.log('Aborted. Nothing was cleared.');
+              return;
+            }
+          }
+          const { clearServerLogsApi } = await import('./serverLogQueryApi.js');
+          await clearServerLogsApi('errorLog', {
+            level: opts.level,
+            source: opts.source,
+            userId: opts.user,
+            sinceMs,
+          });
+          return;
+        }
         const { queryServerLogsApi } = await import('./serverLogQueryApi.js');
         await queryServerLogsApi('errorLog', {
           limit: opts.limit ? parseInt(opts.limit, 10) : 50,
@@ -425,7 +475,7 @@ program
 
 program
   .command('feedback')
-  .description("Query feedback from this project's PROD Neon DB (from publish state)")
+  .description("Query feedback from this project's PROD Cloudflare D1 (feedbackReport)")
   .option('--limit <n>', 'Max entries to show', '50')
   .option('--json', 'Output as JSON')
   .action(async (opts: { limit?: string; json?: boolean }) => {
@@ -503,7 +553,9 @@ program
           readStdinToString,
           resolveFeedback,
           resolveFeedbackBatch,
+          resolveProdResolveContext,
         } = await import('./feedbackResolve.js');
+        const ctx = resolveProdResolveContext();
         if (opts.batch) {
           const raw =
             opts.batch === '-'
@@ -514,6 +566,7 @@ program
           const items = parseBatchPayload(raw);
           const { successes, failures } = await resolveFeedbackBatch(
             items,
+            ctx,
             (item, result) => {
               if (result.ok) {
                 console.log(`✓ ${item.id} ${item.status}`);
@@ -533,11 +586,14 @@ program
             'feedback:resolve requires either --batch <path> or all of --id, --status, --resolution',
           );
         }
-        await resolveFeedback({
-          feedbackId: opts.id,
-          status: opts.status as 'resolved' | 'declined',
-          resolution: opts.resolution,
-        });
+        await resolveFeedback(
+          {
+            feedbackId: opts.id,
+            status: opts.status as 'resolved' | 'declined',
+            resolution: opts.resolution,
+          },
+          ctx,
+        );
         console.log('Feedback resolved.');
       } catch (e) {
         console.error((e as Error).message);

package/src/cli/serverLogQueryApi.ts

@@ -91,6 +91,89 @@ async function queryTelemetryD1(
   return rows.map((r) => mapD1Row(collection, r));
 }
 
+/**
+ * Delete rows from the project's Cloudflare D1 `error_log`, scoped by the same
+ * filters the query path accepts. With no filters this wipes the whole table.
+ *
+ * Unlike the query path, this does NOT silently exclude the `coding-task`
+ * source — "clear" means clear everything that matches, so a bare
+ * `ugly-app errors --clear` removes coding-task noise too. Pass `--source` to
+ * scope the deletion. Returns the number of rows deleted (D1 `meta.changes`).
+ */
+async function clearTelemetryD1(
+  collection: 'errorLog',
+  options: {
+    level?: string | undefined;
+    source?: string | undefined;
+    userId?: string | undefined;
+    sinceMs?: number | undefined;
+  },
+): Promise<number> {
+  const d1: ProdTelemetryD1 = resolveProdTelemetryD1();
+
+  const params: unknown[] = [];
+  const conds: string[] = [];
+  if (options.level) {
+    conds.push('level = ?');
+    params.push(options.level);
+  }
+  if (options.source) {
+    conds.push('source = ?');
+    params.push(options.source);
+  }
+  if (options.userId) {
+    conds.push('user_id = ?');
+    params.push(options.userId);
+  }
+  if (options.sinceMs !== undefined) {
+    conds.push('created > ?');
+    params.push(options.sinceMs);
+  }
+  const where = conds.length ? `WHERE ${conds.join(' AND ')}` : '';
+  const sql = `DELETE FROM error_log ${where}`;
+
+  const res = await cloudflareD1Fetch(
+    d1.projectId,
+    `${CLOUDFLARE_API_BASE}/accounts/${d1.accountId}/d1/database/${d1.databaseId}/query`,
+    { method: 'POST', body: JSON.stringify({ sql, params }) },
+  );
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    // A missing table means there's nothing to clear.
+    if (/no such table/i.test(body)) return 0;
+    throw new Error(`D1 delete failed (${res.status}): ${body.slice(0, 200)}`);
+  }
+  const payload = (await res.json()) as {
+    result?: { meta?: { changes?: number } }[];
+  };
+  return payload.result?.[0]?.meta?.changes ?? 0;
+}
+
+/**
+ * Clear (delete) rows from a telemetry-log collection. Only `errorLog` (the
+ * Cloudflare D1 `error_log` table) is supported today. Prints the count of
+ * rows removed.
+ */
+export async function clearServerLogsApi(
+  collection: AdminCollection,
+  options: {
+    level?: string | undefined;
+    source?: string | undefined;
+    userId?: string | undefined;
+    sinceMs?: number | undefined;
+  },
+): Promise<void> {
+  if (collection !== 'errorLog') {
+    throw new Error(`--clear is only supported for errorLog, not "${collection}".`);
+  }
+  const deleted = await clearTelemetryD1(collection, options);
+  console.log(
+    deleted === 0
+      ? 'No matching entries to clear.'
+      : `Cleared ${deleted} ${collection} entr${deleted === 1 ? 'y' : 'ies'}.`,
+  );
+}
+
 const jsonParse = (v: unknown): unknown => {
   if (typeof v !== 'string') return v ?? null;
   try {
@@ -287,7 +370,11 @@ const formatters: Record<string, (doc: Record<string, unknown>) => string> = {
 };
 
 /**
- * Query a runtime-log collection from the project's PRODUCTION Neon DB.
+ * Query a runtime-log collection from the project's PRODUCTION store.
+ *
+ * `errorLog`, `feedbackReport`, `workerRun`, and `eventLog` live in the
+ * project's Cloudflare D1 telemetry DB and are queried via the D1 HTTP API
+ * (see the branch below). Only `perfLog` remains a Neon collection.
  *
  * These logs are written only by the deployed Worker, so we always target the
  * prod connection string persisted by the publish flow — NOT any ambient

package/src/cli/version.ts

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

package/src/server/App.ts

@@ -1,6 +1,9 @@
 import cookieParser from "cookie-parser";
 import express from "express";
 import type { InboundEmail } from "../shared/InboundEmail.js";
+import { isDefaultAdmin } from "./adminAllowlist.js";
+import { resolveFeedbackReport } from "./TelemetryStore.js";
+import { notifyFeedbackResolved } from "./feedbackNotify.js";
 import { createServer } from "http";
 import type { IncomingMessage } from "http";
 import crypto from "node:crypto";
@@ -680,7 +683,7 @@ export function createApp<
   // Admin gate for the admin-only framework requests. App-provided predicate, else the
   // maintain-bot env id (never allow-all: an unset admin + unset env id denies everyone).
   const resolvedIsAdmin = async (userId: string): Promise<boolean> =>
-    isAdminFn ? !!(await isAdminFn(userId, typedDb)) : !!maintainBotUserId && userId === maintainBotUserId;
+    isAdminFn ? !!(await isAdminFn(userId, typedDb)) : isDefaultAdmin(userId, maintainBotUserId);
   const fwHandlers: Record<string, unknown> = {
     // Test-user admin handlers (adminCreateTestUser / list / delete) — shared factory,
     // identical on the Workers adapter. Admin gate = resolvedIsAdmin.
@@ -817,6 +820,24 @@ export function createApp<
       return { items: [] as Record<string, unknown>[] };
     },
 
+    feedbackReportResolve: async (
+      userId: string,
+      input: { id: string; status: "resolved" | "declined"; resolution: string },
+    ) => {
+      if (!(await resolvedIsAdmin(userId))) throw new Error("Not authorized");
+      // feedback_report + emailSend are Worker-only; on Node/dev resolveFeedbackReport
+      // throws "no D1 binding". That's intentional — resolve runs on the deployed Worker.
+      const row = await resolveFeedbackReport(
+        input.id,
+        input.status,
+        input.resolution,
+        Date.now(),
+      );
+      if (!row) return { ok: false, emailed: false };
+      const emailed = await notifyFeedbackResolved(row, input.status, input.resolution);
+      return { ok: true, emailed };
+    },
+
     submitFeedbackBot: async (
       userId: string,
       input: {

package/src/server/TelemetryStore.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { setTelemetryDb, resolveFeedbackReport, type D1Like } from './TelemetryStore.js';
+
+function fakeDb(row: Record<string, unknown> | null, changes: number): D1Like {
+  const prepared = {
+    bind(..._v: unknown[]) {
+      return prepared;
+    },
+    async run() {
+      return { meta: { changes } };
+    },
+    async first<T>() {
+      return row as T | null;
+    },
+  };
+  return {
+    prepare: (_sql: string) => prepared,
+    batch: async () => undefined,
+  } as unknown as D1Like;
+}
+
+describe('resolveFeedbackReport', () => {
+  it('updates the row and returns userId/message/type on success', async () => {
+    setTelemetryDb(fakeDb({ user_id: 'u1', message: 'tokens wrong', type: 'bug' }, 1));
+    const r = await resolveFeedbackReport('id1', 'resolved', 'fixed', 123);
+    expect(r).toEqual({ userId: 'u1', message: 'tokens wrong', type: 'bug' });
+  });
+
+  it('returns null when no row changed', async () => {
+    setTelemetryDb(fakeDb(null, 0));
+    expect(await resolveFeedbackReport('missing', 'declined', 'n/a', 1)).toBeNull();
+  });
+});

package/src/server/TelemetryStore.ts

@@ -28,6 +28,8 @@ const TTL_SWEEP_INTERVAL_MS = 60 * 60 * 1000;
 export interface D1PreparedLike {
   bind(...values: unknown[]): D1PreparedLike;
   run(): Promise<unknown>;
+  /** Read a single row (used by the feedback-resolve read-back). */
+  first<T = Record<string, unknown>>(): Promise<T | null>;
 }
 export interface D1Like {
   prepare(sql: string): D1PreparedLike;
@@ -227,6 +229,53 @@ export async function insertTelemetry(
   void sweepTtl(db, now);
 }
 
+export interface ResolvedFeedbackRow {
+  userId: string | null;
+  message: string | null;
+  type: string | null;
+}
+
+/**
+ * Mark one feedback report resolved/declined (status + resolution + resolved_at)
+ * and read back the fields needed to notify the reporter (their userId + the
+ * original message/type). Returns null when no row matched the id.
+ *
+ * Requires a D1 binding (runs on the deployed Worker); throws when unbound so the
+ * caller surfaces "resolve only works on the deployed Worker" rather than silently
+ * no-op'ing the way fire-and-forget log writes do.
+ */
+export async function resolveFeedbackReport(
+  id: string,
+  status: 'resolved' | 'declined',
+  resolution: string,
+  resolvedAt: number,
+): Promise<ResolvedFeedbackRow | null> {
+  const db = _db;
+  if (!db) {
+    throw new Error(
+      '[Telemetry] no D1 binding — feedback resolve only works on the deployed Worker',
+    );
+  }
+  await ensureSchema(db);
+  const upd = (await db
+    .prepare(
+      'UPDATE feedback_report SET status = ?, resolution = ?, resolved_at = ? WHERE id = ?',
+    )
+    .bind(status, resolution, resolvedAt, id)
+    .run()) as { meta?: { changes?: number } };
+  if ((upd?.meta?.changes ?? 0) === 0) return null;
+  const row = await db
+    .prepare('SELECT user_id, message, type FROM feedback_report WHERE id = ?')
+    .bind(id)
+    .first<Record<string, unknown>>();
+  if (!row) return null;
+  return {
+    userId: (row['user_id'] as string | null) ?? null,
+    message: (row['message'] as string | null) ?? null,
+    type: (row['type'] as string | null) ?? null,
+  };
+}
+
 export interface WorkerRunRecord {
   id?: string;
   name: string;

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

@@ -79,6 +79,7 @@ import { flushPendingPublishes } from './pubsub.js';
 import { flushErrors, initServerConsoleCapture } from '../../Logging.js';
 import { setEmailBinding, type EmailBinding } from '../../Email.js';
 import { setTelemetryDb, recordWorkerRun } from '../../TelemetryStore.js';
+import { isDefaultAdmin } from '../../adminAllowlist.js';
 import { cronRegistry, workerRegistry } from './schedule.js';
 import { createTypedDB } from '../../DB.js';
 import { createStoreHandlers } from '../../StoreHandlers.js';
@@ -1617,7 +1618,7 @@ export function createWorkersApp<R extends AppRegistryBase>(
     } as never);
   const maintainBotUserId = process.env['MAINTAIN_BOT_USER_ID'] ?? '';
   const resolvedIsAdmin = async (userId: string): Promise<boolean> =>
-    isAdminFn ? !!(await isAdminFn(userId, typedDb)) : !!maintainBotUserId && userId === maintainBotUserId;
+    isAdminFn ? !!(await isAdminFn(userId, typedDb)) : isDefaultAdmin(userId, maintainBotUserId);
   const testUserHandlers = createTestUserHandlers({
     typedDb,
     userHelper: resolvedWorkersUserHelper,
@@ -1812,6 +1813,28 @@ export function createWorkersApp<R extends AppRegistryBase>(
       });
       return { ok: true };
     },
+    // Admin-only: resolve/decline a feedback report + notify the reporter by email
+    // (from THIS app's own domain). Gated by resolvedIsAdmin. Called by the
+    // `feedback:resolve` CLI. See FrameworkRequests.ts `feedbackReportResolve`.
+    feedbackReportResolve: async (userId, rawInput) => {
+      const input = (rawInput ?? {}) as {
+        id: string;
+        status: 'resolved' | 'declined';
+        resolution: string;
+      };
+      if (!(await resolvedIsAdmin(userId ?? ''))) throw new Error('Not authorized');
+      const { resolveFeedbackReport } = await import('../../TelemetryStore.js');
+      const { notifyFeedbackResolved } = await import('../../feedbackNotify.js');
+      const row = await resolveFeedbackReport(
+        input.id,
+        input.status,
+        input.resolution,
+        Date.now(),
+      );
+      if (!row) return { ok: false, emailed: false };
+      const emailed = await notifyFeedbackResolved(row, input.status, input.resolution);
+      return { ok: true, emailed };
+    },
     // Browser error/telemetry capture. Mirrors the Node handler in App.ts —
     // writes to the project's own Postgres errorLog via captureClientErrors,
     // attaching the recent console snapshot to each error's context.