@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/tests/slack-blocks.test.ts

@@ -0,0 +1,246 @@
+import { describe, expect, test } from "bun:test";
+import {
+  buildAssignmentSummaryBlocks,
+  buildBufferFlushBlocks,
+  buildCancelledBlocks,
+  buildCompletedBlocks,
+  buildFailedBlocks,
+  buildProgressBlocks,
+  getTaskLink,
+  getTaskUrl,
+  markdownToSlack,
+} from "../slack/blocks";
+
+describe("markdownToSlack", () => {
+  test("converts bold correctly without italic interference", () => {
+    // **hello** → *hello* (Slack bold)
+    expect(markdownToSlack("**hello**")).toBe("*hello*");
+    expect(markdownToSlack("**hello world**")).toBe("*hello world*");
+  });
+
+  test("converts italic", () => {
+    expect(markdownToSlack("*hello*")).toBe("_hello_");
+  });
+
+  test("converts strikethrough", () => {
+    expect(markdownToSlack("~~hello~~")).toBe("~hello~");
+  });
+
+  test("converts links", () => {
+    expect(markdownToSlack("[click](https://example.com)")).toBe("<https://example.com|click>");
+  });
+
+  test("converts headers to bold", () => {
+    // ## Header → *Header* (Slack bold)
+    expect(markdownToSlack("## Header")).toBe("*Header*");
+  });
+
+  test("collapses excessive blank lines", () => {
+    expect(markdownToSlack("a\n\n\n\nb")).toBe("a\n\nb");
+  });
+});
+
+describe("getTaskLink", () => {
+  test("returns short ID when no APP_URL", () => {
+    // APP_URL is not set in test env
+    const link = getTaskLink("abcdef12-3456-7890-abcd-ef1234567890");
+    expect(link).toContain("abcdef12");
+  });
+});
+
+describe("getTaskUrl", () => {
+  test("returns URL with task ID or empty string", () => {
+    const url = getTaskUrl("some-id");
+    // When APP_URL is set, URL contains the task ID; when not set, returns ""
+    if (url) {
+      expect(url).toContain("some-id");
+    } else {
+      expect(url).toBe("");
+    }
+  });
+});
+
+describe("buildCompletedBlocks", () => {
+  test("returns single-line header + body section", () => {
+    const blocks = buildCompletedBlocks({
+      agentName: "Alpha",
+      taskId: "abcdef12-3456-7890-abcd-ef1234567890",
+      body: "Task output here",
+    });
+
+    expect(blocks.length).toBe(2);
+    // First block: single-line with emoji, agent name, task link
+    expect(blocks[0].type).toBe("section");
+    expect(blocks[0].text.text).toContain("✅");
+    expect(blocks[0].text.text).toContain("Alpha");
+    expect(blocks[0].text.text).toContain("abcdef12");
+    // Second block: body content
+    expect(blocks[1].type).toBe("section");
+    expect(blocks[1].text.text).toBe("Task output here");
+  });
+
+  test("includes duration when provided", () => {
+    const blocks = buildCompletedBlocks({
+      agentName: "Alpha",
+      taskId: "abcdef12-3456-7890-abcd-ef1234567890",
+      body: "Done",
+      duration: "45s",
+    });
+
+    expect(blocks[0].text.text).toContain("45s");
+  });
+
+  test("splits long body into multiple sections", () => {
+    const longBody = "x".repeat(6000);
+    const blocks = buildCompletedBlocks({
+      agentName: "Alpha",
+      taskId: "abcdef12-3456-7890-abcd-ef1234567890",
+      body: longBody,
+    });
+
+    // 1 header line + N body sections
+    expect(blocks.length).toBeGreaterThanOrEqual(3);
+    const bodySections = blocks.slice(1);
+    expect(bodySections.length).toBeGreaterThanOrEqual(2);
+    const totalText = bodySections.map((s) => s.text.text).join("");
+    expect(totalText).toBe(longBody);
+  });
+});
+
+describe("buildFailedBlocks", () => {
+  test("returns single-line header + error section", () => {
+    const blocks = buildFailedBlocks({
+      agentName: "Beta",
+      taskId: "12345678-abcd-ef12-3456-7890abcdef12",
+      reason: "Something broke",
+    });
+
+    expect(blocks.length).toBe(2);
+    expect(blocks[0].type).toBe("section");
+    expect(blocks[0].text.text).toContain("❌");
+    expect(blocks[0].text.text).toContain("Beta");
+    expect(blocks[0].text.text).toContain("12345678");
+    expect(blocks[1].type).toBe("section");
+    expect(blocks[1].text.text).toContain("Something broke");
+  });
+
+  test("includes duration when provided", () => {
+    const blocks = buildFailedBlocks({
+      agentName: "Beta",
+      taskId: "12345678-abcd-ef12-3456-7890abcdef12",
+      reason: "Error",
+      duration: "2m 30s",
+    });
+
+    expect(blocks[0].text.text).toContain("2m 30s");
+  });
+});
+
+describe("buildProgressBlocks", () => {
+  test("returns single-line section + cancel action", () => {
+    const blocks = buildProgressBlocks({
+      agentName: "Gamma",
+      taskId: "aabbccdd-1234-5678-9012-abcdefabcdef",
+      progress: "Analyzing codebase...",
+    });
+
+    expect(blocks.length).toBe(2);
+    // Single line: ⏳ *Gamma* (`aabbccdd`): Analyzing codebase...
+    expect(blocks[0].type).toBe("section");
+    expect(blocks[0].text.text).toContain("⏳");
+    expect(blocks[0].text.text).toContain("Gamma");
+    expect(blocks[0].text.text).toContain("aabbccdd");
+    expect(blocks[0].text.text).toContain("Analyzing codebase...");
+    // Cancel button
+    expect(blocks[1].type).toBe("actions");
+    expect(blocks[1].elements[0].action_id).toBe("cancel_task");
+    expect(blocks[1].elements[0].style).toBe("danger");
+    expect(blocks[1].elements[0].confirm).toBeDefined();
+  });
+});
+
+describe("buildAssignmentSummaryBlocks", () => {
+  test("single assigned task — one-line format", () => {
+    const blocks = buildAssignmentSummaryBlocks({
+      assigned: [{ agentName: "Alpha", taskId: "aabb1122-0000-0000-0000-000000000000" }],
+      queued: [],
+      failed: [],
+    });
+
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].type).toBe("section");
+    expect(blocks[0].text.text).toContain("📡 Task assigned to:");
+    expect(blocks[0].text.text).toContain("Alpha");
+    expect(blocks[0].text.text).toContain("aabb1122");
+  });
+
+  test("mixed assigned, queued, and failed", () => {
+    const blocks = buildAssignmentSummaryBlocks({
+      assigned: [{ agentName: "Alpha", taskId: "aaaa0000-0000-0000-0000-000000000000" }],
+      queued: [{ agentName: "Beta", taskId: "bbbb0000-0000-0000-0000-000000000000" }],
+      failed: [{ agentName: "Gamma", reason: "offline" }],
+    });
+
+    expect(blocks.length).toBe(1);
+    const text = blocks[0].text.text;
+    expect(text).toContain("Task assigned to:");
+    expect(text).toContain("Alpha");
+    expect(text).toContain("Task queued for:");
+    expect(text).toContain("Beta");
+    expect(text).toContain("Could not assign to:");
+    expect(text).toContain("Gamma");
+    expect(text).toContain("offline");
+  });
+
+  test("all failed shows warning", () => {
+    const blocks = buildAssignmentSummaryBlocks({
+      assigned: [],
+      queued: [],
+      failed: [{ agentName: "Delta", reason: "error" }],
+    });
+
+    expect(blocks[0].text.text).toContain("⚠️");
+    expect(blocks[0].text.text).toContain("Could not assign");
+  });
+});
+
+describe("buildCancelledBlocks", () => {
+  test("returns single section block", () => {
+    const blocks = buildCancelledBlocks({
+      agentName: "Alpha",
+      taskId: "cccc0000-0000-0000-0000-000000000000",
+    });
+
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].type).toBe("section");
+    expect(blocks[0].text.text).toContain("🚫");
+    expect(blocks[0].text.text).toContain("Alpha");
+    expect(blocks[0].text.text).toContain("Cancelled");
+    expect(blocks[0].text.text).toContain("cccc0000");
+  });
+});
+
+describe("buildBufferFlushBlocks", () => {
+  test("without dependency", () => {
+    const blocks = buildBufferFlushBlocks({
+      messageCount: 3,
+      taskId: "dddd0000-0000-0000-0000-000000000000",
+      hasDependency: false,
+    });
+
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].type).toBe("context");
+    expect(blocks[0].elements[0].text).toContain("3 follow-up");
+    expect(blocks[0].elements[0].text).toContain("batched into task");
+  });
+
+  test("with dependency", () => {
+    const blocks = buildBufferFlushBlocks({
+      messageCount: 2,
+      taskId: "eeee0000-0000-0000-0000-000000000000",
+      hasDependency: true,
+    });
+
+    expect(blocks[0].elements[0].text).toContain("queued pending");
+  });
+});

package/src/tests/slack-metadata-inheritance.test.ts

@@ -0,0 +1,243 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import { closeDb, createAgent, createTaskExtended, getDb, initDb } from "../be/db";
+
+const TEST_DB_PATH = "./test-slack-metadata-inheritance.sqlite";
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(() => {
+  closeDb();
+  try {
+    unlinkSync(TEST_DB_PATH);
+    unlinkSync(`${TEST_DB_PATH}-wal`);
+    unlinkSync(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore if files don't exist
+  }
+});
+
+/** Helper to set a task to in_progress status (simulates runner picking it up) */
+function setTaskInProgress(taskId: string): void {
+  getDb().run(
+    "UPDATE agent_tasks SET status = 'in_progress', lastUpdatedAt = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?",
+    [taskId],
+  );
+}
+
+describe("Slack metadata auto-inheritance via sourceTaskId", () => {
+  const lead = { name: "inherit-lead", isLead: true, status: "idle" as const, capabilities: [] };
+  const worker = {
+    name: "inherit-worker",
+    isLead: false,
+    status: "idle" as const,
+    capabilities: [],
+  };
+
+  let leadAgent: ReturnType<typeof createAgent>;
+  let workerAgent: ReturnType<typeof createAgent>;
+
+  beforeAll(() => {
+    leadAgent = createAgent(lead);
+    workerAgent = createAgent(worker);
+  });
+
+  test("sourceTaskId provided → inherits from that task's Slack metadata", () => {
+    // Lead has an in-progress task with Slack metadata
+    const leadTask = createTaskExtended("lead task with slack", {
+      agentId: leadAgent.id,
+      slackChannelId: "C_SOURCE",
+      slackThreadTs: "1000.0001",
+      slackUserId: "U_TARAS",
+    });
+    setTaskInProgress(leadTask.id);
+
+    // Create a child task using sourceTaskId
+    const childTask = createTaskExtended("child task", {
+      agentId: workerAgent.id,
+      creatorAgentId: leadAgent.id,
+      sourceTaskId: leadTask.id,
+    });
+
+    expect(childTask.slackChannelId).toBe("C_SOURCE");
+    expect(childTask.slackThreadTs).toBe("1000.0001");
+    expect(childTask.slackUserId).toBe("U_TARAS");
+  });
+
+  test("sourceTaskId picks the correct task even with multiple in-progress tasks", () => {
+    // Lead has TWO in-progress tasks with different Slack metadata
+    const taskA = createTaskExtended("lead task A", {
+      agentId: leadAgent.id,
+      slackChannelId: "C_TASK_A",
+      slackThreadTs: "2000.0001",
+      slackUserId: "U_USER_A",
+    });
+    setTaskInProgress(taskA.id);
+
+    const taskB = createTaskExtended("lead task B", {
+      agentId: leadAgent.id,
+      slackChannelId: "C_TASK_B",
+      slackThreadTs: "3000.0001",
+      slackUserId: "U_USER_B",
+    });
+    setTaskInProgress(taskB.id);
+
+    // sourceTaskId = taskA → should inherit from A, not B (which is more recent)
+    const childFromA = createTaskExtended("child from A", {
+      agentId: workerAgent.id,
+      creatorAgentId: leadAgent.id,
+      sourceTaskId: taskA.id,
+    });
+
+    expect(childFromA.slackChannelId).toBe("C_TASK_A");
+    expect(childFromA.slackThreadTs).toBe("2000.0001");
+    expect(childFromA.slackUserId).toBe("U_USER_A");
+  });
+
+  test("sourceTaskId not provided → no inheritance (no heuristic fallback)", () => {
+    // Create a fresh agent to avoid interference from other tests
+    const freshLead = createAgent({
+      name: "fallback-lead",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const leadTask = createTaskExtended("fallback lead task", {
+      agentId: freshLead.id,
+      slackChannelId: "C_FALLBACK",
+      slackThreadTs: "4000.0001",
+      slackUserId: "U_FALLBACK",
+    });
+    setTaskInProgress(leadTask.id);
+
+    // No sourceTaskId → no inheritance (adapters must provide sourceTaskId deterministically)
+    const childTask = createTaskExtended("child no sourceTaskId", {
+      agentId: workerAgent.id,
+      creatorAgentId: freshLead.id,
+    });
+
+    expect(childTask.slackChannelId).toBeFalsy();
+    expect(childTask.slackThreadTs).toBeFalsy();
+    expect(childTask.slackUserId).toBeFalsy();
+  });
+
+  test("explicit Slack params take priority over sourceTaskId inheritance", () => {
+    const leadTask = createTaskExtended("lead explicit test", {
+      agentId: leadAgent.id,
+      slackChannelId: "C_LEAD_EXPLICIT",
+      slackThreadTs: "5000.0001",
+      slackUserId: "U_LEAD_EXPLICIT",
+    });
+    setTaskInProgress(leadTask.id);
+
+    // Explicit params should override sourceTaskId inheritance
+    const childTask = createTaskExtended("child explicit", {
+      agentId: workerAgent.id,
+      creatorAgentId: leadAgent.id,
+      sourceTaskId: leadTask.id,
+      slackChannelId: "C_EXPLICIT",
+      slackThreadTs: "6000.0001",
+      slackUserId: "U_EXPLICIT",
+    });
+
+    expect(childTask.slackChannelId).toBe("C_EXPLICIT");
+    expect(childTask.slackThreadTs).toBe("6000.0001");
+    expect(childTask.slackUserId).toBe("U_EXPLICIT");
+  });
+
+  test("parentTaskId inheritance takes priority over sourceTaskId", () => {
+    const parentTask = createTaskExtended("parent task", {
+      agentId: workerAgent.id,
+      slackChannelId: "C_PARENT",
+      slackThreadTs: "7000.0001",
+      slackUserId: "U_PARENT",
+    });
+
+    const leadTask = createTaskExtended("lead with different slack", {
+      agentId: leadAgent.id,
+      slackChannelId: "C_LEAD_DIFFERENT",
+      slackThreadTs: "8000.0001",
+      slackUserId: "U_LEAD_DIFFERENT",
+    });
+    setTaskInProgress(leadTask.id);
+
+    // parentTaskId sets Slack metadata first, so sourceTaskId doesn't override
+    const childTask = createTaskExtended("child with parent", {
+      agentId: workerAgent.id,
+      creatorAgentId: leadAgent.id,
+      sourceTaskId: leadTask.id,
+      parentTaskId: parentTask.id,
+    });
+
+    expect(childTask.slackChannelId).toBe("C_PARENT");
+    expect(childTask.slackThreadTs).toBe("7000.0001");
+    expect(childTask.slackUserId).toBe("U_PARENT");
+  });
+
+  test("no in-progress task and no sourceTaskId → no inheritance", () => {
+    const freshLead = createAgent({
+      name: "no-task-lead",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+
+    // No tasks for this agent at all
+    const childTask = createTaskExtended("orphan child", {
+      agentId: workerAgent.id,
+      creatorAgentId: freshLead.id,
+    });
+
+    expect(childTask.slackChannelId).toBeFalsy();
+    expect(childTask.slackThreadTs).toBeFalsy();
+    expect(childTask.slackUserId).toBeFalsy();
+  });
+
+  test("creator task has no Slack metadata → no inheritance", () => {
+    const leadTask = createTaskExtended("lead task no slack", {
+      agentId: leadAgent.id,
+      // No Slack metadata on this task
+    });
+    setTaskInProgress(leadTask.id);
+
+    const childTask = createTaskExtended("child no slack inherit", {
+      agentId: workerAgent.id,
+      creatorAgentId: leadAgent.id,
+      sourceTaskId: leadTask.id,
+    });
+
+    expect(childTask.slackChannelId).toBeFalsy();
+    expect(childTask.slackThreadTs).toBeFalsy();
+    expect(childTask.slackUserId).toBeFalsy();
+  });
+
+  test("sourceTaskId pointing to non-existent task → no inheritance (no heuristic fallback)", () => {
+    const freshLead = createAgent({
+      name: "nonexist-lead",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const leadTask = createTaskExtended("fallback task for nonexist", {
+      agentId: freshLead.id,
+      slackChannelId: "C_NONEXIST_FALLBACK",
+      slackThreadTs: "9000.0001",
+      slackUserId: "U_NONEXIST",
+    });
+    setTaskInProgress(leadTask.id);
+
+    const childTask = createTaskExtended("child with bad sourceTaskId", {
+      agentId: workerAgent.id,
+      creatorAgentId: freshLead.id,
+      sourceTaskId: "00000000-0000-0000-0000-000000000000", // non-existent
+    });
+
+    // No fallback — sourceTaskId is the only path, and it points to a non-existent task
+    expect(childTask.slackChannelId).toBeFalsy();
+    expect(childTask.slackThreadTs).toBeFalsy();
+  });
+});

package/src/tests/slack-queue-offline.test.ts

@@ -0,0 +1,174 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getLeadAgent,
+  getTasksByAgentId,
+  getTasksByStatus,
+  initDb,
+} from "../be/db";
+import { extractTaskFromMessage, routeMessage } from "../slack/router";
+
+const TEST_DB_PATH = "./test-slack-queue-offline.sqlite";
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(() => {
+  closeDb();
+  try {
+    unlinkSync(TEST_DB_PATH);
+    unlinkSync(`${TEST_DB_PATH}-wal`);
+    unlinkSync(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore if files don't exist
+  }
+});
+
+describe("Slack queue-when-offline", () => {
+  describe("routeMessage returns empty when all agents are offline", () => {
+    test("returns no matches when only offline agents exist", () => {
+      createAgent({ name: "offline-worker", isLead: false, status: "offline", capabilities: [] });
+
+      const matches = routeMessage("Hello <@BOT123>", "BOT123", true);
+      expect(matches).toHaveLength(0);
+    });
+
+    test("returns no matches when offline lead exists", () => {
+      createAgent({ name: "offline-lead", isLead: true, status: "offline", capabilities: [] });
+
+      const matches = routeMessage("<@BOT123> do something", "BOT123", true);
+      expect(matches).toHaveLength(0);
+    });
+  });
+
+  describe("getLeadAgent finds lead regardless of status", () => {
+    test("returns offline lead agent", () => {
+      const lead = getLeadAgent();
+      expect(lead).not.toBeNull();
+      expect(lead!.isLead).toBe(true);
+      // The lead we created above is offline — getLeadAgent should still find it
+      expect(lead!.status).toBe("offline");
+    });
+  });
+
+  describe("queue as task when offline lead exists", () => {
+    test("creates task for offline lead with correct metadata", () => {
+      const lead = getLeadAgent()!;
+      const taskDescription = "deploy the new feature";
+
+      const task = createTaskExtended(taskDescription, {
+        agentId: lead.id,
+        source: "slack",
+        slackChannelId: "C999",
+        slackThreadTs: "1111.2222",
+        slackUserId: "U_HUMAN",
+      });
+
+      expect(task.agentId).toBe(lead.id);
+      expect(task.task).toBe(taskDescription);
+      expect(task.source).toBe("slack");
+      expect(task.slackChannelId).toBe("C999");
+      expect(task.slackThreadTs).toBe("1111.2222");
+      expect(task.slackUserId).toBe("U_HUMAN");
+      expect(task.status).toBe("pending");
+    });
+
+    test("queued task appears in lead's task list", () => {
+      const lead = getLeadAgent()!;
+      const tasks = getTasksByAgentId(lead.id);
+      expect(tasks.length).toBeGreaterThanOrEqual(1);
+
+      const queued = tasks.find((t) => t.task === "deploy the new feature");
+      expect(queued).toBeDefined();
+      expect(queued!.source).toBe("slack");
+    });
+
+    test("creates task with thread context", () => {
+      const lead = getLeadAgent()!;
+      const threadContext = "Alice: something is broken\n[Agent]: I'll look into it";
+      const taskDescription = "check the logs";
+      const fullTaskDescription = `<thread_context>\n${threadContext}\n</thread_context>\n\n${taskDescription}`;
+
+      const task = createTaskExtended(fullTaskDescription, {
+        agentId: lead.id,
+        source: "slack",
+        slackChannelId: "C888",
+        slackThreadTs: "3333.4444",
+        slackUserId: "U_HUMAN2",
+      });
+
+      expect(task.task).toContain("<thread_context>");
+      expect(task.task).toContain("check the logs");
+      expect(task.task).toContain("Alice: something is broken");
+    });
+  });
+
+  describe("queue as unassigned task when no lead exists at all", () => {
+    test("creates unassigned task with Slack metadata", () => {
+      const taskText = "fix the CI pipeline";
+
+      const task = createTaskExtended(taskText, {
+        source: "slack",
+        slackChannelId: "C777",
+        slackThreadTs: "5555.6666",
+        slackUserId: "U_HUMAN3",
+      });
+
+      expect(task.task).toBe(taskText);
+      expect(task.status).toBe("unassigned");
+      expect(task.agentId).toBeNull();
+      expect(task.source).toBe("slack");
+      expect(task.slackChannelId).toBe("C777");
+      expect(task.slackThreadTs).toBe("5555.6666");
+      expect(task.slackUserId).toBe("U_HUMAN3");
+    });
+
+    test("unassigned task appears in unassigned status query", () => {
+      const unassigned = getTasksByStatus("unassigned");
+      const queued = unassigned.find((t) => t.task === "fix the CI pipeline");
+      expect(queued).toBeDefined();
+      expect(queued!.slackChannelId).toBe("C777");
+    });
+
+    test("creates task with thread context in fullTaskDescription format", () => {
+      const threadContext = "Bob: deploy broke\n[Agent]: checking";
+      const taskDescription = "investigate the deploy failure";
+      const fullTaskDescription = `<thread_context>\n${threadContext}\n</thread_context>\n\n${taskDescription}`;
+
+      const task = createTaskExtended(fullTaskDescription, {
+        source: "slack",
+        slackChannelId: "C666",
+        slackThreadTs: "7777.8888",
+        slackUserId: "U_HUMAN4",
+      });
+
+      expect(task.task).toContain("<thread_context>");
+      expect(task.task).toContain("Bob: deploy broke");
+      expect(task.task).toContain("investigate the deploy failure");
+    });
+  });
+
+  describe("extractTaskFromMessage", () => {
+    test("strips bot mention and returns task text", () => {
+      const result = extractTaskFromMessage("<@BOT123> deploy the app", "BOT123");
+      expect(result).toBe("deploy the app");
+    });
+
+    test("returns empty string for mention-only messages", () => {
+      const result = extractTaskFromMessage("<@BOT123>", "BOT123");
+      expect(result).toBe("");
+    });
+
+    test("strips swarm# references too", () => {
+      const result = extractTaskFromMessage(
+        "<@BOT123> swarm#all do something swarm#00000000-0000-0000-0000-000000000000",
+        "BOT123",
+      );
+      expect(result).toBe("do something");
+    });
+  });
+});