feat(admin): support org profile updates (#3416)

Author: Patrick-Erichsen

.agents/skills/clawhub-moderation/SKILL.md

@@ -115,6 +115,7 @@ has asked for fuzzy handle resolution or the exact handle is ambiguous.
 ```text
 official
 create <handle>
+profile update <handle>
 remove-member <handle> <member>
 delete <handle>
 repair-scoped-packages <csv>
@@ -127,6 +128,8 @@ bun run admin -- org official list
 bun run admin -- org official add <handle> --reason "<reason>" --yes
 bun run admin -- org official remove <handle> --reason "<reason>" --yes
 bun run admin -- org create <handle> --display-name "<name>" --member <user-handle> --role owner
+bun run admin -- org profile update <handle> --bio "<description>" --reason "<reason>" --yes
+bun run admin -- org profile update <handle> --logo-file <path> --reason "<reason>" --yes
 bun run admin -- org remove-member <handle> <member-handle>
 bun run admin -- org delete <handle> --reason "<reason>"          # dry-run
 bun run admin -- org delete <handle> --reason "<reason>" --apply
@@ -136,7 +139,8 @@ bun run admin -- org repair-scoped-packages <csv> --apply
 
 `org create` requires `--member`; it must not add the moderator running the
 command as an implicit owner. `org delete` only works for empty org publishers
-and defaults to dry-run.
+and defaults to dry-run. `org profile update` accepts a bio, a PNG/JPEG/WebP
+logo under 2 MB, or both, and records the required reason in the audit log.
 
 ### Plugin Packages
 

convex/httpApiV1.handlers.test.ts

@@ -1697,6 +1697,105 @@ describe("httpApiV1 handlers", () => {
     );
   });
 
+  it("users/publisher-profile updates an org bio and stores a logo for admin", async () => {
+    const runMutation = vi.fn(async (_mutation: unknown, args: Record<string, unknown>) => {
+      if (isRateLimitArgs(args)) return okRate();
+      return {
+        ok: true,
+        publisherId: "publishers:heygen",
+        handle: "heygen-com",
+        bio: "HeyGen is an AI video platform.",
+        image: "https://storage.example/heygen-logo",
+        bioUpdated: true,
+        logoUpdated: true,
+      };
+    });
+    const store = vi.fn(async () => "storage:heygen-logo");
+    const remove = vi.fn(async () => {});
+    vi.mocked(requireApiTokenUser).mockResolvedValue({
+      userId: "users:admin",
+      user: { _id: "users:admin", role: "admin" },
+    } as never);
+    const form = new FormData();
+    form.set(
+      "payload",
+      JSON.stringify({
+        handle: "HeyGen-Com",
+        bio: "HeyGen is an AI video platform.",
+        reason: "Refresh official publisher profile",
+      }),
+    );
+    form.set(
+      "logo",
+      new File([new Uint8Array([137, 80, 78, 71])], "heygen.png", { type: "image/png" }),
+    );
+
+    const response = await __handlers.usersPostRouterV1Handler(
+      makeCtx({
+        runQuery: vi.fn(),
+        runAction: vi.fn(),
+        runMutation,
+        storage: { store, delete: remove },
+      }),
+      new Request("https://example.com/api/v1/users/publisher-profile", {
+        method: "POST",
+        body: form,
+      }),
+    );
+    if (response.status !== 200) throw new Error(await response.text());
+
+    expect(store).toHaveBeenCalledOnce();
+    expect(remove).not.toHaveBeenCalled();
+    expect(runMutation).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        actorUserId: "users:admin",
+        handle: "heygen-com",
+        bio: "HeyGen is an AI video platform.",
+        imageStorageId: "storage:heygen-logo",
+        reason: "Refresh official publisher profile",
+      }),
+    );
+    expect(await response.json()).toMatchObject({
+      ok: true,
+      handle: "heygen-com",
+      bioUpdated: true,
+      logoUpdated: true,
+    });
+  });
+
+  it("users/publisher-profile forbids non-admin api tokens before storing files", async () => {
+    const store = vi.fn(async () => "storage:unused");
+    const runMutation = vi.fn(async (_mutation: unknown, args: Record<string, unknown>) => {
+      if (isRateLimitArgs(args)) return okRate();
+      throw new Error(`unexpected mutation ${JSON.stringify(args)}`);
+    });
+    vi.mocked(requireApiTokenUser).mockResolvedValue({
+      userId: "users:member",
+      user: { _id: "users:member", role: "user" },
+    } as never);
+    const form = new FormData();
+    form.set(
+      "payload",
+      JSON.stringify({
+        handle: "opik",
+        bio: "Opik is an AI observability platform.",
+        reason: "Refresh official publisher profile",
+      }),
+    );
+
+    const response = await __handlers.usersPostRouterV1Handler(
+      makeCtx({ runQuery: vi.fn(), runAction: vi.fn(), runMutation, storage: { store } }),
+      new Request("https://example.com/api/v1/users/publisher-profile", {
+        method: "POST",
+        body: form,
+      }),
+    );
+
+    expect(response.status).toBe(403);
+    expect(store).not.toHaveBeenCalled();
+  });
+
   it("users/publisher-recovery plans personal publisher recovery for admin", async () => {
     const runMutation = vi.fn(async (_mutation: unknown, args: Record<string, unknown>) => {
       if (isRateLimitArgs(args)) return okRate();

convex/httpApiV1/usersV1.ts

@@ -24,6 +24,7 @@ const usersV1InternalRefs = internal as unknown as {
     removeOrgPublisherMemberInternal: unknown;
     removeOfficialPublisherInternal: unknown;
     recoverPersonalPublisherInternal: unknown;
+    updateOrgPublisherProfileInternal: unknown;
   };
   users: {
     getBanAppealContextByGitHubProviderAccountIdInternal: unknown;
@@ -98,12 +99,21 @@ export async function usersPostRouterV1Handler(ctx: ActionCtx, request: Request)
     action !== "publisher-delete" &&
     action !== "publisher-official" &&
     action !== "publisher-member" &&
+    action !== "publisher-profile" &&
     action !== "publisher-reclaim" &&
     action !== "publisher-recovery"
   ) {
     return text("Not found", 404, rate.headers);
   }
 
+  if (action === "publisher-profile") {
+    const authResult = await requireApiTokenUserOrResponse(ctx, request, rate.headers);
+    if (!authResult.ok) return authResult.response;
+    const admin = requireAdminOrResponse(authResult.user, rate.headers);
+    if (!admin.ok) return admin.response;
+    return handleAdminUpdatePublisherProfile(ctx, request, authResult.userId, rate.headers);
+  }
+
   const payloadResult = await parseJsonPayload(request, rate.headers);
   if (!payloadResult.ok) return payloadResult.response;
   const payload = payloadResult.payload;
@@ -930,6 +940,85 @@ async function handleAdminEnsurePublisher(
   }
 }
 
+const PUBLISHER_PROFILE_IMAGE_MAX_BYTES = 2 * 1024 * 1024;
+const PUBLISHER_PROFILE_IMAGE_CONTENT_TYPES = new Set(["image/jpeg", "image/png", "image/webp"]);
+
+async function handleAdminUpdatePublisherProfile(
+  ctx: ActionCtx,
+  request: Request,
+  actorUserId: Id<"users">,
+  headers: HeadersInit,
+) {
+  let form: FormData;
+  try {
+    form = await request.formData();
+  } catch {
+    return text("Invalid multipart form", 400, headers);
+  }
+  const payloadRaw = form.get("payload");
+  if (typeof payloadRaw !== "string") return text("Missing payload", 400, headers);
+  let payload: Record<string, unknown>;
+  try {
+    const parsed = JSON.parse(payloadRaw) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return text("JSON payload must be an object", 400, headers);
+    }
+    payload = parsed as Record<string, unknown>;
+  } catch {
+    return text("Invalid JSON payload", 400, headers);
+  }
+
+  const handle = typeof payload.handle === "string" ? payload.handle.trim().toLowerCase() : "";
+  const reason = typeof payload.reason === "string" ? payload.reason.trim() : "";
+  const hasBio = Object.prototype.hasOwnProperty.call(payload, "bio");
+  const bio = typeof payload.bio === "string" ? payload.bio.trim() : undefined;
+  if (!handle) return text("Missing handle", 400, headers);
+  if (!reason) return text("Missing reason", 400, headers);
+  if (reason.length > 500) return text("Reason too long (max 500 chars)", 400, headers);
+  if (hasBio && typeof payload.bio !== "string") return text("bio must be a string", 400, headers);
+
+  const logoParts = form.getAll("logo");
+  if (logoParts.length > 1) return text("Upload one logo", 400, headers);
+  const logo = logoParts[0];
+  if (typeof logo === "string") return text("logo must be a file", 400, headers);
+  if (!hasBio && !logo) return text("bio or logo required", 400, headers);
+  if (
+    logo &&
+    (logo.size <= 0 ||
+      logo.size > PUBLISHER_PROFILE_IMAGE_MAX_BYTES ||
+      !PUBLISHER_PROFILE_IMAGE_CONTENT_TYPES.has(logo.type))
+  ) {
+    return text("Logo must be a PNG, JPEG, or WebP image smaller than 2 MB", 400, headers);
+  }
+
+  let imageStorageId: Id<"_storage"> | undefined;
+  try {
+    if (logo) imageStorageId = await ctx.storage.store(logo);
+    const result = await runUsersV1MutationRef<{
+      ok: true;
+      publisherId: Id<"publishers">;
+      handle: string;
+      bio: string | null;
+      image: string | null;
+      bioUpdated: boolean;
+      logoUpdated: boolean;
+    }>(ctx, usersV1InternalRefs.publishers.updateOrgPublisherProfileInternal, {
+      actorUserId,
+      handle,
+      ...(hasBio ? { bio: bio ?? "" } : {}),
+      ...(imageStorageId ? { imageStorageId } : {}),
+      reason,
+    });
+    return json(result, 200, headers);
+  } catch (error) {
+    if (imageStorageId) await ctx.storage.delete(imageStorageId);
+    const message = error instanceof Error ? error.message : "Publisher profile update failed";
+    if (/not found/i.test(message)) return text(message, 404, headers);
+    if (/unauthorized|forbidden/i.test(message)) return text("Forbidden", 403, headers);
+    return text(message, 400, headers);
+  }
+}
+
 async function handleBanAppealUnban(
   ctx: ActionCtx,
   request: Request,