@mndrk/agx 1.4.61 → 1.4.62

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/worker/index.js

@@ -11768,11 +11768,11 @@ var init_worker = __esm({
       loopDelayPromise = null;
       beenNotified = false;
       runPromise = null;
-      constructor({ id, name, options, interval, fetch, onFetch, onError }) {
+      constructor({ id, name, options, interval, fetch: fetch2, onFetch, onError }) {
         this.id = id;
         this.name = name;
         this.options = options;
-        this.fetch = fetch;
+        this.fetch = fetch2;
         this.onFetch = onFetch;
         this.onError = onError;
         this.interval = interval;
@@ -12181,7 +12181,7 @@ var init_manager = __esm({
         }
         const firstWorkerId = (0, import_node_crypto.randomUUID)({ disableEntropyCache: true });
         const createWorker = (workerId) => {
-          const fetch = () => {
+          const fetch2 = () => {
             const ignoreGroups = localGroupConcurrency != null ? this.#getGroupsAtLocalCapacity(name) : void 0;
             return this.fetch(name, { batchSize, includeMetadata, priority, orderByCreatedOn, groupConcurrency, ignoreGroups });
           };
@@ -12214,7 +12214,7 @@ var init_manager = __esm({
           const onError = (error) => {
             this.emit(events.error, { ...error, message: error.message, stack: error.stack, queue: name, worker: workerId });
           };
-          return new worker_default({ id: workerId, name, options, interval, fetch, onFetch, onError });
+          return new worker_default({ id: workerId, name, options, interval, fetch: fetch2, onFetch, onError });
         };
         for (let i = 0; i < localConcurrency; i++) {
           const workerId = i === 0 ? firstWorkerId : (0, import_node_crypto.randomUUID)({ disableEntropyCache: true });
@@ -18872,8 +18872,129 @@ function isDependencyBlockedReason(reason) {
   return typeof reason === "string" && reason.startsWith(DEPENDENCY_BLOCKED_REASON_PREFIX);
 }
 
-// ../agx-cloud/lib/db.ts
+// ../agx-cloud/lib/notifications/constants.ts
+var NOTIFICATION_EVENT_OPTIONS = [
+  {
+    value: "task.created",
+    label: "Task created",
+    description: "Fires immediately when a new task is added to the queue."
+  },
+  {
+    value: "task.stage_complete",
+    label: "Stage completed",
+    description: "Emitted whenever a stage finishes and the task advances."
+  },
+  {
+    value: "task.completed",
+    label: "Task completed",
+    description: "When the task reaches a completed status (done)."
+  },
+  {
+    value: "task.failed",
+    label: "Task failed",
+    description: "When the task may have errored, including cancellations."
+  },
+  {
+    value: "task.blocked",
+    label: "Task blocked",
+    description: "When the agent raises the task as blocked awaiting manual input."
+  }
+];
+var NOTIFICATION_EVENT_VALUES = NOTIFICATION_EVENT_OPTIONS.map((option) => option.value);
+
+// ../agx-cloud/lib/notifications/index.ts
+var SchemaNotReadyError = class extends Error {
+};
 function isMissingRelationError(error, relation) {
+  if (!error || typeof error !== "object") return false;
+  const code = error.code;
+  const message = typeof error.message === "string" ? error.message : "";
+  return code === "42P01" || code === "PGRST205" || message.includes(`relation "${relation}" does not exist`) || message.includes(`Could not find the table 'agx.${relation}'`) || message.includes(`Could not find the table 'public.${relation}'`);
+}
+function mapWebhookRecord(raw) {
+  const events5 = Array.isArray(raw.events) ? raw.events.filter((value) => typeof value === "string").map((value) => value.trim()).filter(
+    (value) => NOTIFICATION_EVENT_VALUES.includes(value)
+  ) : [];
+  return {
+    id: String(raw.id),
+    user_id: String(raw.user_id),
+    url: String(raw.url),
+    name: raw.name != null ? String(raw.name) : null,
+    events: events5,
+    enabled: raw.enabled !== false,
+    created_at: String(raw.created_at),
+    updated_at: String(raw.updated_at)
+  };
+}
+async function handleRelationError(relation, error) {
+  if (isMissingRelationError(error, relation)) {
+    throw new SchemaNotReadyError(`Missing relation: ${relation}`);
+  }
+  throw error;
+}
+async function listNotificationWebhooks(userId) {
+  const db = createAdminDbClient();
+  const { data, error } = await db.from("notification_webhooks").select("*").eq("user_id", userId).order("created_at", { ascending: false });
+  if (error) {
+    await handleRelationError("notification_webhooks", error);
+  }
+  if (!data) return [];
+  return (Array.isArray(data) ? data : [data]).map(mapWebhookRecord);
+}
+async function notifyTaskEvent(payload) {
+  if (!payload.userId) return;
+  let endpoints = [];
+  try {
+    endpoints = await listNotificationWebhooks(payload.userId);
+  } catch (error) {
+    if (error instanceof SchemaNotReadyError) {
+      console.debug("[notifications] notification_webhooks schema not ready, skipping");
+      return;
+    }
+    console.error("[notifications] failed to load webhooks", error);
+    return;
+  }
+  const targets = endpoints.filter(
+    (endpoint) => endpoint.enabled && endpoint.events.includes(payload.eventType)
+  );
+  if (!targets.length) return;
+  const timestamp = payload.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const body = {
+    eventType: payload.eventType,
+    taskId: payload.taskId,
+    userId: payload.userId,
+    title: payload.title || null,
+    slug: payload.slug || null,
+    stage: payload.stage || null,
+    previousStage: payload.previousStage || null,
+    nextStage: payload.nextStage || null,
+    status: payload.status || null,
+    error: payload.error || null,
+    timestamp,
+    details: payload.details || {}
+  };
+  await Promise.all(
+    targets.map(async (endpoint) => {
+      try {
+        const response = await fetch(endpoint.url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          console.error(
+            `[notifications] webhook ${endpoint.url} responded with ${response.status}`
+          );
+        }
+      } catch (error) {
+        console.error(`[notifications] failed to send to ${endpoint.url}`, error);
+      }
+    })
+  );
+}
+
+// ../agx-cloud/lib/db.ts
+function isMissingRelationError2(error, relation) {
   if (!error) return false;
   const message = typeof error.message === "string" ? error.message : "";
   return error.code === "42P01" || error.code === "PGRST205" || message.includes(`relation "${relation}" does not exist`) || message.includes(`Could not find the table 'agx.${relation}'`) || message.includes(`Could not find the table 'public.${relation}'`);
@@ -19084,13 +19205,36 @@ async function updateTask(id, content, userId, options) {
   }
   await ensureTaskDependencyState(data, userId);
   const refreshed = await getTask(data.id, userId);
-  return refreshed || data;
+  const taskRecord = refreshed || data;
+  const resolvedUserId = userId || taskRecord.user_id;
+  if (resolvedUserId) {
+    const eventTimestamp = taskRecord.created_at || (/* @__PURE__ */ new Date()).toISOString();
+    const details = {
+      dependsOn: Array.isArray(taskRecord.depends_on) ? taskRecord.depends_on : [],
+      project: taskRecord.project || null,
+      projectId: taskRecord.project_id || null,
+      workflowId: taskRecord.workflow_id || null,
+      createdBy: taskRecord.created_by || null
+    };
+    void notifyTaskEvent({
+      taskId: taskRecord.id,
+      userId: resolvedUserId,
+      eventType: "task.created",
+      title: taskRecord.title || null,
+      slug: taskRecord.slug || null,
+      stage: taskRecord.stage || null,
+      status: taskRecord.status || null,
+      timestamp: eventTimestamp,
+      details
+    });
+  }
+  return taskRecord;
 }
 async function getWorkflowNodes(workflowId) {
   const db = createAdminDbClient();
   const { data, error } = await db.from("workflow_nodes").select("*").eq("workflow_id", workflowId).order("position", { ascending: true });
   if (error) {
-    if (isMissingRelationError(error, "workflow_nodes")) return [];
+    if (isMissingRelationError2(error, "workflow_nodes")) return [];
     throw error;
   }
   return data || [];
@@ -19099,7 +19243,7 @@ async function getWorkflowNodeByName(workflowId, name) {
   const db = createAdminDbClient();
   const { data, error } = await db.from("workflow_nodes").select("*").eq("workflow_id", workflowId).eq("name", name).maybeSingle();
   if (error) {
-    if (isMissingRelationError(error, "workflow_nodes")) return null;
+    if (isMissingRelationError2(error, "workflow_nodes")) return null;
     throw error;
   }
   return data;
@@ -19108,7 +19252,7 @@ async function getWorkflowTransitionsFromNode(workflowId, fromNodeId) {
   const db = createAdminDbClient();
   const { data, error } = await db.from("workflow_transitions").select("*").eq("workflow_id", workflowId).eq("from_node_id", fromNodeId).order("priority", { ascending: true });
   if (error) {
-    if (isMissingRelationError(error, "workflow_transitions")) return [];
+    if (isMissingRelationError2(error, "workflow_transitions")) return [];
     throw error;
   }
   return data || [];
@@ -19135,6 +19279,24 @@ var DEFAULT_STAGE_SEQUENCE = [
   "done"
 ];
 var STANDARD_STAGE_SEQUENCES = [DEFAULT_STAGE_SEQUENCE];
+function normalizeTicketType(value) {
+  if (typeof value !== "string") return "task";
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "spike" || normalized === "spikes") return "spike";
+  return "task";
+}
+function getTicketType(frontmatter, markdownBody) {
+  const typeKeys = ["ticket_type", "type", "issue_type", "kind"];
+  for (const key of typeKeys) {
+    if (normalizeTicketType(frontmatter[key]) === "spike") return "spike";
+  }
+  const titleMatch = markdownBody.match(/^#\s+(.+)$/m);
+  const title = titleMatch?.[1]?.trim().toLowerCase() || "";
+  if (title.startsWith("spike:") || title.startsWith("[spike]")) {
+    return "spike";
+  }
+  return "task";
+}
 function getNextStage(currentStage, ticketType) {
   if (ticketType === "spike") {
     if (currentStage === "ideation") return "planning";
@@ -19334,6 +19496,131 @@ ${stringifyFrontmatter(frontmatter)}
 ${body}`;
 }
 
+// ../agx-cloud/lib/dependency-manager.ts
+var READY_STATUS = "completed";
+function describeDependency2(dep) {
+  return dep.title || dep.slug || dep.id || "(unknown)";
+}
+function summarizeRecord(record, id) {
+  if (!record) {
+    return { id: id || "" };
+  }
+  return {
+    id: record.id || id || "",
+    title: record.title || void 0,
+    slug: record.slug || void 0,
+    status: record.status,
+    stage: record.stage
+  };
+}
+async function fetchTasksByIds(ids, userId) {
+  if (!ids.length) return [];
+  const db = createAdminDbClient();
+  let query = db.from("tasks").select("id, title, slug, status, stage").in("id", ids);
+  if (userId) {
+    query = query.eq("user_id", userId);
+  }
+  const { data } = await query;
+  const map = /* @__PURE__ */ new Map();
+  if (Array.isArray(data)) {
+    for (const row of data) {
+      if (row && row.id) {
+        map.set(row.id, summarizeRecord(row, row.id));
+      }
+    }
+  }
+  return ids.map((id) => map.get(id) || { id });
+}
+function formatMissingDependencies(missing) {
+  if (!missing.length) return "";
+  const maxItems = 3;
+  const entries = missing.slice(0, maxItems).map((dep) => {
+    const label = describeDependency2(dep);
+    const suffix = dep.status ? ` (${dep.status})` : "";
+    return `${label}${suffix}`;
+  });
+  let message = `Waiting on dependencies: ${entries.join(", ")}`;
+  if (missing.length > maxItems) {
+    message += ` +${missing.length - maxItems} more`;
+  }
+  return message;
+}
+async function getMissingDependencies(task, userId) {
+  const dependsOn = Array.isArray(task.depends_on) ? task.depends_on : [];
+  if (!dependsOn.length) return [];
+  const records = await fetchTasksByIds(dependsOn, userId);
+  return records.filter((dep) => (dep.status || "") !== READY_STATUS);
+}
+async function attemptStartTask(taskId, userId, options) {
+  const resolvedUserId = userId || LOCAL_USER.id;
+  const task = await getTask(taskId, resolvedUserId);
+  if (!task) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  const missingDependencies = await getMissingDependencies(task, resolvedUserId);
+  if (missingDependencies.length) {
+    const reason = formatMissingDependencies(missingDependencies);
+    const adminDb2 = createAdminDbClient();
+    const { error: error2 } = await adminDb2.from("tasks").update({
+      status: "blocked",
+      blocked_reason: reason,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).eq("id", taskId);
+    if (error2 && error2.code !== "42703") {
+      throw error2;
+    }
+    return {
+      started: false,
+      missingDependencies,
+      blockedReason: reason
+    };
+  }
+  if (!options?.force && task.status === "queued" && !task.blocked_reason) {
+    return {
+      started: false,
+      missingDependencies: [],
+      alreadyQueued: true
+    };
+  }
+  const { frontmatter, body } = parseFrontmatter(task.content || "");
+  const ticketType = options?.ticketType ?? getTicketType(frontmatter, body);
+  const boss2 = await getBoss();
+  const jobId = await boss2.send(QUEUE_NAMES.TASK_PROCESS, {
+    taskId,
+    userId: resolvedUserId,
+    signal: "start",
+    ticketType
+  });
+  const adminDb = createAdminDbClient();
+  const { error } = await adminDb.from("tasks").update({
+    status: "queued",
+    blocked_reason: null,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).eq("id", taskId);
+  if (error && error.code !== "42703") {
+    throw error;
+  }
+  return {
+    started: Boolean(jobId),
+    jobId,
+    missingDependencies: [],
+    ticketType
+  };
+}
+async function triggerDependentTasks(taskId, userId) {
+  const resolvedUserId = userId || LOCAL_USER.id;
+  const db = createAdminDbClient();
+  let query = db.from("tasks").select("id").contains("depends_on", [taskId]);
+  if (userId) {
+    query = query.eq("user_id", userId);
+  }
+  const { data } = await query;
+  if (!Array.isArray(data) || !data.length) return;
+  await Promise.all(
+    data.map((row) => row?.id).filter(Boolean).map((dependentId) => attemptStartTask(dependentId, resolvedUserId))
+  );
+}
+
 // ../agx-cloud/lib/orchestrator/activities.ts
 function isMissingStageDecisionsError(error) {
   if (!error || typeof error !== "object") return false;
@@ -19375,6 +19662,15 @@ async function applyStageTransitionActivity(input) {
   if (!task) {
     throw new Error(`Task ${input.taskId} not found`);
   }
+  const previousStage = task.stage || null;
+  const eventTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const baseNotification = {
+    taskId: input.taskId,
+    userId: input.userId,
+    title: task.title || null,
+    slug: task.slug || null,
+    timestamp: eventTimestamp
+  };
   const { frontmatter, body } = parseFrontmatter(task.content);
   frontmatter.stage = input.nextStage;
   frontmatter.status = input.nextStatus;
@@ -19395,6 +19691,43 @@ async function applyStageTransitionActivity(input) {
   }).eq("id", input.taskId).eq("user_id", input.userId);
   if (input.nextStatus === "completed") {
     await db.from("tasks").update({ completed_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", input.taskId).eq("user_id", input.userId);
+    await triggerDependentTasks(input.taskId, input.userId);
+  }
+  const shouldEmitStageComplete = input.nextStatus !== "blocked" && input.nextStatus !== "failed";
+  if (shouldEmitStageComplete) {
+    void notifyTaskEvent({
+      ...baseNotification,
+      eventType: "task.stage_complete",
+      stage: previousStage,
+      previousStage,
+      nextStage: input.nextStage,
+      status: input.nextStatus,
+      details: { nextStatus: input.nextStatus }
+    });
+  }
+  if (input.nextStatus === "completed") {
+    void notifyTaskEvent({
+      ...baseNotification,
+      eventType: "task.completed",
+      stage: input.nextStage,
+      status: input.nextStatus,
+      details: {
+        previousStage,
+        nextStage: input.nextStage
+      }
+    });
+  }
+  if (input.nextStatus === "failed") {
+    void notifyTaskEvent({
+      ...baseNotification,
+      eventType: "task.failed",
+      stage: input.nextStage,
+      status: input.nextStatus,
+      error: input.error,
+      details: {
+        previousStage
+      }
+    });
   }
 }
 async function appendTaskLogActivity(input) {
@@ -19418,6 +19751,20 @@ async function markCancelledActivity(input) {
     error: input.reason || "Cancelled",
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   }).eq("id", input.taskId).eq("user_id", input.userId);
+  void notifyTaskEvent({
+    taskId: input.taskId,
+    userId: input.userId,
+    eventType: "task.failed",
+    title: task.title || null,
+    slug: task.slug || null,
+    stage: task.stage || null,
+    status: "failed",
+    error: input.reason || "Cancelled",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    details: {
+      previousStage: task.stage || null
+    }
+  });
 }
 
 // ../agx-cloud/lib/orchestrator/processor.ts