@yattalo/task-system 0.3.6 → 0.5.0

package/templates/uca/hooks.ts

@@ -0,0 +1,430 @@
+import { mutation, query } from "../_generated/server";
+import { v } from "convex/values";
+
+function makeId(prefix: string): string {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function safeString(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (value === null || value === undefined) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function matchesRules(rules: any, payload: any): boolean {
+  if (!rules) return true;
+
+  if (rules.equals && typeof rules.equals === "object") {
+    for (const [key, expected] of Object.entries(rules.equals)) {
+      if ((payload as any)?.[key] !== expected) return false;
+    }
+  }
+
+  if (rules.contains && typeof rules.contains === "object") {
+    for (const [key, expected] of Object.entries(rules.contains)) {
+      const source = safeString((payload as any)?.[key]).toLowerCase();
+      if (!source.includes(String(expected).toLowerCase())) return false;
+    }
+  }
+
+  if (Array.isArray(rules.taskStatusIn)) {
+    const status = (payload as any)?.status;
+    if (!rules.taskStatusIn.includes(status)) return false;
+  }
+
+  return true;
+}
+
+async function findTaskByTaskId(ctx: any, taskId: string): Promise<any | null> {
+  return await ctx.db
+    .query("tasks")
+    .withIndex("by_taskId", (q: any) => q.eq("taskId", taskId))
+    .first();
+}
+
+async function ensureJobForTask(ctx: any, task: any, lane: "main" | "cron" | "subagent"): Promise<string> {
+  const existingJob = await ctx.db
+    .query("agentOpsJobs")
+    .withIndex("by_taskId", (q: any) => q.eq("taskId", task.taskId))
+    .first();
+  if (existingJob) return existingJob.jobId;
+
+  const now = Date.now();
+  const jobId = makeId(`job-${task.taskId.toLowerCase()}`);
+  await ctx.db.insert("agentOpsJobs", {
+    jobId,
+    taskId: task.taskId,
+    name: `${task.taskId} - ${task.title}`,
+    description: task.description,
+    agent: task.agent,
+    lane,
+    scheduleType: "manual",
+    cronExpression: undefined,
+    intervalMinutes: undefined,
+    enabled: true,
+    status: "active",
+    triggerEvent: undefined,
+    triggerFilter: undefined,
+    prompt: `Webhook-triggered job for ${task.taskId}`,
+    metadata: { source: "hooks" },
+    lastRunAt: undefined,
+    nextRunAt: undefined,
+    totalRuns: 0,
+    successRuns: 0,
+    failureRuns: 0,
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  await ctx.db.patch(task._id, {
+    linkedJobId: jobId,
+    updatedAt: now,
+  });
+
+  return jobId;
+}
+
+async function createTaskFromEvent(ctx: any, event: any, endpoint: any, payload: any): Promise<any> {
+  const now = Date.now();
+  const providedTaskId = typeof payload?.taskId === "string" ? payload.taskId : undefined;
+  const taskId = providedTaskId ?? makeId(`EV-${event.eventType.toUpperCase()}`);
+
+  const existing = await findTaskByTaskId(ctx, taskId);
+  if (existing) return existing;
+
+  const task = {
+    taskId,
+    agent: endpoint.targetAgent ?? payload?.agent ?? "codex",
+    title: payload?.title ?? `Event ${event.eventType}`,
+    description:
+      payload?.description ??
+      [
+        `Generated from event ${event.eventType}`,
+        `Source: ${event.source}`,
+        `Event ID: ${event.eventId}`,
+        "",
+        safeString(payload),
+      ].join("\n"),
+    status: "todo",
+    priority: payload?.priority ?? "medium",
+    category: payload?.category ?? "backend",
+    phaseId: payload?.phaseId,
+    tags: ["webhook", "event-driven"],
+    createdAt: now,
+    updatedAt: now,
+    statusHistory: [
+      {
+        status: "todo",
+        timestamp: now,
+        agent: endpoint.targetAgent ?? payload?.agent ?? "codex",
+        note: `Created by webhook endpoint ${endpoint.webhookId}`,
+      },
+    ],
+    commits: [],
+    notes: `Triggered by event ${event.eventId}`,
+  } as any;
+
+  await ctx.db.insert("tasks", task);
+  return await findTaskByTaskId(ctx, taskId);
+}
+
+async function processEvent(ctx: any, event: any): Promise<{
+  routed: number;
+  createdTasks: string[];
+  createdJobs: string[];
+}> {
+  const endpoints = await ctx.db
+    .query("webhookEndpoints")
+    .withIndex("by_enabled", (q: any) => q.eq("enabled", true))
+    .collect();
+
+  const matched = endpoints.filter(
+    (endpoint: any) =>
+      (endpoint.eventType === event.eventType || endpoint.eventType === "*") &&
+      matchesRules(endpoint.rules, event.payload),
+  );
+
+  const createdTasks: string[] = [];
+  const createdJobs: string[] = [];
+
+  for (const endpoint of matched) {
+    const deliveryId = makeId("delivery");
+    await ctx.db.insert("webhookDeliveries", {
+      deliveryId,
+      webhookId: endpoint.webhookId,
+      eventId: event.eventId,
+      status: "received",
+      payload: event.payload,
+      error: undefined,
+      receivedAt: Date.now(),
+      processedAt: undefined,
+    });
+
+    try {
+      let task = event.taskId ? await findTaskByTaskId(ctx, event.taskId) : null;
+      if (endpoint.createTask) {
+        task = await createTaskFromEvent(ctx, event, endpoint, event.payload);
+        if (task) createdTasks.push(task.taskId);
+      }
+
+      if (endpoint.createJob) {
+        const taskForJob = task ?? (event.taskId ? await findTaskByTaskId(ctx, event.taskId) : null);
+        if (taskForJob) {
+          const jobId = await ensureJobForTask(ctx, taskForJob, "main");
+          createdJobs.push(jobId);
+        }
+      }
+
+      await ctx.db.patch(endpoint._id, {
+        lastTriggeredAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+
+      const delivery = await ctx.db
+        .query("webhookDeliveries")
+        .withIndex("by_deliveryId", (q: any) => q.eq("deliveryId", deliveryId))
+        .first();
+      if (delivery) {
+        await ctx.db.patch(delivery._id, {
+          status: "processed",
+          processedAt: Date.now(),
+        });
+      }
+    } catch (error: any) {
+      const delivery = await ctx.db
+        .query("webhookDeliveries")
+        .withIndex("by_deliveryId", (q: any) => q.eq("deliveryId", deliveryId))
+        .first();
+      if (delivery) {
+        await ctx.db.patch(delivery._id, {
+          status: "failed",
+          error: error?.message ?? String(error),
+          processedAt: Date.now(),
+        });
+      }
+    }
+  }
+
+  await ctx.db.patch(event._id, {
+    handled: true,
+    handledAt: Date.now(),
+  });
+
+  return {
+    routed: matched.length,
+    createdTasks: [...new Set(createdTasks)],
+    createdJobs: [...new Set(createdJobs)],
+  };
+}
+
+export const listEvents = query({
+  args: {
+    eventType: v.optional(v.string()),
+    handled: v.optional(v.boolean()),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    let events = await ctx.db.query("agentEvents").collect();
+    if (args.eventType) events = events.filter((event) => event.eventType === args.eventType);
+    if (args.handled !== undefined) events = events.filter((event) => event.handled === args.handled);
+    events.sort((a, b) => b.createdAt - a.createdAt);
+    return args.limit ? events.slice(0, args.limit) : events;
+  },
+});
+
+export const listWebhooks = query({
+  args: {
+    enabled: v.optional(v.boolean()),
+  },
+  handler: async (ctx, { enabled }) => {
+    let endpoints = await ctx.db.query("webhookEndpoints").collect();
+    if (enabled !== undefined) endpoints = endpoints.filter((endpoint) => endpoint.enabled === enabled);
+    return endpoints.sort((a, b) => b.updatedAt - a.updatedAt);
+  },
+});
+
+export const registerWebhook = mutation({
+  args: {
+    webhookId: v.optional(v.string()),
+    name: v.string(),
+    path: v.string(),
+    secret: v.optional(v.string()),
+    enabled: v.optional(v.boolean()),
+    eventType: v.string(),
+    rules: v.optional(v.any()),
+    targetAgent: v.optional(v.string()),
+    createTask: v.optional(v.boolean()),
+    createJob: v.optional(v.boolean()),
+    createdBy: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const webhookId = args.webhookId ?? makeId("wh");
+
+    const existing = await ctx.db
+      .query("webhookEndpoints")
+      .withIndex("by_webhookId", (q: any) => q.eq("webhookId", webhookId))
+      .first();
+
+    if (existing) {
+      await ctx.db.patch(existing._id, {
+        name: args.name,
+        path: args.path,
+        secret: args.secret,
+        enabled: args.enabled ?? existing.enabled,
+        eventType: args.eventType,
+        rules: args.rules,
+        targetAgent: args.targetAgent,
+        createTask: args.createTask ?? existing.createTask,
+        createJob: args.createJob ?? existing.createJob,
+        updatedAt: now,
+      });
+      return { webhookId, updated: true };
+    }
+
+    await ctx.db.insert("webhookEndpoints", {
+      webhookId,
+      name: args.name,
+      path: args.path,
+      secret: args.secret,
+      enabled: args.enabled ?? true,
+      eventType: args.eventType,
+      rules: args.rules,
+      targetAgent: args.targetAgent,
+      createTask: args.createTask ?? true,
+      createJob: args.createJob ?? false,
+      createdBy: args.createdBy,
+      lastTriggeredAt: undefined,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    return { webhookId, created: true };
+  },
+});
+
+export const setWebhookEnabled = mutation({
+  args: {
+    webhookId: v.string(),
+    enabled: v.boolean(),
+  },
+  handler: async (ctx, { webhookId, enabled }) => {
+    const endpoint = await ctx.db
+      .query("webhookEndpoints")
+      .withIndex("by_webhookId", (q: any) => q.eq("webhookId", webhookId))
+      .first();
+    if (!endpoint) throw new Error(`Webhook ${webhookId} not found`);
+
+    await ctx.db.patch(endpoint._id, {
+      enabled,
+      updatedAt: Date.now(),
+    });
+  },
+});
+
+export const emitEvent = mutation({
+  args: {
+    eventId: v.optional(v.string()),
+    eventType: v.string(),
+    source: v.string(),
+    sourceId: v.optional(v.string()),
+    taskId: v.optional(v.string()),
+    payload: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const eventId = args.eventId ?? makeId("evt");
+
+    const existing = await ctx.db
+      .query("agentEvents")
+      .withIndex("by_eventId", (q: any) => q.eq("eventId", eventId))
+      .first();
+    if (existing) {
+      return { eventId, duplicated: true };
+    }
+
+    await ctx.db.insert("agentEvents", {
+      eventId,
+      eventType: args.eventType,
+      source: args.source,
+      sourceId: args.sourceId,
+      taskId: args.taskId,
+      payload: args.payload,
+      handled: false,
+      handledAt: undefined,
+      createdAt: now,
+    });
+
+    const event = await ctx.db
+      .query("agentEvents")
+      .withIndex("by_eventId", (q: any) => q.eq("eventId", eventId))
+      .first();
+    if (!event) throw new Error(`Event ${eventId} not found after insert`);
+
+    const routing = await processEvent(ctx, event);
+    return { eventId, ...routing };
+  },
+});
+
+export const ingestWebhook = mutation({
+  args: {
+    path: v.string(),
+    secret: v.optional(v.string()),
+    payload: v.optional(v.any()),
+    headers: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const endpoint = await ctx.db
+      .query("webhookEndpoints")
+      .withIndex("by_path", (q: any) => q.eq("path", args.path))
+      .first();
+
+    if (!endpoint || !endpoint.enabled) {
+      return { accepted: false, reason: "endpoint_not_found_or_disabled" };
+    }
+
+    if (endpoint.secret && endpoint.secret !== args.secret) {
+      await ctx.db.insert("webhookDeliveries", {
+        deliveryId: makeId("delivery"),
+        webhookId: endpoint.webhookId,
+        eventId: undefined,
+        status: "rejected",
+        payload: args.payload,
+        error: "invalid_secret",
+        receivedAt: Date.now(),
+        processedAt: Date.now(),
+      });
+      return { accepted: false, reason: "invalid_secret" };
+    }
+
+    const eventId = makeId("evt-webhook");
+    await ctx.db.insert("agentEvents", {
+      eventId,
+      eventType: endpoint.eventType,
+      source: "webhook",
+      sourceId: endpoint.webhookId,
+      taskId: typeof args.payload?.taskId === "string" ? args.payload.taskId : undefined,
+      payload: {
+        ...(args.payload ?? {}),
+        _headers: args.headers,
+        _path: args.path,
+      },
+      handled: false,
+      handledAt: undefined,
+      createdAt: Date.now(),
+    });
+
+    const event = await ctx.db
+      .query("agentEvents")
+      .withIndex("by_eventId", (q: any) => q.eq("eventId", eventId))
+      .first();
+    if (!event) throw new Error(`Webhook event ${eventId} not found`);
+
+    const routing = await processEvent(ctx, event);
+    return { accepted: true, eventId, ...routing };
+  },
+});