feat: implement task comment creation event handling and integrate with GitHub plugin

apps/api/src/activity/index.ts

···
+import { eq } from "drizzle-orm";
 import { Hono } from "hono";
 import { describeRoute, resolver, validator } from "hono-openapi";
 import * as v from "valibot";
-import { subscribeToEvent } from "../events";
+import db from "../database";
+import { taskTable } from "../database/schema";
+import { publishEvent, subscribeToEvent } from "../events";
 import { activitySchema } from "../schemas";
 import { workspaceAccess } from "../utils/workspace-access-middleware";
 import createActivity from "./controllers/create-activity";
···
       const { taskId, comment } = c.req.valid("json");
       const userId = c.get("userId");
       const newComment = await createComment(taskId, userId, comment);
+
+      const [task] = await db
+        .select({ projectId: taskTable.projectId })
+        .from(taskTable)
+        .where(eq(taskTable.id, taskId));
+
+      if (task) {
+        await publishEvent("task.comment_created", {
+          taskId,
+          userId,
+          comment,
+          projectId: task.projectId,
+        });
+      }
+
       return c.json(newComment);
     },
   )

apps/api/src/github-integration/controllers/create-github-integration.ts

···
     throw new HTTPException(404, { message: "Project not found" });
   }
 
+  const allGitHubIntegrations = await db.query.integrationTable.findMany({
+    where: eq(integrationTable.type, "github"),
+  });
+
+  for (const integration of allGitHubIntegrations) {
+    if (integration.projectId === projectId) {
+      continue;
+    }
+
+    try {
+      const config = JSON.parse(integration.config);
+      if (
+        config.repositoryOwner === repositoryOwner &&
+        config.repositoryName === repositoryName
+      ) {
+        throw new HTTPException(409, {
+          message: `Repository ${repositoryOwner}/${repositoryName} is already linked to another project`,
+        });
+      }
+    } catch (error) {
+      if (error instanceof HTTPException) {
+        throw error;
+      }
+    }
+  }
+
   let installationId: number | null = null;
   try {
     const { data: installation } =

apps/api/src/plugins/github/events/task-comment-created.ts

···
+import type { PluginContext, TaskCommentCreatedEvent } from "../../types";
+import type { GitHubConfig } from "../config";
+import { findExternalLinkByTaskAndType } from "../services/link-manager";
+import { getGithubApp, getInstallationIdForRepo } from "../utils/github-app";
+
+export async function handleTaskCommentCreated(
+  event: TaskCommentCreatedEvent,
+  context: PluginContext,
+): Promise<void> {
+  const githubApp = getGithubApp();
+  if (!githubApp) {
+    return;
+  }
+
+  const config = context.config as GitHubConfig;
+  const { repositoryOwner, repositoryName } = config;
+
+  const existingLink = await findExternalLinkByTaskAndType(
+    event.taskId,
+    context.integrationId,
+    "issue",
+  );
+
+  if (!existingLink) {
+    return;
+  }
+
+  try {
+    let installationId = config.installationId;
+    if (!installationId) {
+      installationId = await getInstallationIdForRepo(
+        repositoryOwner,
+        repositoryName,
+      );
+    }
+
+    const octokit = await githubApp.getInstallationOctokit(installationId);
+
+    const issueNumber = Number.parseInt(existingLink.externalId, 10);
+
+    await octokit.rest.issues.createComment({
+      owner: repositoryOwner,
+      repo: repositoryName,
+      issue_number: issueNumber,
+      body: event.comment,
+    });
+  } catch (error) {
+    console.error("Failed to create GitHub comment:", error);
+  }
+}

apps/api/src/plugins/github/index.ts

···
 import type { IntegrationPlugin } from "../types";
 import { validateGitHubConfig } from "./config";
+import { handleTaskCommentCreated } from "./events/task-comment-created";
 import { handleTaskCreated } from "./events/task-created";
 import { handleTaskDescriptionChanged } from "./events/task-description-changed";
 import { handleTaskPriorityChanged } from "./events/task-priority-changed";
···
   onTaskPriorityChanged: handleTaskPriorityChanged,
   onTaskTitleChanged: handleTaskTitleChanged,
   onTaskDescriptionChanged: handleTaskDescriptionChanged,
+  onTaskCommentCreated: handleTaskCommentCreated,
   validateConfig: validateGitHubConfig,
 };
 

apps/api/src/plugins/registry.ts

···
 import type {
   IntegrationPlugin,
   PluginContext,
+  TaskCommentCreatedEvent,
   TaskCreatedEvent,
   TaskDescriptionChangedEvent,
   TaskPriorityChangedEvent,
···
       userId: data.userId,
       oldDescription: data.oldDescription,
       newDescription: data.newDescription,
+    });
+  });
+
+  subscribeToEvent<{
+    taskId: string;
+    userId: string;
+    comment: string;
+    projectId: string;
+  }>("task.comment_created", async (data) => {
+    await broadcastTaskCommentCreated({
+      taskId: data.taskId,
+      projectId: data.projectId,
+      userId: data.userId,
+      comment: data.comment,
     });
   });
 
···
     }
   }
 }
+
+export async function broadcastTaskCommentCreated(
+  event: TaskCommentCreatedEvent,
+): Promise<void> {
+  const integrations = await getActiveIntegrations(event.projectId);
+
+  for (const integration of integrations) {
+    const plugin = getPlugin(integration.type);
+    if (!plugin?.onTaskCommentCreated) continue;
+
+    const context = createContext(integration);
+
+    try {
+      await plugin.onTaskCommentCreated(event, context);
+    } catch (error) {
+      console.error(
+        `Plugin ${plugin.type} error on task.comment_created:`,
+        error,
+      );
+    }
+  }
+}

apps/api/src/plugins/types.ts

···
   newDescription: string | null;
 };
 
+export type TaskCommentCreatedEvent = {
+  taskId: string;
+  projectId: string;
+  userId: string;
+  comment: string;
+};
+
 export type TaskEvent =
   | TaskCreatedEvent
   | TaskStatusChangedEvent
   | TaskPriorityChangedEvent
   | TaskTitleChangedEvent
-  | TaskDescriptionChangedEvent;
+  | TaskDescriptionChangedEvent
+  | TaskCommentCreatedEvent;
 
 export type ExternalMetadata = {
   type: "issue" | "pull_request" | "branch";
···
   onTaskPriorityChanged?: TaskEventHandler<TaskPriorityChangedEvent>;
   onTaskTitleChanged?: TaskEventHandler<TaskTitleChangedEvent>;
   onTaskDescriptionChanged?: TaskEventHandler<TaskDescriptionChangedEvent>;
+  onTaskCommentCreated?: TaskEventHandler<TaskCommentCreatedEvent>;
 
   handleWebhook?: WebhookHandler;
   getTaskMetadata?: MetadataProvider;