@takosjp/yurucommu-core 3.0.2 → 3.2.0

package/src/backend/routes/dm/messages.ts

@@ -10,6 +10,7 @@ import {
   actorCache,
   actors,
   blocks,
+  dmReadStatus,
   inbox as inboxTable,
   objectRecipients,
   objects,
@@ -35,6 +36,11 @@ import {
 } from "./query-helpers.ts";
 import { enqueueDeliveryToActor } from "../../lib/delivery/queue.ts";
 import { feedCursorWhere } from "../../lib/feed-cursor.ts";
+import { toApAttachments } from "../../lib/activitypub-helpers.ts";
+import {
+  MAX_ATTACHMENTS,
+  MAX_ATTACHMENTS_JSON_LENGTH,
+} from "../posts/transformers.ts";
 import { logger } from "../../lib/logger.ts";
 
 const log = logger.child({ component: "dm.messages" });
@@ -90,19 +96,28 @@ type DmMessageResponse = {
   created_at: string | null;
 };
 
-/** Validate trimmed DM content; returns the trimmed string or an error response. */
+/**
+ * Validate trimmed DM content; returns the trimmed string or an error response.
+ * With `allowEmpty` (an attachment-only message) an empty/absent content is
+ * accepted and normalized to "".
+ */
 function validateContent(
   raw: unknown,
+  allowEmpty = false,
 ): string | { error: string; status: 400 } {
   // The json<{content:string}>() cast is compile-time only; a client can send a
   // non-string. Guard before .trim() else TypeError → 500 (the global handler
   // deliberately does not mask TypeError as 400). Mirrors the profile/post/invite
   // validators.
   if (typeof raw !== "string") {
+    if (allowEmpty && (raw === undefined || raw === null)) return "";
     return { error: "Message content is required", status: 400 };
   }
   const content = raw.trim();
-  if (!content) return { error: "Message content is required", status: 400 };
+  if (!content) {
+    if (allowEmpty) return "";
+    return { error: "Message content is required", status: 400 };
+  }
   if (content.length > MAX_DM_CONTENT_LENGTH) {
     return {
       error: `Message too long (max ${MAX_DM_CONTENT_LENGTH} chars)`,
@@ -112,6 +127,34 @@ function validateContent(
   return content;
 }
 
+/**
+ * Validate a chat message's attachments array (mirrors the post-create bounds:
+ * records only, capped count + serialized size — the size cap bounds row and
+ * federated-doc bloat regardless of internal shape). Returns the validated
+ * array ([] when absent) or an error response.
+ */
+function validateAttachments(
+  raw: unknown,
+): Attachment[] | { error: string; status: 400 } {
+  if (raw === undefined || raw === null) return [];
+  if (!Array.isArray(raw)) {
+    return { error: "attachments must be an array", status: 400 };
+  }
+  if (raw.some((a) => !a || typeof a !== "object" || Array.isArray(a))) {
+    return { error: "attachments must be objects", status: 400 };
+  }
+  if (raw.length > MAX_ATTACHMENTS) {
+    return {
+      error: `Too many attachments (max ${MAX_ATTACHMENTS})`,
+      status: 400,
+    };
+  }
+  if (JSON.stringify(raw).length > MAX_ATTACHMENTS_JSON_LENGTH) {
+    return { error: "attachments payload too large", status: 400 };
+  }
+  return raw as Attachment[];
+}
+
 /**
  * Resolve a `user@domain` handle for a DM recipient. Prefers the stored
  * preferredUsername paired with the recipient's host, falling back to
@@ -334,6 +377,7 @@ function dmNoteInsert(
     apId: string;
     actorApId: string;
     content: string;
+    attachments: Attachment[];
     toJson: string;
     conversationId: string;
     published: string;
@@ -344,6 +388,7 @@ function dmNoteInsert(
     type: "Note",
     attributedTo: data.actorApId,
     content: data.content,
+    attachmentsJson: JSON.stringify(data.attachments),
     visibility: "direct",
     toJson: data.toJson,
     ccJson: JSON.stringify([]),
@@ -380,10 +425,27 @@ dm.get("/user/:encodedApId/messages", async (c) => {
     limit,
     before,
   );
+
+  // The partner's read position (LOCAL-ONLY read receipt): the row only exists
+  // when the other participant is a local account that opened the thread —
+  // read state is never federated, so a remote partner stays null ("unknown")
+  // rather than "unread".
+  const partnerRead = await db
+    .select({ lastReadAt: dmReadStatus.lastReadAt })
+    .from(dmReadStatus)
+    .where(
+      and(
+        eq(dmReadStatus.actorApId, otherApId),
+        eq(dmReadStatus.conversationId, conversationId),
+      ),
+    )
+    .get();
+
   return c.json({
     messages,
     conversation_id: conversationId,
     has_more: hasMore,
+    partner_last_read_at: partnerRead?.lastReadAt ?? null,
   });
 });
 
@@ -394,10 +456,23 @@ dm.post("/user/:encodedApId/messages", async (c) => {
 
   const db = c.get("db");
   const otherApId = decodeURIComponent(c.req.param("encodedApId"));
-  const body = await c.req.json<{ content: string }>();
+  const body = await c.req.json<{
+    content?: string;
+    attachments?: unknown;
+  }>();
   const baseUrl = c.env.APP_URL;
 
-  const contentOrError = validateContent(body.content);
+  const attachmentsOrError = validateAttachments(body.attachments);
+  if (!Array.isArray(attachmentsOrError)) {
+    return c.json(
+      { error: attachmentsOrError.error },
+      attachmentsOrError.status,
+    );
+  }
+  const attachments = attachmentsOrError;
+
+  // An attachment-only message (LINE-style image send) carries no text.
+  const contentOrError = validateContent(body.content, attachments.length > 0);
   if (typeof contentOrError !== "string") {
     return c.json({ error: contentOrError.error }, contentOrError.status);
   }
@@ -466,6 +541,9 @@ dm.post("/user/:encodedApId/messages", async (c) => {
   const mentionTag = [
     { type: "Mention", href: otherApId, name: recipientName },
   ];
+  // Media is stored as an app-relative /media path; absolutize (and strip the
+  // internal r2_key) for the federated copy so the remote can fetch it.
+  const apAttachments = toApAttachments(attachments, baseUrl);
   const remoteCreateActivity = !isRecipientLocal
     ? {
         "@context": "https://www.w3.org/ns/activitystreams",
@@ -480,6 +558,7 @@ dm.post("/user/:encodedApId/messages", async (c) => {
           attributedTo: actor.ap_id,
           to: [otherApId],
           content,
+          ...(apAttachments.length > 0 ? { attachment: apAttachments } : {}),
           published: now,
           conversation: conversationId,
           tag: mentionTag,
@@ -498,6 +577,7 @@ dm.post("/user/:encodedApId/messages", async (c) => {
     apId,
     actorApId: actor.ap_id,
     content,
+    attachments,
     toJson,
     conversationId,
     published: now,
@@ -560,6 +640,7 @@ dm.post("/user/:encodedApId/messages", async (c) => {
         id: apId,
         sender: buildSenderFromActor(actor),
         content,
+        attachments,
         created_at: now,
       },
       conversation_id: conversationId,

package/src/backend/routes/notification-pushers.ts

@@ -0,0 +1,93 @@
+import { Hono } from "hono";
+
+import type { Env, Variables } from "../types.ts";
+import { requireActor } from "./actors-helpers.ts";
+import { parseJsonObject } from "../lib/parse-helpers.ts";
+import {
+  normalizeGatewayUrl,
+  parseNotificationPusherDeleteRequest,
+  parseNotificationPusherSetRequest,
+} from "../lib/notification-pusher-contract.ts";
+import {
+  deleteNotificationPusher,
+  isNotificationGatewayAllowed,
+  registerNotificationPusher,
+} from "../lib/notification-push.ts";
+
+const pushers = new Hono<{ Bindings: Env; Variables: Variables }>();
+
+pushers.get("/config", (c) => {
+  const actor = requireActor(c);
+  if (actor instanceof Response) return actor;
+
+  const configuredGateway = normalizeGatewayUrl(
+    c.env.YURUCOMMU_NOTIFICATION_PUSH_GATEWAY_URL,
+  );
+  const gatewayUrl =
+    configuredGateway && isNotificationGatewayAllowed(c.env, configuredGateway)
+      ? configuredGateway
+      : null;
+  const configuredPublicKey =
+    c.env.YURUCOMMU_NOTIFICATION_PUSH_WEB_PUSH_PUBLIC_KEY?.trim() ?? "";
+  const webPushPublicKey = normalizeWebPushPublicKey(configuredPublicKey);
+
+  return c.json({
+    gateway_url: gatewayUrl,
+    web_push_public_key: webPushPublicKey,
+  });
+});
+
+pushers.post("/", async (c) => {
+  const actor = requireActor(c);
+  if (actor instanceof Response) return actor;
+  const body = await parseJsonObject(c);
+  if (!body) {
+    return c.json({ code: "BAD_REQUEST", error: "Invalid request body" }, 400);
+  }
+  const parsed = parseNotificationPusherSetRequest(body);
+  if (!parsed.ok) return c.json(parsed.error, 400);
+  if (!isNotificationGatewayAllowed(c.env, parsed.value.gatewayUrl)) {
+    return c.json(
+      {
+        code: "BAD_REQUEST",
+        error: "pusher.data.url is not allowed by this server",
+        field: "pusher.data.url",
+      },
+      400,
+    );
+  }
+  const pusher = await registerNotificationPusher(
+    c.get("db"),
+    actor,
+    parsed.value,
+  );
+  return c.json({ pusher });
+});
+
+pushers.delete("/", async (c) => {
+  const actor = requireActor(c);
+  if (actor instanceof Response) return actor;
+  const body = await parseJsonObject(c);
+  if (!body) {
+    return c.json({ code: "BAD_REQUEST", error: "Invalid request body" }, 400);
+  }
+  const parsed = parseNotificationPusherDeleteRequest(body);
+  if (!parsed.ok) return c.json(parsed.error, 400);
+  await deleteNotificationPusher(c.get("db"), actor, parsed.value);
+  return c.json({ deleted: true as const });
+});
+
+export default pushers;
+
+function normalizeWebPushPublicKey(value: string): string | null {
+  if (!/^[A-Za-z0-9_-]{87}$/.test(value)) return null;
+  try {
+    const padded = value.replace(/-/g, "+").replace(/_/g, "/") + "=";
+    const decoded = Uint8Array.from(atob(padded), (character) =>
+      character.charCodeAt(0),
+    );
+    return decoded.byteLength === 65 && decoded[0] === 0x04 ? value : null;
+  } catch {
+    return null;
+  }
+}

package/src/backend/routes/notifications.ts

@@ -233,6 +233,44 @@ function encodeNotifCursor(row: { created_at: string; id: string }): string {
   return `${row.created_at}${NOTIF_CURSOR_SEP}${row.id}`;
 }
 
+function notificationTarget(
+  type: string | null,
+  activityActorApId: string,
+  objectApId: string | null,
+  objectType: string | null,
+): {
+  target_kind: "post" | "story" | "profile" | "notifications";
+  target_id: string | null;
+  target_url: string;
+} {
+  if (type === "follow" || type === "follow_request") {
+    return {
+      target_kind: "profile",
+      target_id: activityActorApId,
+      target_url: `/profile/${encodeURIComponent(activityActorApId)}`,
+    };
+  }
+  if (objectApId && objectType === "Story") {
+    return {
+      target_kind: "story",
+      target_id: objectApId,
+      target_url: `/?story=${encodeURIComponent(objectApId)}`,
+    };
+  }
+  if (objectApId) {
+    return {
+      target_kind: "post",
+      target_id: objectApId,
+      target_url: `/post/${encodeURIComponent(objectApId)}`,
+    };
+  }
+  return {
+    target_kind: "notifications",
+    target_id: null,
+    target_url: "/notifications",
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Routes
 // ---------------------------------------------------------------------------
@@ -358,6 +396,7 @@ notifications.get("/", async (c) => {
       ? db
           .select({
             apId: objects.apId,
+            type: objects.type,
             content: objects.content,
             inReplyTo: objects.inReplyTo,
             audienceJson: objects.audienceJson,
@@ -438,6 +477,7 @@ notifications.get("/", async (c) => {
     objectRows.map((o) => [
       o.apId,
       {
+        type: o.type,
         content: readableObjectIds.has(o.apId) ? o.content : "",
         inReplyTo: o.inReplyTo,
       },
@@ -464,6 +504,9 @@ notifications.get("/", async (c) => {
       icon_url: string | null;
     };
     object_content: string;
+    target_kind: "post" | "story" | "profile" | "community" | "notifications";
+    target_id: string | null;
+    target_url: string;
   }> = [];
 
   for (const entry of inboxEntries) {
@@ -484,6 +527,12 @@ notifications.get("/", async (c) => {
       followStatus,
     );
     const actorInfo = actorMap.get(entry.activityActorApId);
+    const target = notificationTarget(
+      notifType,
+      entry.activityActorApId,
+      entry.activityObjectApId,
+      objectData?.type ?? null,
+    );
 
     notifications_list.push({
       id: entry.activityApId,
@@ -499,6 +548,7 @@ notifications.get("/", async (c) => {
         icon_url: actorInfo?.iconUrl ?? null,
       },
       object_content: objectData?.content ?? "",
+      ...target,
     });
   }
 

package/src/backend/routes/stories/interactions.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import { and, eq, gt, sql } from "drizzle-orm";
+import { and, count, desc, eq, gt, sql } from "drizzle-orm";
 import type { Env, Variables } from "../../types.ts";
 import {
   activities,
@@ -18,12 +18,14 @@ import {
   safeJsonParse,
 } from "../../federation-helpers.ts";
 import {
+  buildAuthor,
   canViewerReadStory,
   findStory,
   getVoteCounts,
   resolveStoryApId,
   sumVotes,
 } from "./query-helpers.ts";
+import { loadActorInfoMap } from "../actors-helpers.ts";
 import { enqueueDeliveryToActor } from "../../lib/delivery/queue.ts";
 import { actorIsBlockedBy } from "../../lib/post-visibility.ts";
 import { rateLimit, RateLimitConfigs } from "../../middleware/rate-limit.ts";
@@ -573,4 +575,66 @@ stories.get("/:id/votes", async (c) => {
   return c.json({ votes, total: sumVotes(votes), user_vote });
 });
 
+// Cap the returned viewer list most-recent-first. `view_count` stays the true
+// total (the author sees the real number even when the list is truncated).
+const STORY_VIEWERS_LIMIT = 200;
+
+// Get the "seen by" viewer list for a story (author-only).
+stories.get("/:id/views", async (c) => {
+  const db = c.get("db");
+  const actor = c.get("actor");
+  const baseUrl = c.env.APP_URL;
+  // Resolve the id the same way every sibling /:id/* route does.
+  const apId = resolveStoryApId(c.req.param("id"), baseUrl);
+
+  const story = await findStory(db, apId);
+  if (!story) return c.json({ error: "Story not found" }, 404);
+
+  // Author-only: only the story author may see WHO viewed. Anyone else
+  // (including anonymous) gets 404 so the viewer list isn't disclosed and the
+  // endpoint isn't a story-existence oracle for non-authors.
+  if (!actor || actor.ap_id !== story.attributedTo) {
+    return c.json({ error: "Story not found" }, 404);
+  }
+  // Mirror the /:id/votes expiry gate: don't serve the list for an expired
+  // story before the reaper runs.
+  if (story.endTime && story.endTime < new Date().toISOString()) {
+    return c.json({ error: "Story has expired" }, 410);
+  }
+
+  // True total (uncapped) — stays accurate even when the list below is capped.
+  const totalRow = await db
+    .select({ value: count() })
+    .from(storyViews)
+    .where(eq(storyViews.storyApId, apId))
+    .get();
+  const view_count = totalRow?.value ?? 0;
+
+  // Most-recent-first page of viewers, capped.
+  const rows = await db
+    .select({
+      actorApId: storyViews.actorApId,
+      viewedAt: storyViews.viewedAt,
+    })
+    .from(storyViews)
+    .where(eq(storyViews.storyApId, apId))
+    .orderBy(desc(storyViews.viewedAt))
+    .limit(STORY_VIEWERS_LIMIT);
+
+  // Hydrate ap_id → PostAuthor via the same batch loader the follower/story
+  // lists use (local `actors` + `actor_cache`, local wins). A remote viewer
+  // absent from both degrades to a best-effort author in `buildAuthor`.
+  const infoMap = await loadActorInfoMap(
+    db,
+    rows.map((r) => r.actorApId),
+    "author",
+  );
+  const viewers = rows.map((r) => ({
+    actor: buildAuthor(r.actorApId, infoMap.get(r.actorApId)),
+    viewed_at: r.viewedAt,
+  }));
+
+  return c.json({ view_count, viewers });
+});
+
 export default stories;

package/src/backend/routes/stories/query-helpers.ts

@@ -11,7 +11,11 @@ import {
   storyVotes,
 } from "../../../db/index.ts";
 import type { IObjectStorage } from "../../runtime/types.ts";
-import { objectApId, safeJsonParse } from "../../federation-helpers.ts";
+import {
+  formatUsername,
+  objectApId,
+  safeJsonParse,
+} from "../../federation-helpers.ts";
 import {
   deleteObjectCascade,
   purgeMediaBlobs,
@@ -271,6 +275,49 @@ export async function fetchActorCache(
   );
 }
 
+// ---------------------------------------------------------------------------
+// Author projection
+// ---------------------------------------------------------------------------
+
+/**
+ * Public author projection for a story author / viewer (the `PostAuthor` shape
+ * used across the feed / story surfaces). Shared by the story feed and the
+ * viewer ("seen by") list so both hydrate an ap_id → author identically.
+ */
+export type StoryAuthor = {
+  ap_id: string;
+  username: string;
+  preferred_username: string | null;
+  name: string | null;
+  icon_url: string | null;
+};
+
+/**
+ * Build a StoryAuthor from available data sources. A remote actor with no local
+ * `actors` / `actor_cache` row (`data` undefined) degrades gracefully to a
+ * best-effort `username` derived from the ap_id plus null fields, so a viewer is
+ * never dropped just because its profile isn't cached locally.
+ */
+export function buildAuthor(
+  apId: string,
+  data:
+    | {
+        preferredUsername?: string | null;
+        name?: string | null;
+        iconUrl?: string | null;
+      }
+    | null
+    | undefined,
+): StoryAuthor {
+  return {
+    ap_id: apId,
+    username: formatUsername(apId),
+    preferred_username: data?.preferredUsername || null,
+    name: data?.name || null,
+    icon_url: data?.iconUrl || null,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Story data cleanup & transformation
 // ---------------------------------------------------------------------------

package/src/backend/routes/stories/routes.ts

@@ -21,7 +21,6 @@ import type { IObjectStorage } from "../../runtime/types.ts";
 import {
   activityApId,
   actorApId,
-  formatUsername,
   generateId,
   objectApId,
 } from "../../federation-helpers.ts";
@@ -31,10 +30,12 @@ import { maybeReapDrainedTombstones } from "../actors.ts";
 import { checkCommunityPostPermission } from "../posts/post-helpers.ts";
 import { rateLimit, RateLimitConfigs } from "../../middleware/rate-limit.ts";
 import {
+  buildAuthor,
   cleanupExpiredStories,
   fetchActorCache,
   fetchBatchVotes,
   fetchBlockedAndMutedIds,
+  type StoryAuthor,
   sumVotes,
   transformStoryData,
   validateOverlays,
@@ -101,14 +102,6 @@ stories.post("/delete", storyWriteLimiter);
 
 type VoteResults = Record<number, number>;
 
-type StoryAuthor = {
-  ap_id: string;
-  username: string;
-  preferred_username: string | null;
-  name: string | null;
-  icon_url: string | null;
-};
-
 type StoryResponse = {
   ap_id: string;
   author: StoryAuthor;
@@ -160,27 +153,6 @@ const MAX_STORY_CAPTION_LENGTH = 500;
 // feed page; a busy instance simply shows the 90 most recent.
 const MAX_STORY_FEED_ITEMS = 90;
 
-/** Build a StoryAuthor from available data sources. */
-function buildAuthor(
-  apId: string,
-  data:
-    | {
-        preferredUsername?: string | null;
-        name?: string | null;
-        iconUrl?: string | null;
-      }
-    | null
-    | undefined,
-): StoryAuthor {
-  return {
-    ap_id: apId,
-    username: formatUsername(apId),
-    preferred_username: data?.preferredUsername || null,
-    name: data?.name || null,
-    icon_url: data?.iconUrl || null,
-  };
-}
-
 /** Build a StoryResponse from a story object row and pre-fetched data. */
 function buildStoryResponse(
   s: {

package/src/backend/server.ts

@@ -96,6 +96,12 @@ const ENV_PASSTHROUGH_KEYS = [
   "DELIVERY_DLQ_NAME",
   "YURUCOMMU_ENABLE_LOCAL_SUBSTRATE_REMOTE_FETCHES",
   "YURUCOMMU_ENABLE_LOCAL_DELIVERY_QUEUE",
+  "YURUCOMMU_NOTIFICATION_PUSH_GATEWAY_ALLOWED_HOSTS",
+  "YURUCOMMU_NOTIFICATION_PUSH_GATEWAY_URL",
+  "YURUCOMMU_NOTIFICATION_PUSH_GATEWAY_TOKEN",
+  "YURUCOMMU_NOTIFICATION_PUSH_GATEWAY_TIMEOUT_MS",
+  "YURUCOMMU_NOTIFICATION_PUSH_ALLOW_INSECURE_LOOPBACK",
+  "YURUCOMMU_NOTIFICATION_PUSH_WEB_PUSH_PUBLIC_KEY",
 ] as const;
 
 function isTruthyEnv(value: string | undefined): boolean {

package/src/backend/types.ts

@@ -67,6 +67,18 @@ export interface EnvVars {
   // app falls back to the YURUCOMMU_VERSION default constant.
   YURUCOMMU_SOFTWARE_VERSION?: string;
 
+  // Product-neutral notification pusher gateway. Public gateway registration
+  // is fail-closed until its hostname is explicitly allowlisted. The bearer is
+  // attached only when data.url exactly matches the canonical URL.
+  YURUCOMMU_NOTIFICATION_PUSH_GATEWAY_ALLOWED_HOSTS?: string;
+  YURUCOMMU_NOTIFICATION_PUSH_GATEWAY_URL?: string;
+  YURUCOMMU_NOTIFICATION_PUSH_GATEWAY_TOKEN?: string;
+  YURUCOMMU_NOTIFICATION_PUSH_GATEWAY_TIMEOUT_MS?: string;
+  YURUCOMMU_NOTIFICATION_PUSH_ALLOW_INSECURE_LOOPBACK?: string;
+  // Public VAPID application-server key exposed to authenticated browser
+  // clients. The corresponding private key remains gateway-owned.
+  YURUCOMMU_NOTIFICATION_PUSH_WEB_PUSH_PUBLIC_KEY?: string;
+
   // CSRF allowed origins (comma-separated). APP_URL の origin に加えて
   // 受け付ける追加 origin (= dev hostname (`https://yurucommu.test`) を
   // production-equivalent な strict CSRF check 経由で踏むため)。 未設定なら