@takosjp/yurucommu-core 3.0.0

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

@@ -0,0 +1,85 @@
+import { and, desc, eq, inArray, isNotNull, or } from "drizzle-orm";
+import type { Database } from "../../../db/index.ts";
+import { objects } from "../../../db/index.ts";
+import { recipientObjectIds } from "./conversations-helpers.ts";
+import { base64UrlEncode } from "../../lib/oauth-utils.ts";
+
+export const MAX_DM_CONTENT_LENGTH = 5000;
+// Capped at 90 (not 100): a page of DM ids is re-queried via `inArray` for
+// author/recipient enrichment, and Cloudflare D1 allows at most 100 bound
+// parameters per query. (Tests run on libsql's ~32k ceiling, which hides this.)
+export const MAX_DM_PAGE_LIMIT = 90;
+
+/**
+ * Derive the deterministic conversation ID for a DM between two actors.
+ *
+ * The two participant AP-IDs are sorted (so the order in which the pair is
+ * supplied does not matter) and joined with a newline — a byte that cannot
+ * appear inside an AP-ID URL, so it is an unambiguous separator. The joined
+ * pair is then base64url-encoded WITHOUT truncation, which makes the mapping
+ * from actor-pair to conversation ID injective: distinct pairs always produce
+ * distinct IDs, eliminating the collisions that the previous 16-char,
+ * alnum-stripped base64 truncation produced (two same-host actor URLs share a
+ * long common base64 prefix, so the old scheme collapsed every same-host pair
+ * onto the same ID).
+ *
+ * Migration note: this changes the ID derived for a given pair, so DM objects,
+ * read status and archive rows written under the old truncated scheme will not
+ * be matched by the new ID. `resolveConversationId` first looks up the existing
+ * conversation ID stored on prior DM objects, so already-threaded conversations
+ * keep working; only the synchronous `getConversationId` fallback (no prior
+ * message, archive, read-status) changes. There is no automatic backfill: the
+ * old IDs were collision-prone and are intentionally not reproduced.
+ */
+export function getConversationId(
+  baseUrl: string,
+  ap1: string,
+  ap2: string,
+): string {
+  const [p1, p2] = [ap1, ap2].sort();
+  const bytes = new TextEncoder().encode(`${p1}\n${p2}`);
+  // base64url, no padding: URL-safe and free of characters that would be
+  // stripped, so the full (collision-free) encoding is preserved.
+  const hash = base64UrlEncode(bytes.buffer);
+  return `${baseUrl}/ap/conversations/${hash}`;
+}
+
+export async function resolveConversationId(
+  db: Database,
+  baseUrl: string,
+  actorApId: string,
+  otherApId: string,
+): Promise<string> {
+  // Find existing conversation between these two actors
+  const existing = await db
+    .select({ conversation: objects.conversation })
+    .from(objects)
+    .where(
+      and(
+        eq(objects.visibility, "direct"),
+        eq(objects.type, "Note"),
+        isNotNull(objects.conversation),
+        // A DM between this pair = a Note authored by one and addressed to the
+        // other. Recipient membership is resolved via the indexed
+        // object_recipients link (see recipientObjectIds) instead of an
+        // unindexable `to_json LIKE '%"<apId>"%'` scan; same semantics.
+        or(
+          and(
+            eq(objects.attributedTo, actorApId),
+            inArray(objects.apId, recipientObjectIds(db, otherApId)),
+          ),
+          and(
+            eq(objects.attributedTo, otherApId),
+            inArray(objects.apId, recipientObjectIds(db, actorApId)),
+          ),
+        ),
+      ),
+    )
+    .orderBy(desc(objects.published))
+    .limit(1)
+    .get();
+
+  return (
+    existing?.conversation || getConversationId(baseUrl, actorApId, otherApId)
+  );
+}

package/src/backend/routes/dm/read-archive.ts

@@ -0,0 +1,228 @@
+// DM read status and archive management
+
+import { Hono } from "hono";
+import { and, desc, eq } from "drizzle-orm";
+import {
+  communities,
+  communityMembers,
+  dmArchivedConversations,
+  dmCommunityReadStatus,
+  dmReadStatus,
+  objects,
+} from "../../../db/index.ts";
+import { resolveConversationId } from "./query-helpers.ts";
+import {
+  buildActorInfoMap,
+  byTimeDesc,
+  dmWhereForActor,
+  formatActorProfile,
+  groupConversations,
+  type HonoEnv,
+  parseOtherApId,
+  uniqueValues,
+} from "./conversations-helpers.ts";
+
+const readArchive = new Hono<HonoEnv>();
+
+// Mark conversation as read
+readArchive.post("/user/:encodedApId/read", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "Unauthorized" }, 401);
+  const db = c.get("db");
+
+  const otherApId = parseOtherApId(c);
+  if (!otherApId) return c.json({ error: "ap_id required" }, 400);
+
+  const baseUrl = c.env.APP_URL;
+  const conversationId = await resolveConversationId(
+    db,
+    baseUrl,
+    actor.ap_id,
+    otherApId,
+  );
+  const now = new Date().toISOString();
+
+  await db
+    .insert(dmReadStatus)
+    .values({
+      actorApId: actor.ap_id,
+      conversationId,
+      lastReadAt: now,
+    })
+    .onConflictDoUpdate({
+      target: [dmReadStatus.actorApId, dmReadStatus.conversationId],
+      set: { lastReadAt: now },
+    });
+
+  return c.json({ success: true, last_read_at: now });
+});
+
+// Mark a community (group chat) as read for the current viewer.
+// Mirrors the one-to-one DM read endpoint above; the unread baseline used by
+// GET /contacts is the recorded `last_read_at`.
+readArchive.post("/community/:encodedApId/read", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "Unauthorized" }, 401);
+  const db = c.get("db");
+
+  const communityApId = parseOtherApId(c);
+  if (!communityApId) return c.json({ error: "ap_id required" }, 400);
+
+  // Only track read state for communities that actually exist; otherwise an
+  // arbitrary AP-ID could accumulate orphan rows.
+  const community = await db
+    .select({ apId: communities.apId })
+    .from(communities)
+    .where(eq(communities.apId, communityApId))
+    .get();
+  if (!community) return c.json({ error: "Community not found" }, 404);
+
+  // Only members may track a read position for a community group chat: the
+  // unread baseline is meaningless for non-members and would let an arbitrary
+  // actor write read-status rows for communities they cannot see.
+  const membership = await db
+    .select({ actorApId: communityMembers.actorApId })
+    .from(communityMembers)
+    .where(
+      and(
+        eq(communityMembers.communityApId, communityApId),
+        eq(communityMembers.actorApId, actor.ap_id),
+      ),
+    )
+    .get();
+  if (!membership) return c.json({ error: "Not a community member" }, 403);
+
+  const now = new Date().toISOString();
+  await db
+    .insert(dmCommunityReadStatus)
+    .values({
+      actorApId: actor.ap_id,
+      communityApId,
+      lastReadAt: now,
+    })
+    .onConflictDoUpdate({
+      target: [
+        dmCommunityReadStatus.actorApId,
+        dmCommunityReadStatus.communityApId,
+      ],
+      set: { lastReadAt: now },
+    });
+
+  return c.json({ success: true, last_read_at: now });
+});
+
+// Archive a conversation (hide from inbox)
+readArchive.post("/user/:encodedApId/archive", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "Unauthorized" }, 401);
+  const db = c.get("db");
+
+  const otherApId = parseOtherApId(c);
+  if (!otherApId) return c.json({ error: "ap_id required" }, 400);
+
+  const baseUrl = c.env.APP_URL;
+  // Match the STORED conversation id (legacy- or current-scheme) so archiving a
+  // pre-migration conversation actually hides it (the contacts/unread paths key
+  // on the same stored id) instead of writing a never-matching current-scheme row.
+  const conversationId = await resolveConversationId(
+    db,
+    baseUrl,
+    actor.ap_id,
+    otherApId,
+  );
+  const now = new Date().toISOString();
+
+  await db
+    .insert(dmArchivedConversations)
+    .values({
+      actorApId: actor.ap_id,
+      conversationId,
+      archivedAt: now,
+    })
+    .onConflictDoNothing();
+
+  return c.json({ success: true, archived_at: now });
+});
+
+// Unarchive a conversation
+readArchive.delete("/user/:encodedApId/archive", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "Unauthorized" }, 401);
+  const db = c.get("db");
+
+  const otherApId = parseOtherApId(c);
+  if (!otherApId) return c.json({ error: "ap_id required" }, 400);
+
+  const baseUrl = c.env.APP_URL;
+  const conversationId = await resolveConversationId(
+    db,
+    baseUrl,
+    actor.ap_id,
+    otherApId,
+  );
+
+  await db
+    .delete(dmArchivedConversations)
+    .where(
+      and(
+        eq(dmArchivedConversations.actorApId, actor.ap_id),
+        eq(dmArchivedConversations.conversationId, conversationId),
+      ),
+    );
+
+  return c.json({ success: true });
+});
+
+// Get archived conversations
+readArchive.get("/archived", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "Unauthorized" }, 401);
+  const db = c.get("db");
+
+  const archivedConversations = await db
+    .select({
+      conversationId: dmArchivedConversations.conversationId,
+      archivedAt: dmArchivedConversations.archivedAt,
+    })
+    .from(dmArchivedConversations)
+    .where(eq(dmArchivedConversations.actorApId, actor.ap_id));
+
+  if (archivedConversations.length === 0) {
+    return c.json({ archived: [] });
+  }
+
+  const archivedSet = new Set(
+    archivedConversations.map((a) => a.conversationId),
+  );
+
+  const dmObjects = await db
+    .select({
+      conversation: objects.conversation,
+      attributedTo: objects.attributedTo,
+      toJson: objects.toJson,
+      published: objects.published,
+    })
+    .from(objects)
+    .where(dmWhereForActor(db, actor.ap_id)!)
+    .orderBy(desc(objects.published))
+    .limit(2000);
+
+  const conversationMap = groupConversations(dmObjects, actor.ap_id, (id) =>
+    archivedSet.has(id),
+  );
+
+  const otherApIds = uniqueValues(conversationMap, (c) => c.otherApId);
+  const actorInfoMap = await buildActorInfoMap(db, otherApIds);
+
+  const archived = Array.from(conversationMap.values())
+    .map((conv) => ({
+      ...formatActorProfile(conv.otherApId, actorInfoMap.get(conv.otherApId)),
+      conversation_id: conv.conversation,
+      last_message_at: conv.lastMessageAt,
+    }))
+    .sort((a, b) => byTimeDesc(a.last_message_at, b.last_message_at));
+
+  return c.json({ archived });
+});
+
+export default readArchive;

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

@@ -0,0 +1,222 @@
+// DM requests - list, accept, reject
+
+import { Hono } from "hono";
+import { and, desc, eq, inArray, isNotNull, sql } from "drizzle-orm";
+import {
+  activities,
+  blocks,
+  inbox as inboxTable,
+  objectRecipients,
+  objects,
+} from "../../../db/index.ts";
+import { resolveConversationId } from "./query-helpers.ts";
+import {
+  buildActorInfoMap,
+  findRepliedConversations,
+  formatActorProfile,
+  type HonoEnv,
+  recipientObjectIds,
+} from "./conversations-helpers.ts";
+
+// Upper bound on the number of pending-request CONVERSATIONS returned. The list
+// is collapsed to one row per conversation in SQL (GROUP BY), so this bounds
+// distinct senders, NOT messages — a single high-volume sender can occupy at
+// most one slot and can no longer evict every other pending requester.
+const MAX_REQUEST_CONVERSATIONS = 500;
+
+const requests = new Hono<HonoEnv>();
+
+// Get message requests (DMs from people we haven't replied to)
+requests.get("/requests", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "Unauthorized" }, 401);
+  const db = c.get("db");
+
+  // Collapse to ONE row per conversation IN SQL (GROUP BY) — the latest message
+  // of each — then bound by conversation count. Previously we fetched the 1000
+  // most-recent incoming MESSAGES and deduped in JS, so a single sender with
+  // >1000 stored DMs filled the whole window and evicted every other pending
+  // request (and diverged from the unbounded request_count badge). `max()` with
+  // GROUP BY makes the bare columns take their value from each group's latest
+  // message (SQLite min/max bare-column rule).
+  const latestPerConversation = await db
+    .select({
+      apId: objects.apId,
+      attributedTo: objects.attributedTo,
+      content: objects.content,
+      published: sql<string>`max(${objects.published})`,
+      conversation: objects.conversation,
+    })
+    .from(objects)
+    .where(
+      and(
+        eq(objects.visibility, "direct"),
+        eq(objects.type, "Note"),
+        isNotNull(objects.conversation),
+        // Incoming DMs = Notes where this actor is a `to` recipient. Resolved
+        // via the indexed object_recipients link (see recipientObjectIds)
+        // instead of an unindexable `to_json LIKE '%"<apId>"%'` scan; same
+        // recipient-membership semantics.
+        inArray(objects.apId, recipientObjectIds(db, actor.ap_id)),
+      ),
+    )
+    .groupBy(objects.conversation)
+    .orderBy(desc(sql`max(${objects.published})`))
+    .limit(MAX_REQUEST_CONVERSATIONS);
+
+  const allConversations = latestPerConversation
+    .map((dm) => dm.conversation)
+    .filter((c): c is string => c !== null);
+  const repliedConversationsSet = await findRepliedConversations(
+    db,
+    allConversations,
+    actor.ap_id,
+  );
+
+  // Keep only unreplied conversations; GROUP BY already guarantees one row each.
+  const requestList = latestPerConversation
+    .filter(
+      (dm) => dm.conversation && !repliedConversationsSet.has(dm.conversation),
+    )
+    .map((dm) => ({
+      id: dm.apId,
+      senderApId: dm.attributedTo,
+      content: dm.content,
+      createdAt: dm.published,
+      conversation: dm.conversation,
+    }));
+
+  const senderApIds = [...new Set(requestList.map((r) => r.senderApId))];
+  const actorInfoMap = await buildActorInfoMap(db, senderApIds);
+
+  const result = requestList.map((r) => ({
+    id: r.id,
+    sender: formatActorProfile(r.senderApId, actorInfoMap.get(r.senderApId)),
+    content: r.content,
+    created_at: r.createdAt,
+    conversation: r.conversation,
+  }));
+
+  return c.json({ requests: result });
+});
+
+// Reject request = delete messages from a sender and optionally block
+requests.post("/requests/reject", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "Unauthorized" }, 401);
+  const db = c.get("db");
+
+  const body = await c.req.json<{ sender_ap_id: string; block?: boolean }>();
+  if (!body.sender_ap_id) {
+    return c.json({ error: "sender_ap_id is required" }, 400);
+  }
+
+  const baseUrl = c.env.APP_URL;
+  // Resolve to the STORED conversation id (legacy- or current-scheme) so a
+  // pre-migration thread is actually matched by the deletes below.
+  const conversationId = await resolveConversationId(
+    db,
+    baseUrl,
+    actor.ap_id,
+    body.sender_ap_id,
+  );
+
+  // The set of the sender's messages in this conversation, as a reusable
+  // SUBQUERY (never materialised into an `IN (...)`, which would blow D1's
+  // 100-bound-parameter ceiling once a spammer has written >~100 messages).
+  const senderObjectIds = db
+    .select({ apId: objects.apId })
+    .from(objects)
+    .where(
+      and(
+        eq(objects.conversation, conversationId),
+        eq(objects.attributedTo, body.sender_ap_id),
+      ),
+    );
+
+  // Drop the inbox + delivery Create activities for those messages FIRST, before
+  // the objects vanish. These tables are addressed by AP id with no FK to
+  // `objects`, so deleting only the object orphans them — and the notifications
+  // query LEFT JOINs the now-missing object (gone → NULL visibility → no longer
+  // excluded as "direct"), so each orphan Create would resurface as a blank
+  // "mention" notification with a dead link plus an inflated unread badge. This
+  // mirrors the DM message-delete cleanup (messages.ts).
+  await db
+    .delete(inboxTable)
+    .where(
+      inArray(
+        inboxTable.activityApId,
+        db
+          .select({ apId: activities.apId })
+          .from(activities)
+          .where(inArray(activities.objectApId, senderObjectIds)),
+      ),
+    );
+  await db
+    .delete(activities)
+    .where(inArray(activities.objectApId, senderObjectIds));
+
+  // Delete the recipient rows for every message the sender wrote in this
+  // conversation (same subquery-not-IN reasoning as above).
+  await db
+    .delete(objectRecipients)
+    .where(inArray(objectRecipients.objectApId, senderObjectIds));
+
+  await db
+    .delete(objects)
+    .where(
+      and(
+        eq(objects.conversation, conversationId),
+        eq(objects.visibility, "direct"),
+        eq(objects.attributedTo, body.sender_ap_id),
+      ),
+    );
+
+  if (body.block) {
+    await db
+      .insert(blocks)
+      .values({
+        blockerApId: actor.ap_id,
+        blockedApId: body.sender_ap_id,
+      })
+      .onConflictDoNothing();
+  }
+
+  return c.json({ success: true });
+});
+
+// Accept request.
+//
+// In this AP-native DM model there is no separate "accepted" state to persist:
+// a conversation is treated as a pending request precisely until the recipient
+// sends their first reply (see findRepliedConversations / the /requests list),
+// at which point it leaves the request list and the sender becomes a contact.
+// There is therefore nothing this endpoint can record server-side that would
+// make the request "accepted" without actually sending a reply.
+//
+// Rather than fake a success that immediately reverts on the next reload (the
+// previous behaviour returned { success: true } while changing no state, so the
+// request reappeared and no contact was created), respond honestly: acceptance
+// is performed by replying via POST /api/dm/user/:encodedApId/messages.
+requests.post("/requests/accept", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "Unauthorized" }, 401);
+
+  const body = await c.req.json<{ sender_ap_id: string }>();
+  if (!body.sender_ap_id) {
+    return c.json({ error: "sender_ap_id is required" }, 400);
+  }
+
+  return c.json(
+    {
+      error: "not_implemented",
+      message:
+        "Accepting a request is done by replying to the conversation " +
+        "(POST /api/dm/user/:encodedApId/messages). There is no separate " +
+        "accept action in this DM model.",
+    },
+    501,
+  );
+});
+
+export default requests;

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

@@ -0,0 +1,81 @@
+// DM typing indicators
+
+import { Hono } from "hono";
+import { and, eq } from "drizzle-orm";
+import { dmTyping } from "../../../db/index.ts";
+import { type HonoEnv, parseOtherApId } from "./conversations-helpers.ts";
+
+const typing = new Hono<HonoEnv>();
+
+typing.post("/user/:encodedApId/typing", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "Unauthorized" }, 401);
+  const db = c.get("db");
+
+  const otherApId = parseOtherApId(c);
+  if (!otherApId) return c.json({ error: "ap_id required" }, 400);
+
+  const now = new Date().toISOString();
+  await db
+    .insert(dmTyping)
+    .values({
+      actorApId: actor.ap_id,
+      recipientApId: otherApId,
+      lastTypedAt: now,
+    })
+    .onConflictDoUpdate({
+      target: [dmTyping.actorApId, dmTyping.recipientApId],
+      set: { lastTypedAt: now },
+    });
+
+  return c.json({ success: true, typed_at: now });
+});
+
+typing.get("/user/:encodedApId/typing", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "Unauthorized" }, 401);
+  const db = c.get("db");
+
+  const otherApId = parseOtherApId(c);
+  if (!otherApId) return c.json({ error: "ap_id required" }, 400);
+
+  const typingRecord = await db
+    .select({ lastTypedAt: dmTyping.lastTypedAt })
+    .from(dmTyping)
+    .where(
+      and(
+        eq(dmTyping.actorApId, otherApId),
+        eq(dmTyping.recipientApId, actor.ap_id),
+      ),
+    )
+    .get();
+
+  if (!typingRecord?.lastTypedAt) {
+    return c.json({ is_typing: false, last_typed_at: null });
+  }
+
+  const lastTypedMs = Date.parse(typingRecord.lastTypedAt);
+  const elapsedMs = Date.now() - lastTypedMs;
+  const isValid = Number.isFinite(lastTypedMs);
+  const isTyping = isValid && elapsedMs <= 8000;
+  const isExpired = !isValid || elapsedMs > 5 * 60 * 1000;
+
+  if (isExpired) {
+    await db
+      .delete(dmTyping)
+      .where(
+        and(
+          eq(dmTyping.actorApId, otherApId),
+          eq(dmTyping.recipientApId, actor.ap_id),
+        ),
+      );
+    return c.json({ is_typing: false, last_typed_at: null });
+  }
+
+  return c.json({
+    is_typing: isTyping,
+    last_typed_at: typingRecord.lastTypedAt,
+  });
+});
+
+export default typing;

package/src/backend/routes/dm.ts

@@ -0,0 +1,15 @@
+// Direct Messages - AP Native
+// DMs are Note objects with visibility='direct' and to=[recipient]
+// Threading via conversation field
+
+import { Hono } from "hono";
+import type { Env, Variables } from "../types.ts";
+import conversationRoutes from "./dm/conversations.ts";
+import messageRoutes from "./dm/messages.ts";
+
+const dm = new Hono<{ Bindings: Env; Variables: Variables }>();
+
+dm.route("/", conversationRoutes);
+dm.route("/", messageRoutes);
+
+export default dm;