More progress

Author: cte

apps/cloud-agents/package.json

@@ -5,7 +5,7 @@
 	"scripts": {
 		"lint": "next lint",
 		"check-types": "tsc --noEmit",
-		"dev": "next dev --port 3001",
+		"dev": "concurrently \"next dev --port 3001\" \"ngrok http 3001 --domain cte.ngrok.dev\"",
 		"build": "next build",
 		"start": "next start --port 3001",
 		"clean": "rimraf .next .turbo",
@@ -45,6 +45,7 @@
 		"@types/node": "^22.15.20",
 		"@types/react": "^18.3.23",
 		"@types/react-dom": "^18.3.7",
+		"concurrently": "^9.1.0",
 		"drizzle-kit": "^0.31.1",
 		"tsx": "^4.19.3"
 	}

apps/cloud-agents/src/app/api/jobs/route.ts

@@ -20,7 +20,7 @@ export async function POST(request: NextRequest) {
 
 		switch (values.type) {
 			case "github.issue.fix":
-				await enqueue("github.issue.fix", values.payload, job.id)
+				await enqueue({ jobId: job.id, type: "github.issue.fix", payload: values.payload })
 				break
 			default:
 				throw new Error(`Unknown job type: ${values.type}`)

apps/cloud-agents/src/app/api/webhooks/github/route.ts

@@ -2,24 +2,12 @@ import { NextRequest, NextResponse } from "next/server"
 import { createHmac } from "crypto"
 import { z } from "zod"
 
+import { type JobType, type JobStatus, type JobPayload, githubWebhookSchema } from "@/types"
 import { db, cloudJobs } from "@/db"
 import { enqueue } from "@/lib"
 
-const githubWebhookSchema = z.object({
-	action: z.string(),
-	issue: z.object({
-		number: z.number(),
-		title: z.string(),
-		body: z.string().nullable(),
-		labels: z.array(z.object({ name: z.string() })),
-	}),
-	repository: z.object({
-		full_name: z.string(),
-	}),
-})
-
-function verifySignature(payload: string, signature: string, secret: string): boolean {
-	const expectedSignature = createHmac("sha256", secret).update(payload, "utf8").digest("hex")
+function verifySignature(body: string, signature: string, secret: string): boolean {
+	const expectedSignature = createHmac("sha256", secret).update(body, "utf8").digest("hex")
 	const receivedSignature = signature.replace("sha256=", "")
 	return expectedSignature === receivedSignature
 }
@@ -33,40 +21,45 @@ export async function POST(request: NextRequest) {
 			return NextResponse.json({ error: "Missing signature" }, { status: 400 })
 		}
 
-		const payload = await request.text()
+		const body = await request.text()
 
-		if (!verifySignature(payload, signature, process.env.GITHUB_WEBHOOK_SECRET!)) {
+		if (!verifySignature(body, signature, process.env.GITHUB_WEBHOOK_SECRET!)) {
 			return NextResponse.json({ error: "Invalid signature" }, { status: 401 })
 		}
 
+		console.log("✅ Signature verified")
+		console.log("📋 Event ->", event)
+
 		if (event !== "issues") {
-			return NextResponse.json({ message: "Event ignored" })
+			return NextResponse.json({ message: "event_ignored" })
 		}
 
-		const data = githubWebhookSchema.parse(JSON.parse(payload))
+		const data = githubWebhookSchema.parse(JSON.parse(body))
+
+		console.log("🗄️ Data ->", data)
 
 		if (data.action !== "opened") {
-			return NextResponse.json({ message: "Action ignored" })
+			return NextResponse.json({ message: "action_ignored" })
 		}
 
-		const jobPayload = {
+		const type: JobType = "github.issue.fix"
+		const status: JobStatus = "pending"
+
+		const payload: JobPayload<typeof type> = {
 			repo: data.repository.full_name,
 			issue: data.issue.number,
 			title: data.issue.title,
 			body: data.issue.body || "",
 			labels: data.issue.labels.map((label) => label.name),
 		}
 
-		const [job] = await db
-			.insert(cloudJobs)
-			.values({ type: "github.issue.fix", status: "pending", payload: jobPayload })
-			.returning()
+		const [job] = await db.insert(cloudJobs).values({ type, status, payload }).returning()
 
 		if (!job) {
 			throw new Error("Failed to create job")
 		}
 
-		await enqueue("github.issue.fix", jobPayload, job.id)
+		await enqueue({ jobId: job.id, type, payload })
 		return NextResponse.json({ message: "Job created successfully", jobId: job.id })
 	} catch (error) {
 		console.error("GitHub webhook error:", error)

apps/cloud-agents/src/db/schema.ts

@@ -1,28 +1,32 @@
 import { pgTable, text, timestamp, integer, jsonb } from "drizzle-orm/pg-core"
 import { relations } from "drizzle-orm"
 
+import type { JobType, JobStatus, JobPayload } from "@/types"
+
 /**
  * cloudJobs
  */
 
 export const cloudJobs = pgTable("cloud_jobs", {
 	id: integer().primaryKey().generatedAlwaysAsIdentity(),
-	type: text().notNull(), // e.g., 'github.issue.fix'
-	status: text().notNull().default("pending"), // 'pending', 'processing', 'completed', 'failed'
-	payload: jsonb().notNull(), // job-specific data
-	result: jsonb(), // job output
-	error: text(), // error message if failed
-	createdAt: timestamp("created_at").notNull().defaultNow(),
+	type: text().notNull().$type<JobType>(),
+	status: text().notNull().default("pending").$type<JobStatus>(),
+	payload: jsonb().notNull().$type<JobPayload>(),
+	result: jsonb(),
+	error: text(),
 	startedAt: timestamp("started_at"),
 	completedAt: timestamp("completed_at"),
+	createdAt: timestamp("created_at").notNull().defaultNow(),
 })
 
 export const cloudJobsRelations = relations(cloudJobs, ({ many }) => ({
 	tasks: many(cloudTasks),
 }))
 
 export type CloudJob = typeof cloudJobs.$inferSelect
+
 export type InsertCloudJob = typeof cloudJobs.$inferInsert
+
 export type UpdateCloudJob = Partial<Omit<CloudJob, "id" | "createdAt">>
 
 /**
@@ -34,8 +38,8 @@ export const cloudTasks = pgTable("cloud_tasks", {
 	jobId: integer("job_id")
 		.references(() => cloudJobs.id)
 		.notNull(),
-	taskId: integer("task_id"), // references tasks from evals database
-	containerId: text("container_id"), // Docker container ID
+	taskId: integer("task_id"),
+	containerId: text("container_id"),
 	createdAt: timestamp("created_at").notNull().defaultNow(),
 })
 
@@ -44,7 +48,9 @@ export const cloudTasksRelations = relations(cloudTasks, ({ one }) => ({
 }))
 
 export type CloudTask = typeof cloudTasks.$inferSelect
+
 export type InsertCloudTask = typeof cloudTasks.$inferInsert
+
 export type UpdateCloudTask = Partial<Omit<CloudTask, "id" | "createdAt">>
 
 /**

apps/cloud-agents/src/lib/job.ts

@@ -1,14 +1,13 @@
 import { eq } from "drizzle-orm"
 import { Job } from "bullmq"
 
-import { db, cloudJobs } from "@/db"
-import type { JobTypes, CloudJobData } from "@/types"
+import { db, cloudJobs, type UpdateCloudJob } from "@/db"
+import type { JobTypes, JobType, JobStatus, JobParams } from "@/types"
 
 import { fixGitHubIssue } from "./jobs/fixGitHubIssue"
 
-export async function processJob(job: Job<CloudJobData>) {
-	const { type, payload, jobId } = job.data
-	console.log(`Processing job ${jobId} of type ${type}`)
+export async function processJob<T extends JobType>({ data: { type, payload, jobId }, ...job }: Job<JobParams<T>>) {
+	console.log(`[${job.name} | ${job.id}] Processing job ${jobId} of type ${type}`)
 
 	try {
 		await updateJobStatus(jobId, "processing")
@@ -23,36 +22,31 @@ export async function processJob(job: Job<CloudJobData>) {
 		}
 
 		await updateJobStatus(jobId, "completed", result)
-		console.log(`Job ${jobId} completed successfully`)
+		console.log(`[${job.name} | ${job.id}] Job ${jobId} completed successfully`)
 	} catch (error) {
-		console.error(`Job ${jobId} failed:`, error)
+		console.error(`[${job.name} | ${job.id}] Job ${jobId} failed:`, error)
 		const errorMessage = error instanceof Error ? error.message : String(error)
 		await updateJobStatus(jobId, "failed", undefined, errorMessage)
 		throw error // Re-throw to mark job as failed in BullMQ.
 	}
 }
 
-async function updateJobStatus(
-	jobId: number,
-	status: "processing" | "completed" | "failed",
-	result?: unknown,
-	error?: string,
-) {
-	const updates: Record<string, unknown> = { status }
+async function updateJobStatus(jobId: number, status: JobStatus, result?: unknown, error?: string) {
+	const values: UpdateCloudJob = { status }
 
 	if (status === "processing") {
-		updates.startedAt = new Date()
+		values.startedAt = new Date()
 	} else if (status === "completed" || status === "failed") {
-		updates.completedAt = new Date()
+		values.completedAt = new Date()
 
 		if (result) {
-			updates.result = result
+			values.result = result
 		}
 
 		if (error) {
-			updates.error = error
+			values.error = error
 		}
 	}
 
-	await db.update(cloudJobs).set(updates).where(eq(cloudJobs.id, jobId))
+	await db.update(cloudJobs).set(values).where(eq(cloudJobs.id, jobId))
 }

apps/cloud-agents/src/lib/queue.ts

@@ -1,6 +1,6 @@
 import { Queue, Job } from "bullmq"
 
-import type { JobTypes, CloudJobData } from "@/types"
+import type { JobTypes, JobPayload, JobParams } from "@/types"
 
 import { redis } from "./redis"
 
@@ -14,10 +14,6 @@ const queue = new Queue("cloud-agents", {
 	},
 })
 
-export async function enqueue<T extends keyof JobTypes>(
-	type: T,
-	payload: JobTypes[T],
-	jobId: number,
-): Promise<Job<CloudJobData<T>>> {
-	return queue.add(type, { type, payload, jobId }, { jobId: `${type}-${jobId}` })
+export async function enqueue<T extends keyof JobTypes>(params: JobParams<T>): Promise<Job<JobPayload<T>>> {
+	return queue.add(params.type, params, { jobId: `${params.type}-${params.jobId}` })
 }

apps/cloud-agents/src/types/index.ts

@@ -2,22 +2,30 @@ import { z } from "zod"
 
 export interface JobTypes {
 	"github.issue.fix": {
-		repo: string // e.g., "RooCodeInc/Roo-Code"
-		issue: number // Issue number
-		title: string // Issue title
-		body: string // Issue description
-		labels?: string[] // Issue labels
+		repo: string
+		issue: number
+		title: string
+		body: string
+		labels?: string[]
 	}
 }
 
+export type JobType = keyof JobTypes
+
 export type JobStatus = "pending" | "processing" | "completed" | "failed"
 
-export type CloudJobData<T extends keyof JobTypes = keyof JobTypes> = {
-	type: T
-	payload: JobTypes[T]
+export type JobPayload<T extends JobType = JobType> = JobTypes[T]
+
+export type JobParams<T extends JobType> = {
 	jobId: number
+	type: T
+	payload: JobPayload<T>
 }
 
+/**
+ * CreateJob
+ */
+
 export const createJobSchema = z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("github.issue.fix"),
@@ -32,3 +40,22 @@ export const createJobSchema = z.discriminatedUnion("type", [
 ])
 
 export type CreateJob = z.infer<typeof createJobSchema>
+
+/**
+ * GitHubWebhook
+ */
+
+export const githubWebhookSchema = z.object({
+	action: z.string(),
+	issue: z.object({
+		number: z.number(),
+		title: z.string(),
+		body: z.string().nullable(),
+		labels: z.array(z.object({ name: z.string() })),
+	}),
+	repository: z.object({
+		full_name: z.string(),
+	}),
+})
+
+export type GitHubWebhook = z.infer<typeof githubWebhookSchema>