bopodev-api 0.1.27 → 0.1.29

package/src/startup/scheduler-config.ts

@@ -0,0 +1,39 @@
+import { asc, companies, eq } from "bopodev-db";
+import type { BootstrappedDb } from "./database";
+
+export async function resolveSchedulerCompanyId(
+  db: BootstrappedDb["db"],
+  configuredCompanyId: string | null
+) {
+  if (configuredCompanyId) {
+    const configured = await db
+      .select({ id: companies.id })
+      .from(companies)
+      .where(eq(companies.id, configuredCompanyId))
+      .limit(1);
+    if (configured.length > 0) {
+      return configuredCompanyId;
+    }
+    // eslint-disable-next-line no-console
+    console.warn(`[startup] BOPO_DEFAULT_COMPANY_ID='${configuredCompanyId}' was not found; using first available company.`);
+  }
+
+  const fallback = await db
+    .select({ id: companies.id })
+    .from(companies)
+    .orderBy(asc(companies.createdAt))
+    .limit(1);
+  const id = fallback[0]?.id;
+  return typeof id === "string" && id.length > 0 ? id : null;
+}
+
+export function shouldStartScheduler() {
+  const rawRole = (process.env.BOPO_SCHEDULER_ROLE ?? "auto").trim().toLowerCase();
+  if (rawRole === "off" || rawRole === "follower") {
+    return false;
+  }
+  if (rawRole === "leader" || rawRole === "auto") {
+    return true;
+  }
+  throw new Error(`Invalid BOPO_SCHEDULER_ROLE '${rawRole}'. Expected one of: auto, leader, follower, off.`);
+}

package/src/types/express.d.ts

@@ -0,0 +1,13 @@
+import type { RequestActor } from "./request-actor";
+
+declare global {
+  namespace Express {
+    interface Request {
+      actor?: RequestActor;
+      companyId?: string;
+      requestId?: string;
+    }
+  }
+}
+
+export {};

package/src/types/request-actor.ts

@@ -0,0 +1,6 @@
+export type RequestActor = {
+  type: "board" | "member" | "agent";
+  id: string;
+  companyIds: string[] | null;
+  permissions: string[];
+};

package/src/validation/issue-routes.ts

@@ -0,0 +1,79 @@
+import { z } from "zod";
+
+export const createIssueSchema = z.object({
+  projectId: z.string().min(1),
+  parentIssueId: z.string().optional(),
+  title: z.string().min(1),
+  body: z.string().optional(),
+  metadata: z
+    .object({
+      delegatedHiringIntent: z
+        .object({
+          intentType: z.literal("agent_hiring_request"),
+          requestedRole: z.string().nullable().optional(),
+          requestedRoleKey: z.string().nullable().optional(),
+          requestedTitle: z.string().nullable().optional(),
+          requestedName: z.string().nullable().optional(),
+          requestedManagerAgentId: z.string().nullable().optional(),
+          requestedProviderType: z.string().nullable().optional(),
+          requestedRuntimeModel: z.string().nullable().optional()
+        })
+        .optional()
+    })
+    .optional(),
+  status: z.enum(["todo", "in_progress", "blocked", "in_review", "done", "canceled"]).default("todo"),
+  priority: z.enum(["none", "low", "medium", "high", "urgent"]).default("none"),
+  assigneeAgentId: z.string().nullable().optional(),
+  goalIds: z.array(z.string().min(1)).default([]),
+  externalLink: z.string().max(2048).nullable().optional(),
+  labels: z.array(z.string()).default([]),
+  tags: z.array(z.string()).default([])
+});
+
+export const createIssueCommentSchema = z.object({
+  body: z.string().min(1),
+  recipients: z
+    .array(
+      z.object({
+        recipientType: z.enum(["agent", "board", "member"]),
+        recipientId: z.string().nullable().optional()
+      })
+    )
+    .default([]),
+  authorType: z.enum(["human", "agent", "system"]).optional(),
+  authorId: z.string().optional()
+});
+
+export const createIssueCommentLegacySchema = z.object({
+  issueId: z.string().min(1),
+  body: z.string().min(1),
+  recipients: z
+    .array(
+      z.object({
+        recipientType: z.enum(["agent", "board", "member"]),
+        recipientId: z.string().nullable().optional()
+      })
+    )
+    .default([]),
+  authorType: z.enum(["human", "agent", "system"]).optional(),
+  authorId: z.string().optional()
+});
+
+export const updateIssueCommentSchema = z.object({
+  body: z.string().min(1)
+});
+
+export const updateIssueSchema = z
+  .object({
+    projectId: z.string().min(1).optional(),
+    title: z.string().min(1).optional(),
+    body: z.string().nullable().optional(),
+    status: z.enum(["todo", "in_progress", "blocked", "in_review", "done", "canceled"]).optional(),
+    priority: z.enum(["none", "low", "medium", "high", "urgent"]).optional(),
+    assigneeAgentId: z.string().nullable().optional(),
+    goalIds: z.array(z.string().min(1)).optional(),
+    externalLink: z.string().max(2048).nullable().optional(),
+    labels: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional()
+  })
+  .refine((payload) => Object.keys(payload).length > 0, "At least one field must be provided.");

package/src/worker/scheduler.ts

@@ -4,6 +4,10 @@ import { runHeartbeatSweep } from "../services/heartbeat-service";
 import { runHeartbeatQueueSweep } from "../services/heartbeat-queue-service";
 import { runIssueCommentDispatchSweep } from "../services/comment-recipient-dispatch-service";
 
+export type HeartbeatSchedulerHandle = {
+  stop: () => Promise<void>;
+};
+
 export function createHeartbeatScheduler(db: BopoDb, companyId: string, realtimeHub?: RealtimeHub) {
   const heartbeatIntervalMs = Number(process.env.BOPO_HEARTBEAT_SWEEP_MS ?? 60_000);
   const queueIntervalMs = Number(process.env.BOPO_HEARTBEAT_QUEUE_SWEEP_MS ?? 2_000);
@@ -11,18 +15,22 @@ export function createHeartbeatScheduler(db: BopoDb, companyId: string, realtime
   let heartbeatRunning = false;
   let queueRunning = false;
   let commentDispatchRunning = false;
+  let heartbeatPromise: Promise<unknown> | null = null;
+  let queuePromise: Promise<unknown> | null = null;
+  let commentDispatchPromise: Promise<unknown> | null = null;
   const heartbeatTimer = setInterval(() => {
     if (heartbeatRunning) {
       return;
     }
     heartbeatRunning = true;
-    void runHeartbeatSweep(db, companyId, { realtimeHub })
+    heartbeatPromise = runHeartbeatSweep(db, companyId, { realtimeHub })
       .catch((error) => {
         // eslint-disable-next-line no-console
         console.error("[scheduler] heartbeat sweep failed", error);
       })
       .finally(() => {
         heartbeatRunning = false;
+        heartbeatPromise = null;
       });
   }, heartbeatIntervalMs);
   const queueTimer = setInterval(() => {
@@ -30,13 +38,14 @@ export function createHeartbeatScheduler(db: BopoDb, companyId: string, realtime
       return;
     }
     queueRunning = true;
-    void runHeartbeatQueueSweep(db, companyId, { realtimeHub })
+    queuePromise = runHeartbeatQueueSweep(db, companyId, { realtimeHub })
       .catch((error) => {
         // eslint-disable-next-line no-console
         console.error("[scheduler] queue sweep failed", error);
       })
       .finally(() => {
         queueRunning = false;
+        queuePromise = null;
       });
   }, queueIntervalMs);
   const commentDispatchTimer = setInterval(() => {
@@ -44,18 +53,25 @@ export function createHeartbeatScheduler(db: BopoDb, companyId: string, realtime
       return;
     }
     commentDispatchRunning = true;
-    void runIssueCommentDispatchSweep(db, companyId, { realtimeHub })
+    commentDispatchPromise = runIssueCommentDispatchSweep(db, companyId, { realtimeHub })
       .catch((error) => {
         // eslint-disable-next-line no-console
         console.error("[scheduler] comment dispatch sweep failed", error);
       })
       .finally(() => {
         commentDispatchRunning = false;
+        commentDispatchPromise = null;
       });
   }, commentDispatchIntervalMs);
-  return () => {
+  const stop = async () => {
     clearInterval(heartbeatTimer);
     clearInterval(queueTimer);
     clearInterval(commentDispatchTimer);
+    await Promise.allSettled(
+      [heartbeatPromise, queuePromise, commentDispatchPromise].filter(
+        (promise): promise is Promise<unknown> => promise !== null
+      )
+    );
   };
+  return { stop } satisfies HeartbeatSchedulerHandle;
 }