@takosjp/yurucommu-core 3.4.3 → 3.4.4

package/src/backend/routes/takos-tools/posts.ts

@@ -5,17 +5,34 @@
  *          yurucommu_like_post, yurucommu_bookmark_post
  */
 
-import { and, count, eq, gt } from "drizzle-orm";
+import { and, eq, gt, or } from "drizzle-orm";
 import { sql } from "drizzle-orm";
-import { actors, bookmarks, likes, objects } from "../../../db/index.ts";
+import {
+  actors,
+  bookmarks,
+  objects,
+  runBatch,
+  type D1Statement,
+} from "../../../db/index.ts";
+import { objectApId } from "../../federation-helpers.ts";
 import {
   actorIsBlockedBy,
   canViewerReadObjectFull,
 } from "../../lib/post-visibility.ts";
+import {
+  prepareObjectDeleteCascade,
+  purgeMediaBlobs,
+} from "../posts/delete-cascade.ts";
 import {
   MAX_POST_CONTENT_LENGTH,
   normalizeVisibility,
 } from "../posts/transformers.ts";
+import {
+  prepareCreatedPostFederation,
+  prepareDeletedPostFederation,
+} from "../posts/federation.ts";
+import { setPostLike } from "../posts/like-mutation.ts";
+import { preparePostInsertStatements } from "../posts/post-helpers.ts";
 import {
   errAuth,
   errNotFound,
@@ -28,9 +45,20 @@ import {
 } from "../takos-tools-response.ts";
 import type { Input, ToolContext } from "./types.ts";
 
-// `.batch` lives only on the concrete D1/libsql subclasses; reach it through a
-// narrow structural cast so the object write + postCount update commit together.
-type Batchable = { batch: (stmts: unknown[]) => Promise<unknown> };
+/**
+ * Tool results expose both a full `ap_id` and a compact `post_id`, so every
+ * tool mutation must accept either form. Keep the historical `/ap/notes/:id`
+ * candidate too: older versions minted tool posts under that non-canonical
+ * path, and their returned compact IDs must remain usable for cleanup.
+ */
+function toolPostWhereByIdOrApId(baseUrl: string, postId: string) {
+  const normalizedBase = baseUrl.replace(/\/+$/u, "");
+  return or(
+    eq(objects.apId, postId),
+    eq(objects.apId, objectApId(normalizedBase, postId)),
+    eq(objects.apId, `${normalizedBase}/ap/notes/${postId}`),
+  );
+}
 
 export async function handleCreatePost(
   c: ToolContext,
@@ -44,7 +72,11 @@ export async function handleCreatePost(
   // Constrain visibility to the canonical enum (unknown → "public"), matching
   // the web post route; a raw value would be invisible to every feed filter.
   const visibility = normalizeVisibility(String(input.visibility || "public"));
-  const inReplyTo = input.in_reply_to ? String(input.in_reply_to) : null;
+  const requestedInReplyTo = input.in_reply_to
+    ? String(input.in_reply_to)
+    : null;
+  let inReplyTo: string | null = null;
+  let parentAuthor: string | null = null;
 
   if (!content) return c.json(errRequired("Content"), 400);
   // Enforce the same content cap as the canonical post route so this MCP path
@@ -62,9 +94,10 @@ export async function handleCreatePost(
   // private-community), bumping that restricted parent's reply_count and exposing
   // its existence via the stored in_reply_to (a privacy oracle), or reply to a
   // parent whose author blocked the actor (block bypass + notification).
-  if (inReplyTo) {
+  if (requestedInReplyTo) {
     const parent = await db
       .select({
+        apId: objects.apId,
         attributedTo: objects.attributedTo,
         visibility: objects.visibility,
         toJson: objects.toJson,
@@ -75,7 +108,7 @@ export async function handleCreatePost(
         endTime: objects.endTime,
       })
       .from(objects)
-      .where(eq(objects.apId, inReplyTo))
+      .where(toolPostWhereByIdOrApId(c.env.APP_URL, requestedInReplyTo))
       .get();
     if (
       !parent ||
@@ -87,54 +120,58 @@ export async function handleCreatePost(
         404,
       );
     }
+    // Persist the resolved canonical/full AP identifier, never the compact
+    // caller input, so reply traversal and counter recomputation share one key.
+    inReplyTo = parent.apId;
+    parentAuthor = parent.attributedTo;
   }
 
   const postId = crypto.randomUUID();
   const now = new Date().toISOString();
-  const apId = `${c.env.APP_URL}/ap/notes/${postId}`;
+  const apId = objectApId(c.env.APP_URL.replace(/\/+$/u, ""), postId);
 
-  // Co-commit the Note + author postCount bump (+ parent replyCount recompute for
-  // a reply) atomically (no drift on a mid-write failure). Direct posts do NOT
-  // count toward postCount (mirror the canonical create/delete + DM paths).
-  const stmts: unknown[] = [
-    db.insert(objects).values({
-      apId,
-      type: "Note",
-      attributedTo: actor.ap_id,
-      content,
-      summary: null,
-      attachmentsJson: "[]",
-      inReplyTo,
-      visibility,
-      likeCount: 0,
-      replyCount: 0,
-      announceCount: 0,
-      shareCount: 0,
-      published: now,
-      isLocal: 1,
-    }),
-  ];
-  if (visibility !== "direct") {
-    stmts.push(
-      db
-        .update(actors)
-        .set({ postCount: sql`${actors.postCount} + 1` })
-        .where(eq(actors.apId, actor.ap_id)),
-    );
-  }
-  if (inReplyTo) {
-    stmts.push(
-      db
-        .update(objects)
-        .set({
-          replyCount: sql`(SELECT COUNT(*) FROM ${objects} WHERE ${objects.inReplyTo} = ${inReplyTo})`,
-        })
-        .where(eq(objects.apId, inReplyTo)),
-    );
-  }
-  await (db as unknown as Batchable).batch(stmts);
+  const preparedFederation = await prepareCreatedPostFederation({
+    db,
+    env: c.env,
+    actorApId: actor.ap_id,
+    objectApId: apId,
+    content,
+    summary: null,
+    inReplyTo,
+    parentAuthor,
+    visibility,
+    community: null,
+    published: now,
+  });
+  const localStatements = preparePostInsertStatements(db, {
+    apId,
+    actorApId: actor.ap_id,
+    content,
+    summary: null,
+    attachments: undefined,
+    inReplyTo,
+    visibility,
+    communityId: null,
+    to: preparedFederation.to,
+    cc: preparedFederation.cc,
+    audience: preparedFederation.audience,
+    tags: preparedFederation.tags,
+    parentAuthor,
+    baseUrl: c.env.APP_URL,
+    now,
+  });
+  await runBatch(db, [...localStatements, ...preparedFederation.statements]);
+  const { mentionFailures } = await preparedFederation.complete();
 
-  return c.json(ok({ post_id: postId, ap_id: apId }));
+  return c.json(
+    ok({
+      post_id: postId,
+      ap_id: apId,
+      ...(mentionFailures.length > 0
+        ? { mention_processing: { failed_count: mentionFailures.length } }
+        : {}),
+    }),
+  );
 }
 
 export async function handleDeletePost(
@@ -149,9 +186,21 @@ export async function handleDeletePost(
   if (!postId) return c.json(errRequired("Post ID"), 400);
 
   const post = await db
-    .select({ apId: objects.apId })
+    .select({
+      apId: objects.apId,
+      inReplyTo: objects.inReplyTo,
+      visibility: objects.visibility,
+      communityApId: objects.communityApId,
+      toJson: objects.toJson,
+      ccJson: objects.ccJson,
+    })
     .from(objects)
-    .where(and(eq(objects.apId, postId), eq(objects.attributedTo, actor.ap_id)))
+    .where(
+      and(
+        toolPostWhereByIdOrApId(c.env.APP_URL, postId),
+        eq(objects.attributedTo, actor.ap_id),
+      ),
+    )
     .get();
   if (!post) {
     return c.json(
@@ -163,25 +212,61 @@ export async function handleDeletePost(
     );
   }
 
+  const [cascade, preparedFederation] = await Promise.all([
+    prepareObjectDeleteCascade(db, post.apId, c.env.MEDIA),
+    prepareDeletedPostFederation({
+      db,
+      env: c.env,
+      actorApId: actor.ap_id,
+      post,
+    }),
+  ]);
+
   // #COUNTER-SYM: gate the decrement on the object STILL existing (correlated
   // EXISTS) and run it BEFORE the delete, so two concurrent/retried deletes of
   // the same post can't double-decrement postCount — the second batch's EXISTS
   // is false (the first already deleted the row) → its -1 matches 0 rows. gt(>0)
   // guards underflow. Mirrors the canonical web delete path (posts/routes.ts).
-  const objectExists = sql`EXISTS (SELECT 1 FROM ${objects} WHERE ${objects.apId} = ${postId})`;
-  await (db as unknown as Batchable).batch([
-    db
-      .update(actors)
-      .set({ postCount: sql`${actors.postCount} - 1` })
-      .where(
-        and(
-          eq(actors.apId, actor.ap_id),
-          gt(actors.postCount, 0),
-          objectExists,
-        ),
-      ),
-    db.delete(objects).where(eq(objects.apId, postId)),
-  ]);
+  const objectExists = sql`EXISTS (SELECT 1 FROM ${objects} WHERE ${objects.apId} = ${post.apId})`;
+  const ops: D1Statement[] = [...cascade.statements];
+  // Direct messages never increment postCount, so their deletion must not
+  // decrement it. This keeps the tool path symmetric with canonical post/DM
+  // creation and deletion.
+  if (post.visibility !== "direct") {
+    ops.push(
+      db
+        .update(actors)
+        .set({ postCount: sql`${actors.postCount} - 1` })
+        .where(
+          and(
+            eq(actors.apId, actor.ap_id),
+            gt(actors.postCount, 0),
+            objectExists,
+          ),
+        ) as D1Statement,
+    );
+  }
+  ops.push(...preparedFederation.statements);
+  ops.push(
+    db.delete(objects).where(eq(objects.apId, post.apId)) as D1Statement,
+  );
+  if (post.inReplyTo) {
+    const parentId = post.inReplyTo;
+    ops.push(
+      db
+        .update(objects)
+        .set({
+          replyCount: sql`(SELECT COUNT(*) FROM ${objects} WHERE ${objects.inReplyTo} = ${parentId})`,
+        })
+        .where(eq(objects.apId, parentId)) as D1Statement,
+    );
+  }
+  await runBatch(db, ops as [D1Statement, ...D1Statement[]]);
+
+  // The irreversible external delete is last: failure leaks a blob instead of
+  // leaving a live post whose media has already been destroyed.
+  await purgeMediaBlobs(c.env.MEDIA, cascade.mediaKeys);
+  await preparedFederation.complete();
 
   return c.json(ok({ deleted: true }));
 }
@@ -216,54 +301,34 @@ export async function handleLikePost(
       endTime: objects.endTime,
     })
     .from(objects)
-    .where(eq(objects.apId, postId))
+    .where(toolPostWhereByIdOrApId(c.env.APP_URL, postId))
     .get();
   // Block-gate too (the read-gate passes for any public post, so it alone does
   // not stop a blocked actor): an actor the author blocked must not bump the
   // author's like_count, mirroring the canonical like route (interactions.ts).
+  if (!post) {
+    return c.json(errNotFound("Post"), 404);
+  }
+  // Creating an interaction requires current read/moderation entitlement.
+  // Removing a retained interaction stays available by id after access is
+  // revoked, matching the canonical web unlike cleanup path.
   if (
-    !post ||
-    !(await canViewerReadObjectFull(db, post, actor.ap_id)) ||
-    (await actorIsBlockedBy(db, post.attributedTo, actor.ap_id))
+    likeActive &&
+    (!(await canViewerReadObjectFull(db, post, actor.ap_id)) ||
+      (await actorIsBlockedBy(db, post.attributedTo, actor.ap_id)))
   ) {
     return c.json(errNotFound("Post"), 404);
   }
 
-  // Co-commit the like-edge toggle AND the likeCount recompute in ONE atomic
-  // batch (the canonical route does the same): a mid-request failure between the
-  // toggle and the count UPDATE would otherwise leave likeCount diverged from the
-  // likes table. The recompute is a COUNT(*) subquery so it is idempotent.
-  const toggleStmt = likeActive
-    ? db
-        .insert(likes)
-        .values({ actorApId: actor.ap_id, objectApId: post.apId })
-        .onConflictDoNothing()
-    : db
-        .delete(likes)
-        .where(
-          and(
-            eq(likes.actorApId, actor.ap_id),
-            eq(likes.objectApId, post.apId),
-          ),
-        );
-  await (db as unknown as Batchable).batch([
-    toggleStmt,
-    db
-      .update(objects)
-      .set({
-        likeCount: sql`(SELECT COUNT(*) FROM ${likes} WHERE ${likes.objectApId} = ${post.apId})`,
-      })
-      .where(eq(objects.apId, post.apId)),
-  ]);
+  const result = await setPostLike({
+    db,
+    env: c.env,
+    actorApId: actor.ap_id,
+    post,
+    active: likeActive,
+  });
 
-  const likeCountResult = await db
-    .select({ count: count() })
-    .from(likes)
-    .where(eq(likes.objectApId, post.apId))
-    .get();
-  const likeCount = likeCountResult?.count ?? 0;
-
-  return c.json(ok({ liked: likeActive, like_count: likeCount }));
+  return c.json(ok({ liked: result.active, like_count: result.likeCount }));
 }
 
 export async function handleBookmarkPost(
@@ -280,12 +345,30 @@ export async function handleBookmarkPost(
   if (!postId) return c.json(errRequired("Post ID"), 400);
 
   const post = await db
-    .select({ apId: objects.apId })
+    .select({
+      apId: objects.apId,
+      visibility: objects.visibility,
+      attributedTo: objects.attributedTo,
+      toJson: objects.toJson,
+      ccJson: objects.ccJson,
+      audienceJson: objects.audienceJson,
+      communityApId: objects.communityApId,
+      type: objects.type,
+      endTime: objects.endTime,
+    })
     .from(objects)
-    .where(eq(objects.apId, postId))
+    .where(toolPostWhereByIdOrApId(c.env.APP_URL, postId))
     .get();
   if (!post) return c.json(errNotFound("Post"), 404);
 
+  if (
+    bookmark &&
+    (!(await canViewerReadObjectFull(db, post, actor.ap_id)) ||
+      (await actorIsBlockedBy(db, post.attributedTo, actor.ap_id)))
+  ) {
+    return c.json(errNotFound("Post"), 404);
+  }
+
   await togglePostRelation(db, bookmarks, actor.ap_id, post.apId, bookmark);
 
   return c.json(ok({ bookmarked: bookmark }));

package/src/backend/routes/takos-tools/search.ts

@@ -10,7 +10,8 @@ import { sql } from "drizzle-orm";
 import { actors, objects } from "../../../db/index.ts";
 
 import { NO_AUDIENCE_PREDICATE } from "../../lib/community-visibility.ts";
-import { excludeBlockedMutedAuthors } from "../../lib/feed-exclude.ts";
+import { excludeModeratedActors } from "../../lib/feed-exclude.ts";
+import { operatorActorNotBlockedSql } from "../../lib/blocklist.ts";
 import { extractHashtags } from "../posts/transformers.ts";
 import { postContentSearchPredicate } from "../search.ts";
 import {
@@ -79,6 +80,7 @@ async function searchUsers(c: ToolContext, input: Input) {
         // otherwise a scrubbed `deleted-<id>` tombstone can surface here.
         isNull(actors.deletedAt),
         eq(actors.isPrivate, 0),
+        operatorActorNotBlockedSql(sql`${actors.apId}`),
         or(
           sql`instr(lower(${actors.preferredUsername}), lower(${query})) > 0`,
           sql`instr(lower(${actors.name}), lower(${query})) > 0`,
@@ -124,8 +126,8 @@ async function searchPosts(
         NO_AUDIENCE_PREDICATE,
         isNull(objects.deletedAt),
         // Honor the caller's block/mute filter, matching the web search +
-        // feed surfaces (undefined for an anonymous caller → and() drops it).
-        excludeBlockedMutedAuthors(db, actor?.ap_id ?? ""),
+        // feed surfaces, plus the global operator defederation boundary.
+        excludeModeratedActors(actor?.ap_id ?? ""),
       ),
     )
     .orderBy(desc(objects.published), desc(objects.apId))
@@ -158,6 +160,7 @@ async function getTrending(c: ToolContext, input: Input) {
         eq(objects.visibility, "public"),
         NO_AUDIENCE_PREDICATE,
         isNull(objects.deletedAt),
+        operatorActorNotBlockedSql(sql`${objects.attributedTo}`),
         sql`${objects.published} > ${sinceDate}`,
       ),
     )
@@ -206,7 +209,13 @@ async function getUserProfile(
       isPrivate: actors.isPrivate,
     })
     .from(actors)
-    .where(eq(actors.preferredUsername, username))
+    .where(
+      and(
+        eq(actors.preferredUsername, username),
+        isNull(actors.deletedAt),
+        operatorActorNotBlockedSql(sql`${actors.apId}`),
+      ),
+    )
     .get();
 
   if (!actorRecord) return c.json(errNotFound("User"), 404);

package/src/backend/routes/takos-tools/timeline.ts

@@ -5,9 +5,11 @@
  */
 
 import { and, desc, eq, inArray, isNull } from "drizzle-orm";
-import { actors, inbox, objects } from "../../../db/index.ts";
+import { activities, actors, inbox, objects } from "../../../db/index.ts";
 import { NO_AUDIENCE_PREDICATE } from "../../lib/community-visibility.ts";
 import { encodeFeedCursor, feedCursorWhere } from "../../lib/feed-cursor.ts";
+import { excludeModeratedActors } from "../../lib/feed-exclude.ts";
+import { notificationEligibilityWhere } from "../../lib/notification-eligibility.ts";
 import {
   ACTOR_SUMMARY_COLUMNS,
   errAuth,
@@ -20,7 +22,7 @@ import type { Input, ToolContext } from "./types.ts";
 export async function handleGetTimeline(
   c: ToolContext,
   input: Input,
-  _actor: { ap_id: string } | null,
+  actor: { ap_id: string } | null,
 ) {
   const db = c.get("db");
   const limit = toolLimit(input.limit, 20, 50);
@@ -30,6 +32,7 @@ export async function handleGetTimeline(
     eq(objects.visibility, "public"),
     NO_AUDIENCE_PREDICATE,
     isNull(objects.deletedAt),
+    excludeModeratedActors(actor?.ap_id ?? ""),
   ];
   // Composite (published, apId) cursor so agent pagination doesn't skip posts
   // sharing a published millisecond (see lib/feed-cursor.ts).
@@ -95,35 +98,40 @@ export async function handleGetNotifications(
   const limit = toolLimit(input.limit, 20, 50);
   const unreadOnly = Boolean(input.unread_only);
 
-  // Use query API with relations for inbox + activity join
-  const inboxEntries = await db.query.inbox.findMany({
-    where: and(
-      eq(inbox.actorApId, actor.ap_id),
-      ...(unreadOnly ? [eq(inbox.read, 0)] : []),
-    ),
-    with: {
-      activity: true,
-    },
-    orderBy: desc(inbox.createdAt),
-    limit,
-  });
-
-  // Filter: activity must not be from self and must be one of the expected types
-  const allowedTypes = new Set(["Follow", "Like", "Announce", "Create"]);
-  const filtered = inboxEntries.filter(
-    (entry) =>
-      entry.activity &&
-      entry.activity.actorApId !== actor.ap_id &&
-      allowedTypes.has(entry.activity.type),
-  );
+  // Apply the same eligibility owner as the web list/badge/realtime/push paths
+  // in SQL before the limit. A post-query filter both drifted from moderation
+  // policy and let blocked rows consume the agent's page budget.
+  const inboxEntries = await db
+    .select({
+      activityApId: inbox.activityApId,
+      activityType: activities.type,
+      activityActorApId: activities.actorApId,
+      activityObjectApId: activities.objectApId,
+      read: inbox.read,
+      createdAt: inbox.createdAt,
+    })
+    .from(inbox)
+    .innerJoin(activities, eq(inbox.activityApId, activities.apId))
+    .leftJoin(objects, eq(activities.objectApId, objects.apId))
+    .where(
+      and(
+        eq(inbox.actorApId, actor.ap_id),
+        ...(unreadOnly ? [eq(inbox.read, 0)] : []),
+        ...notificationEligibilityWhere(db, actor.ap_id, {
+          direct: "exclude",
+        }),
+      ),
+    )
+    .orderBy(desc(inbox.createdAt))
+    .limit(limit);
 
   return c.json(
     ok({
-      notifications: filtered.map((entry) => ({
+      notifications: inboxEntries.map((entry) => ({
         id: entry.activityApId,
-        type: entry.activity.type.toLowerCase(),
-        from_actor: entry.activity.actorApId,
-        object: entry.activity.objectApId,
+        type: entry.activityType.toLowerCase(),
+        from_actor: entry.activityActorApId,
+        object: entry.activityObjectApId,
         read: !!entry.read,
         created_at: entry.createdAt,
       })),

package/src/backend/routes/takos-tools-response.ts

@@ -5,7 +5,7 @@
  * input validation, and common data operations.
  */
 
-import { and, eq, inArray } from "drizzle-orm";
+import { and, eq, inArray, sql } from "drizzle-orm";
 import type { Database } from "../../db/index.ts";
 import { actors, bookmarks, follows, likes } from "../../db/index.ts";
 import {
@@ -13,6 +13,7 @@ import {
   parseLimit,
   safeJsonParse,
 } from "../federation-helpers.ts";
+import { operatorActorNotBlockedSql } from "../lib/blocklist.ts";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -77,7 +78,7 @@ export function ok(data: unknown): ToolResponse {
 export function formatActorSummary(a: ActorSummary): Record<string, unknown> {
   return {
     ap_id: a.apId,
-    username: formatUsername(a.apId),
+    username: formatUsername(a.apId, a.preferredUsername),
     preferred_username: a.preferredUsername,
     name: a.name,
     icon_url: a.iconUrl,
@@ -162,6 +163,9 @@ export async function fetchFollowList(
           targetApId,
         ),
         eq(follows.status, "accepted"),
+        operatorActorNotBlockedSql(
+          sql`${isFollowers ? follows.followerApId : follows.followingApId}`,
+        ),
       ),
     )
     .limit(limit);

package/src/backend/routes/timeline.ts

@@ -24,7 +24,7 @@ import {
   safeJsonParse,
 } from "../federation-helpers.ts";
 import { CacheTags, CacheTTL, withCache } from "../middleware/cache.ts";
-import { excludeBlockedMutedAuthors } from "../lib/feed-exclude.ts";
+import { excludeModeratedActors } from "../lib/feed-exclude.ts";
 import { chunkForInClause } from "../lib/chunk.ts";
 
 // Match every other feed's page cap. Clamping to 90 (not 100) leaves headroom
@@ -302,7 +302,7 @@ function formatPost(
     type: p.type,
     author: {
       ap_id: p.attributedTo,
-      username: formatUsername(p.attributedTo),
+      username: formatUsername(p.attributedTo, author.preferredUsername),
       preferred_username: author.preferredUsername,
       name: author.name,
       icon_url: author.iconUrl,
@@ -475,7 +475,7 @@ async function handleCommunityTimeline(
     return c.json({ error: "Not a community member" }, 403);
   }
 
-  const excludeAuthors = excludeBlockedMutedAuthors(db, viewerApId);
+  const excludeAuthors = excludeModeratedActors(viewerApId);
 
   // This is the home "narrow to a community" filter: it shows the slice of the
   // viewer's reach that belongs to this community — (1) posts deliberately
@@ -565,7 +565,7 @@ timeline.get(
     const before = c.req.query("before");
     const viewerApId = actor?.ap_id || "";
 
-    const excludeAuthors = excludeBlockedMutedAuthors(db, viewerApId);
+    const excludeAuthors = excludeModeratedActors(viewerApId);
 
     const base = [
       eq(objects.type, "Note"),
@@ -702,7 +702,7 @@ timeline.get("/following", async (c) => {
   const before = c.req.query("before");
   const viewerApId = actor.ap_id;
 
-  const excludeAuthors = excludeBlockedMutedAuthors(db, viewerApId);
+  const excludeAuthors = excludeModeratedActors(viewerApId);
 
   // Own posts: all visibilities except direct
   // Followed users' posts: public, unlisted, or followers visibility