@takosjp/yurucommu-core 3.0.3 → 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/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 経由で踏むため)。 未設定なら

package/src/db/schema/mobile.ts

@@ -2,7 +2,13 @@
  * Mobile client tables.
  */
 
-import { index, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import {
+  index,
+  integer,
+  sqliteTable,
+  text,
+  uniqueIndex,
+} from "drizzle-orm/sqlite-core";
 import { nowIsoUtc } from "./date-utils.ts";
 import { actors } from "./actors.ts";
 
@@ -35,3 +41,97 @@ export const mobilePushRegistrations = sqliteTable(
     index("mobile_push_registrations_last_seen_idx").on(t.lastSeenAt),
   ],
 );
+
+/**
+ * Product-neutral notification pushers shared by yurucommu-family clients.
+ *
+ * `pushkey` is an opaque downstream-provider identifier. Provider credentials
+ * never live in this table; they stay in the configured stateless gateway.
+ */
+export const notificationPushers = sqliteTable(
+  "notification_pushers",
+  {
+    id: text("id").primaryKey(),
+    actorApId: text("actor_ap_id")
+      .notNull()
+      .references(() => actors.apId),
+    product: text("product").notNull(),
+    scope: text("scope"),
+    kind: text("kind").notNull().default("http"),
+    appId: text("app_id").notNull(),
+    pushkey: text("pushkey").notNull(),
+    pushkeyHash: text("pushkey_hash").notNull(),
+    appDisplayName: text("app_display_name"),
+    deviceDisplayName: text("device_display_name"),
+    profileTag: text("profile_tag"),
+    lang: text("lang"),
+    dataJson: text("data_json").notNull().default("{}"),
+    gatewayUrl: text("gateway_url").notNull(),
+    createdAt: text("created_at").notNull().$defaultFn(nowIsoUtc),
+    updatedAt: text("updated_at")
+      .notNull()
+      .$defaultFn(nowIsoUtc)
+      .$onUpdateFn(nowIsoUtc),
+    lastSeenAt: text("last_seen_at").notNull().$defaultFn(nowIsoUtc),
+  },
+  (t) => [
+    uniqueIndex("notification_pushers_actor_product_app_pushkey_idx").on(
+      t.actorApId,
+      t.product,
+      t.appId,
+      t.pushkeyHash,
+    ),
+    index("notification_pushers_actor_product_idx").on(t.actorApId, t.product),
+    uniqueIndex("notification_pushers_device_idx").on(
+      t.product,
+      t.appId,
+      t.pushkeyHash,
+    ),
+    index("notification_pushers_last_seen_idx").on(t.lastSeenAt),
+  ],
+);
+
+/**
+ * Durable outbox for push delivery. A migration-owned trigger writes one row
+ * whenever an unread inbox entry is created. Queue messages contain only `id`.
+ */
+export const notificationPushJobs = sqliteTable(
+  "notification_push_jobs",
+  {
+    id: text("id").primaryKey(),
+    actorApId: text("actor_ap_id").notNull(),
+    activityApId: text("activity_ap_id").notNull(),
+    // Explicit for notification sources that do not create an inbox row (for
+    // example community talk). NULL means infer social/direct from the object.
+    product: text("product"),
+    status: text("status").notNull().default("pending"),
+    // Per-claim fencing token. Every processing-state mutation must match this
+    // value so an expired worker cannot overwrite a reclaimed job.
+    processingToken: text("processing_token"),
+    attempts: integer("attempts").notNull().default(0),
+    pendingPusherIdsJson: text("pending_pusher_ids_json"),
+    nextAttemptAt: text("next_attempt_at").notNull().$defaultFn(nowIsoUtc),
+    lastError: text("last_error"),
+    createdAt: text("created_at").notNull().$defaultFn(nowIsoUtc),
+    updatedAt: text("updated_at")
+      .notNull()
+      .$defaultFn(nowIsoUtc)
+      .$onUpdateFn(nowIsoUtc),
+    deliveredAt: text("delivered_at"),
+  },
+  (t) => [
+    uniqueIndex("notification_push_jobs_actor_activity_idx").on(
+      t.actorApId,
+      t.activityApId,
+    ),
+    index("notification_push_jobs_status_next_idx").on(
+      t.status,
+      t.nextAttemptAt,
+    ),
+    index("notification_push_jobs_terminal_retention_idx").on(
+      t.status,
+      t.updatedAt,
+    ),
+    index("notification_push_jobs_actor_idx").on(t.actorApId),
+  ],
+);