@takosjp/yurucommu-core 3.0.0

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

@@ -0,0 +1,178 @@
+/**
+ * Takos Tools - Response & input helpers
+ *
+ * Shared helpers extracted from takos-tools.ts for response formatting,
+ * input validation, and common data operations.
+ */
+
+import { and, eq, inArray } from "drizzle-orm";
+import type { Database } from "../../db/index.ts";
+import { actors, bookmarks, follows, likes } from "../../db/index.ts";
+import {
+  formatUsername,
+  parseLimit,
+  safeJsonParse,
+} from "../federation-helpers.ts";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ToolResponse {
+  success: boolean;
+  data?: unknown;
+  error?: string;
+}
+
+export interface ActorSummary {
+  apId: string;
+  preferredUsername: string;
+  name: string | null;
+  iconUrl: string | null;
+}
+
+export type Input = Record<string, unknown>;
+
+// ---------------------------------------------------------------------------
+// Input helpers
+// ---------------------------------------------------------------------------
+
+export function toolLimit(
+  value: unknown,
+  fallback: number,
+  max: number,
+): number {
+  const normalized = value == null ? undefined : String(value);
+  return parseLimit(normalized, fallback, max);
+}
+
+export function requireString(input: Input, key: string): string {
+  return String(input[key] || "").trim();
+}
+
+// ---------------------------------------------------------------------------
+// Response helpers
+// ---------------------------------------------------------------------------
+
+export function errAuth(): ToolResponse {
+  return { success: false, error: "Authentication required" };
+}
+
+export function errRequired(field: string): ToolResponse {
+  return { success: false, error: `${field} is required` };
+}
+
+export function errNotFound(entity: string): ToolResponse {
+  return { success: false, error: `${entity} not found` };
+}
+
+export function ok(data: unknown): ToolResponse {
+  return { success: true, data };
+}
+
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+
+export function formatActorSummary(a: ActorSummary): Record<string, unknown> {
+  return {
+    ap_id: a.apId,
+    username: formatUsername(a.apId),
+    preferred_username: a.preferredUsername,
+    name: a.name,
+    icon_url: a.iconUrl,
+  };
+}
+
+export const ACTOR_SUMMARY_COLUMNS = {
+  apId: actors.apId,
+  preferredUsername: actors.preferredUsername,
+  name: actors.name,
+  iconUrl: actors.iconUrl,
+} as const;
+
+// ---------------------------------------------------------------------------
+// Data helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Determine the conversation partner from a DM object.
+ * Returns null when the current actor is not a verified participant (defense in depth).
+ */
+export function resolveDmPartner(
+  dm: { attributedTo: string; toJson: string | null },
+  actorApId: string,
+): string | null {
+  const toRecipients = safeJsonParse<string[]>(dm.toJson, []);
+
+  if (dm.attributedTo === actorApId) {
+    return toRecipients[0] || null;
+  }
+
+  // Defense in depth: verify we're actually a recipient.
+  if (!toRecipients.includes(actorApId)) return null;
+  return dm.attributedTo;
+}
+
+/**
+ * Toggle a many-to-one relation (like, bookmark) on a post.
+ */
+export async function togglePostRelation(
+  db: Database,
+  table: typeof likes | typeof bookmarks,
+  actorApIdVal: string,
+  objectApIdVal: string,
+  active: boolean,
+): Promise<void> {
+  if (active) {
+    // Upsert: insert if not exists, ignore conflict
+    await db
+      .insert(table)
+      .values({ actorApId: actorApIdVal, objectApId: objectApIdVal })
+      .onConflictDoNothing();
+  } else {
+    await db
+      .delete(table)
+      .where(
+        and(
+          eq(table.actorApId, actorApIdVal),
+          eq(table.objectApId, objectApIdVal),
+        ),
+      );
+  }
+}
+
+/**
+ * Fetch a follow-direction list for a given actor (followers or following).
+ */
+export async function fetchFollowList(
+  db: Database,
+  targetApId: string,
+  direction: "followers" | "following",
+  limit: number,
+): Promise<ActorSummary[]> {
+  const isFollowers = direction === "followers";
+  const followRows = await db
+    .select()
+    .from(follows)
+    .where(
+      and(
+        eq(
+          isFollowers ? follows.followingApId : follows.followerApId,
+          targetApId,
+        ),
+        eq(follows.status, "accepted"),
+      ),
+    )
+    .limit(limit);
+
+  const relatedIds = followRows.map((f) =>
+    isFollowers ? f.followerApId : f.followingApId,
+  );
+  if (relatedIds.length === 0) return [];
+
+  return db
+    .select(ACTOR_SUMMARY_COLUMNS)
+    .from(actors)
+    .where(inArray(actors.apId, relatedIds));
+}

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

@@ -0,0 +1,153 @@
+/**
+ * Takos Tools Endpoint
+ *
+ * Provides tool endpoints for AI agent integration.
+ * POST /.takos/tools/:name - Execute a tool
+ *
+ * Each tool category is implemented in a dedicated module under ./takos-tools/.
+ */
+
+import { Hono } from "hono";
+import type { Env, Variables } from "../types.ts";
+import type { ToolResponse } from "./takos-tools-response.ts";
+import { logger } from "../lib/logger.ts";
+
+// Handler modules
+import {
+  handleGetTrending,
+  handleGetUserProfile,
+  handleSearchPosts,
+  handleSearchUsers,
+} from "./takos-tools/search.ts";
+import {
+  handleBookmarkPost,
+  handleCreatePost,
+  handleDeletePost,
+  handleLikePost,
+} from "./takos-tools/posts.ts";
+import {
+  handleFollowUser,
+  handleGetFollowList,
+  handleUnfollowUser,
+} from "./takos-tools/follows.ts";
+import {
+  handleGetDmMessages,
+  handleGetDmThreads,
+  handleSendDm,
+} from "./takos-tools/dm.ts";
+import {
+  handleGetNotifications,
+  handleGetTimeline,
+} from "./takos-tools/timeline.ts";
+
+type HonoEnv = { Bindings: Env; Variables: Variables };
+
+const takosTools = new Hono<HonoEnv>();
+const log = logger.child({ component: "takos.tools" });
+
+// Feature flag gate (fail-close).
+takosTools.use("*", async (c, next) => {
+  if (c.env.ENABLE_TAKOS_TOOLS !== "true") {
+    return c.notFound();
+  }
+  await next();
+});
+
+interface ToolRequest {
+  input: Record<string, unknown>;
+  context?: {
+    user_id?: string;
+    session_id?: string;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Route
+// ---------------------------------------------------------------------------
+
+takosTools.post("/:name", async (c) => {
+  const toolName = c.req.param("name");
+  const actor = c.get("actor");
+
+  let body: ToolRequest;
+  try {
+    body = await c.req.json();
+  } catch {
+    return c.json(
+      { success: false, error: "Invalid JSON body" } as ToolResponse,
+      400,
+    );
+  }
+
+  const input = body.input || {};
+
+  try {
+    switch (toolName) {
+      // ------ Search tools ------
+      case "yurucommu_search_users":
+        return await handleSearchUsers(c, input, actor);
+      case "yurucommu_search_posts":
+        return await handleSearchPosts(c, input, actor);
+      case "yurucommu_get_trending":
+        return await handleGetTrending(c, input, actor);
+      case "yurucommu_get_user_profile":
+        return await handleGetUserProfile(c, input, actor);
+
+      // ------ Post tools ------
+      case "yurucommu_create_post":
+        return await handleCreatePost(c, input, actor);
+      case "yurucommu_delete_post":
+        return await handleDeletePost(c, input, actor);
+      case "yurucommu_like_post":
+        return await handleLikePost(c, input, actor);
+      case "yurucommu_bookmark_post":
+        return await handleBookmarkPost(c, input, actor);
+
+      // ------ Follow tools ------
+      case "yurucommu_follow_user":
+        return await handleFollowUser(c, input, actor);
+      case "yurucommu_unfollow_user":
+        return await handleUnfollowUser(c, input, actor);
+      case "yurucommu_get_followers":
+        return await handleGetFollowList(c, input, actor, "followers");
+      case "yurucommu_get_following":
+        return await handleGetFollowList(c, input, actor, "following");
+
+      // ------ DM tools ------
+      case "yurucommu_send_dm":
+        return await handleSendDm(c, input, actor);
+      case "yurucommu_get_dm_threads":
+        return await handleGetDmThreads(c, input, actor);
+      case "yurucommu_get_dm_messages":
+        return await handleGetDmMessages(c, input, actor);
+
+      // ------ Timeline tools ------
+      case "yurucommu_get_timeline":
+        return await handleGetTimeline(c, input, actor);
+      case "yurucommu_get_notifications":
+        return await handleGetNotifications(c, input, actor);
+
+      default:
+        return c.json(
+          { success: false, error: `Unknown tool: ${toolName}` },
+          404,
+        );
+    }
+  } catch (error) {
+    log.error("Takos tool failed", {
+      event: "takos.tools.failed",
+      toolName,
+      error,
+    });
+    // Return a GENERIC message — never echo the raw Error.message to the client.
+    // A D1/Drizzle failure can carry SQL fragments / column names / constraint
+    // text; the detail is logged server-side above. Mirrors media.ts and the
+    // global onError handler (which both return fixed strings).
+    return c.json(
+      { success: false, error: "Internal error" } as ToolResponse,
+      500,
+    );
+  }
+});
+
+export default takosTools;