@takosjp/yurucommu-core 3.0.0

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

@@ -0,0 +1,292 @@
+/**
+ * Takos Tools - Post handlers
+ *
+ * Handles: yurucommu_create_post, yurucommu_delete_post,
+ *          yurucommu_like_post, yurucommu_bookmark_post
+ */
+
+import { and, count, eq, gt } from "drizzle-orm";
+import { sql } from "drizzle-orm";
+import { actors, bookmarks, likes, objects } from "../../../db/index.ts";
+import {
+  actorIsBlockedBy,
+  canViewerReadObjectFull,
+} from "../../lib/post-visibility.ts";
+import {
+  MAX_POST_CONTENT_LENGTH,
+  normalizeVisibility,
+} from "../posts/transformers.ts";
+import {
+  errAuth,
+  errNotFound,
+  errRequired,
+  ok,
+  requireString,
+  togglePostRelation,
+  toolLimit,
+  type ToolResponse,
+} 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> };
+
+export async function handleCreatePost(
+  c: ToolContext,
+  input: Input,
+  actor: { ap_id: string } | null,
+) {
+  if (!actor) return c.json(errAuth(), 401);
+
+  const db = c.get("db");
+  const content = requireString(input, "content");
+  // 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;
+
+  if (!content) return c.json(errRequired("Content"), 400);
+  // Enforce the same content cap as the canonical post route so this MCP path
+  // can't store an oversized Note that then federates + renders everywhere.
+  if (content.length > MAX_POST_CONTENT_LENGTH) {
+    return c.json(
+      { success: false, error: "Content too long" } as ToolResponse,
+      400,
+    );
+  }
+
+  // Gate a reply on the SAME read-gate + block-check the canonical web reply
+  // route enforces (routes/posts/routes.ts) — not a mere existence check. Without
+  // it the agent could reply to a parent it cannot read (followers-only / direct /
+  // 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) {
+    const parent = await db
+      .select({
+        attributedTo: objects.attributedTo,
+        visibility: objects.visibility,
+        toJson: objects.toJson,
+        ccJson: objects.ccJson,
+        audienceJson: objects.audienceJson,
+        communityApId: objects.communityApId,
+        type: objects.type,
+        endTime: objects.endTime,
+      })
+      .from(objects)
+      .where(eq(objects.apId, inReplyTo))
+      .get();
+    if (
+      !parent ||
+      !(await canViewerReadObjectFull(db, parent, actor.ap_id)) ||
+      (await actorIsBlockedBy(db, parent.attributedTo, actor.ap_id))
+    ) {
+      return c.json(
+        { success: false, error: "Reply target not found" } as ToolResponse,
+        404,
+      );
+    }
+  }
+
+  const postId = crypto.randomUUID();
+  const now = new Date().toISOString();
+  const apId = `${c.env.APP_URL}/ap/notes/${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);
+
+  return c.json(ok({ post_id: postId, ap_id: apId }));
+}
+
+export async function handleDeletePost(
+  c: ToolContext,
+  input: Input,
+  actor: { ap_id: string } | null,
+) {
+  if (!actor) return c.json(errAuth(), 401);
+
+  const db = c.get("db");
+  const postId = requireString(input, "post_id");
+  if (!postId) return c.json(errRequired("Post ID"), 400);
+
+  const post = await db
+    .select({ apId: objects.apId })
+    .from(objects)
+    .where(and(eq(objects.apId, postId), eq(objects.attributedTo, actor.ap_id)))
+    .get();
+  if (!post) {
+    return c.json(
+      {
+        success: false,
+        error: "Post not found or not authorized",
+      } as ToolResponse,
+      404,
+    );
+  }
+
+  // #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)),
+  ]);
+
+  return c.json(ok({ deleted: true }));
+}
+
+export async function handleLikePost(
+  c: ToolContext,
+  input: Input,
+  actor: { ap_id: string } | null,
+) {
+  if (!actor) return c.json(errAuth(), 401);
+
+  const db = c.get("db");
+  const postId = requireString(input, "post_id");
+  const likeActive = Boolean(input.like);
+
+  if (!postId) return c.json(errRequired("Post ID"), 400);
+
+  // Read-gate the like exactly as the web route does (interactions.ts): an
+  // unentitled actor who merely learns a followers-only / direct / private-
+  // community post's apId must not be able to like it (which would bump
+  // like_count and leak the post's existence). 404 when not readable.
+  const post = await db
+    .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))
+    .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 ||
+    !(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 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 }));
+}
+
+export async function handleBookmarkPost(
+  c: ToolContext,
+  input: Input,
+  actor: { ap_id: string } | null,
+) {
+  if (!actor) return c.json(errAuth(), 401);
+
+  const db = c.get("db");
+  const postId = requireString(input, "post_id");
+  const bookmark = Boolean(input.bookmark);
+
+  if (!postId) return c.json(errRequired("Post ID"), 400);
+
+  const post = await db
+    .select({ apId: objects.apId })
+    .from(objects)
+    .where(eq(objects.apId, postId))
+    .get();
+  if (!post) 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

@@ -0,0 +1,228 @@
+/**
+ * Takos Tools - Search handlers
+ *
+ * Handles: yurucommu_search_users, yurucommu_search_posts,
+ *          yurucommu_get_trending, yurucommu_get_user_profile
+ */
+
+import { and, desc, eq, isNull, or } from "drizzle-orm";
+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 { extractHashtags } from "../posts/transformers.ts";
+import { postContentSearchPredicate } from "../search.ts";
+import {
+  ACTOR_SUMMARY_COLUMNS,
+  errNotFound,
+  errRequired,
+  formatActorSummary,
+  ok,
+  requireString,
+  toolLimit,
+} from "../takos-tools-response.ts";
+import type { Input, ToolContext } from "./types.ts";
+
+export function handleSearchUsers(
+  c: ToolContext,
+  input: Input,
+  _actor: { ap_id: string } | null,
+) {
+  return searchUsers(c, input);
+}
+
+export function handleSearchPosts(
+  c: ToolContext,
+  input: Input,
+  actor: { ap_id: string } | null,
+) {
+  return searchPosts(c, input, actor);
+}
+
+export function handleGetTrending(
+  c: ToolContext,
+  input: Input,
+  _actor: { ap_id: string } | null,
+) {
+  return getTrending(c, input);
+}
+
+export function handleGetUserProfile(
+  c: ToolContext,
+  input: Input,
+  actor: { ap_id: string } | null,
+) {
+  return getUserProfile(c, input, actor);
+}
+
+// ---------------------------------------------------------------------------
+
+async function searchUsers(c: ToolContext, input: Input) {
+  const db = c.get("db");
+  const query = requireString(input, "query");
+  const limit = toolLimit(input.limit, 20, 50);
+
+  if (!query) return c.json(ok({ actors: [] }));
+
+  const results = await db
+    .select({
+      ...ACTOR_SUMMARY_COLUMNS,
+      summary: actors.summary,
+      followerCount: actors.followerCount,
+    })
+    .from(actors)
+    .where(
+      and(
+        // Exclude soft-deleted tombstones (matches the web /search/actors
+        // notDeleted filter + the sibling searchPosts/getTrending handlers);
+        // otherwise a scrubbed `deleted-<id>` tombstone can surface here.
+        isNull(actors.deletedAt),
+        eq(actors.isPrivate, 0),
+        or(
+          sql`instr(lower(${actors.preferredUsername}), lower(${query})) > 0`,
+          sql`instr(lower(${actors.name}), lower(${query})) > 0`,
+        ),
+      ),
+    )
+    .orderBy(desc(actors.followerCount))
+    .limit(limit);
+
+  return c.json(
+    ok({
+      actors: results.map((a) => ({
+        ...formatActorSummary(a),
+        summary: a.summary,
+        follower_count: a.followerCount,
+      })),
+    }),
+  );
+}
+
+async function searchPosts(
+  c: ToolContext,
+  input: Input,
+  actor: { ap_id: string } | null,
+) {
+  const db = c.get("db");
+  const query = requireString(input, "query");
+  const limit = toolLimit(input.limit, 20, 50);
+
+  if (!query) return c.json(ok({ posts: [] }));
+
+  const posts = await db
+    .select()
+    .from(objects)
+    .where(
+      and(
+        // Match via the SAME predicate as the web GET /search/posts (FTS trigram
+        // for >=3 codepoints, instr() fallback for shorter) so the agent and web
+        // surfaces return identical results and the agent path uses the FTS index
+        // instead of a full-table substring scan.
+        postContentSearchPredicate(query),
+        eq(objects.visibility, "public"),
+        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 ?? ""),
+      ),
+    )
+    .orderBy(desc(objects.published), desc(objects.apId))
+    .limit(limit);
+
+  return c.json(
+    ok({
+      posts: posts.map((p) => ({
+        ap_id: p.apId,
+        content: p.content,
+        published: p.published,
+        like_count: p.likeCount,
+      })),
+    }),
+  );
+}
+
+async function getTrending(c: ToolContext, input: Input) {
+  const db = c.get("db");
+  const limit = toolLimit(input.limit, 10, 50);
+  const sinceDate = new Date(
+    Date.now() - 7 * 24 * 60 * 60 * 1000,
+  ).toISOString();
+
+  const posts = await db
+    .select({ content: objects.content })
+    .from(objects)
+    .where(
+      and(
+        eq(objects.visibility, "public"),
+        NO_AUDIENCE_PREDICATE,
+        isNull(objects.deletedAt),
+        sql`${objects.published} > ${sinceDate}`,
+      ),
+    )
+    .orderBy(desc(objects.published))
+    .limit(1000);
+
+  const hashtagCounts: Record<string, number> = {};
+
+  for (const post of posts) {
+    // Use the SHARED full-Unicode tokenizer (extractHashtags) so the agent
+    // trending list tokenizes hashtags identically to storage + web search/
+    // trending. The old inline ASCII+Hiragana+Katakana+BMP-CJK class silently
+    // dropped Korean/Cyrillic/Greek/accented-Latin/CJK-ext tags and mis-segmented
+    // #caf\u00E9 \u2192 #caf. (extractHashtags de-dupes within a post, so a tag spammed in
+    // one post counts once for that post \u2014 desirable for trending.)
+    for (const tag of extractHashtags(post.content || "")) {
+      const tagName = tag.toLowerCase();
+      hashtagCounts[tagName] = (hashtagCounts[tagName] || 0) + 1;
+    }
+  }
+
+  const trending = Object.entries(hashtagCounts)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, limit)
+    .map(([tag, count]) => ({ tag, count }));
+
+  return c.json(ok({ trending }));
+}
+
+async function getUserProfile(
+  c: ToolContext,
+  input: Input,
+  actor: { ap_id: string } | null,
+) {
+  const db = c.get("db");
+  const username = requireString(input, "username");
+  if (!username) return c.json(errRequired("Username"), 400);
+
+  const actorRecord = await db
+    .select({
+      ...ACTOR_SUMMARY_COLUMNS,
+      summary: actors.summary,
+      followerCount: actors.followerCount,
+      followingCount: actors.followingCount,
+      postCount: actors.postCount,
+      isPrivate: actors.isPrivate,
+    })
+    .from(actors)
+    .where(eq(actors.preferredUsername, username))
+    .get();
+
+  if (!actorRecord) return c.json(errNotFound("User"), 404);
+
+  // Fail-close for private accounts (allow self lookup only).
+  if (actorRecord.isPrivate && actor?.ap_id !== actorRecord.apId) {
+    return c.json(errNotFound("User"), 404);
+  }
+
+  return c.json(
+    ok({
+      ...formatActorSummary(actorRecord),
+      summary: actorRecord.summary,
+      follower_count: actorRecord.followerCount,
+      following_count: actorRecord.followingCount,
+      post_count: actorRecord.postCount,
+    }),
+  );
+}

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

@@ -0,0 +1,132 @@
+/**
+ * Takos Tools - Timeline & notification handlers
+ *
+ * Handles: yurucommu_get_timeline, yurucommu_get_notifications
+ */
+
+import { and, desc, eq, inArray, isNull } from "drizzle-orm";
+import { 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 {
+  ACTOR_SUMMARY_COLUMNS,
+  errAuth,
+  formatActorSummary,
+  ok,
+  toolLimit,
+} from "../takos-tools-response.ts";
+import type { Input, ToolContext } from "./types.ts";
+
+export async function handleGetTimeline(
+  c: ToolContext,
+  input: Input,
+  _actor: { ap_id: string } | null,
+) {
+  const db = c.get("db");
+  const limit = toolLimit(input.limit, 20, 50);
+  const before = input.before ? String(input.before) : null;
+
+  const whereConditions = [
+    eq(objects.visibility, "public"),
+    NO_AUDIENCE_PREDICATE,
+    isNull(objects.deletedAt),
+  ];
+  // Composite (published, apId) cursor so agent pagination doesn't skip posts
+  // sharing a published millisecond (see lib/feed-cursor.ts).
+  const toolCursor = feedCursorWhere(objects.published, objects.apId, before);
+  if (toolCursor) whereConditions.push(toolCursor);
+
+  // Fetch one extra row as a has-more probe so the final/full page does NOT
+  // advertise a next_cursor (the bare `.limit(limit)` returned a cursor on every
+  // non-empty page, forcing the agent into one extra empty fetch and never a
+  // clean end-of-feed). Mirrors the client feed/notifications limit+1 pattern.
+  const scanned = await db
+    .select()
+    .from(objects)
+    .where(and(...whereConditions))
+    .orderBy(desc(objects.published), desc(objects.apId))
+    .limit(limit + 1);
+  const hasMore = scanned.length > limit;
+  const posts = hasMore ? scanned.slice(0, limit) : scanned;
+
+  const authorIds = [...new Set(posts.map((p) => p.attributedTo))];
+  const authorRows =
+    authorIds.length > 0
+      ? await db
+          .select(ACTOR_SUMMARY_COLUMNS)
+          .from(actors)
+          .where(inArray(actors.apId, authorIds))
+      : [];
+
+  const authorMap = new Map(authorRows.map((a) => [a.apId, a]));
+
+  return c.json(
+    ok({
+      posts: posts.map((p) => {
+        const author = authorMap.get(p.attributedTo);
+        return {
+          ap_id: p.apId,
+          content: p.content,
+          published: p.published,
+          like_count: p.likeCount,
+          author: author ? formatActorSummary(author) : null,
+        };
+      }),
+      has_more: hasMore,
+      next_cursor:
+        hasMore && posts.length > 0
+          ? encodeFeedCursor(
+              posts[posts.length - 1].published,
+              posts[posts.length - 1].apId,
+            )
+          : null,
+    }),
+  );
+}
+
+export async function handleGetNotifications(
+  c: ToolContext,
+  input: Input,
+  actor: { ap_id: string } | null,
+) {
+  if (!actor) return c.json(errAuth(), 401);
+
+  const db = c.get("db");
+  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),
+  );
+
+  return c.json(
+    ok({
+      notifications: filtered.map((entry) => ({
+        id: entry.activityApId,
+        type: entry.activity.type.toLowerCase(),
+        from_actor: entry.activity.actorApId,
+        object: entry.activity.objectApId,
+        read: !!entry.read,
+        created_at: entry.createdAt,
+      })),
+    }),
+  );
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Shared types for takos-tools handler modules.
+ */
+
+import type { Context } from "hono";
+import type { Env, Variables } from "../../types.ts";
+
+export type HonoEnv = { Bindings: Env; Variables: Variables };
+export type ToolContext = Context<HonoEnv>;
+export type Input = Record<string, unknown>;