@bastani/atomic 0.6.8 → 0.7.0-2

package/src/commands/cli/workflow-list.test.ts

@@ -1,235 +0,0 @@
-/**
- * Unit tests for `atomic workflow list` — the subcommand that replaced
- * the old dispatcher `-l/--list` flag.
- *
- * The command itself is thin; these tests cover the behaviors that
- * would silently break if the filter logic regressed: agent filtering,
- * empty results, unknown agent rejection, and the sort order that
- * keeps output stable across runs.
- */
-
-import { describe, test, expect, beforeAll, beforeEach, afterAll, afterEach, mock } from "bun:test";
-import { workflowListCommand } from "./workflow-list.ts";
-import type { AgentType, WorkflowDefinition } from "../../sdk/workflows/index.ts";
-
-function def(agent: AgentType, name: string, description = ""): WorkflowDefinition {
-  return {
-    __brand: "WorkflowDefinition",
-    agent,
-    name,
-    description,
-    inputs: [],
-    minSDKVersion: null,
-    source: import.meta.path,
-    run: async () => {},
-  } as unknown as WorkflowDefinition;
-}
-
-let originalNoColor: string | undefined;
-beforeAll(() => {
-  originalNoColor = process.env.NO_COLOR;
-  process.env.NO_COLOR = "1";
-});
-afterAll(() => {
-  if (originalNoColor === undefined) delete process.env.NO_COLOR;
-  else process.env.NO_COLOR = originalNoColor;
-});
-
-interface Captured {
-  stdout: string;
-  stderr: string;
-  restore: () => void;
-}
-
-function captureOutput(): Captured {
-  const captured: Captured = { stdout: "", stderr: "", restore: () => {} };
-  const origStdout = process.stdout.write.bind(process.stdout);
-  const origStderr = process.stderr.write.bind(process.stderr);
-  process.stdout.write = ((chunk: string | Uint8Array): boolean => {
-    captured.stdout += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
-    return true;
-  }) as typeof process.stdout.write;
-  process.stderr.write = ((chunk: string | Uint8Array): boolean => {
-    captured.stderr += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
-    return true;
-  }) as typeof process.stderr.write;
-  captured.restore = () => {
-    process.stdout.write = origStdout;
-    process.stderr.write = origStderr;
-  };
-  return captured;
-}
-
-const fixture = [
-  def("claude", "ralph", "iterative plan/orchestrate/review/debug loop"),
-  def("copilot", "ralph", "iterative plan/orchestrate/review/debug loop"),
-  def("opencode", "ralph", "iterative plan/orchestrate/review/debug loop"),
-  def("claude", "deep-research-codebase", "scout -> explorer fan-out"),
-  def("copilot", "deep-research-codebase", "scout -> explorer fan-out"),
-  def("opencode", "deep-research-codebase", "scout -> explorer fan-out"),
-  def("claude", "open-claude-design", "design system onboarding"),
-  def("copilot", "open-claude-design", "design system onboarding"),
-  def("opencode", "open-claude-design", "design system onboarding"),
-];
-
-let savedNoColor: string | undefined;
-beforeEach(() => {
-  savedNoColor = process.env.NO_COLOR;
-  process.env.NO_COLOR = "1";
-});
-afterEach(() => {
-  if (savedNoColor === undefined) delete process.env.NO_COLOR;
-  else process.env.NO_COLOR = savedNoColor;
-});
-
-describe("workflowListCommand", () => {
-  test("no agent filter: prints every registered workflow, grouped by name", async () => {
-    const cap = captureOutput();
-    let code: number;
-    try {
-      code = await workflowListCommand({}, { list: () => fixture });
-    } finally {
-      cap.restore();
-    }
-    expect(code).toBe(0);
-    expect(cap.stdout).toContain("ralph");
-    expect(cap.stdout).toContain("deep-research-codebase");
-    expect(cap.stdout).toContain("open-claude-design");
-    // Grouping deduplicates identical (name, description) pairs, so each
-    // workflow name appears exactly once.
-    expect(cap.stdout.match(/\bralph\b/g)?.length).toBe(1);
-    // Agents are rendered as a badge line under each group.
-    expect(cap.stdout).toContain("claude");
-    expect(cap.stdout).toContain("copilot");
-    expect(cap.stdout).toContain("opencode");
-    expect(cap.stdout).toContain(" · ");
-    // The old `agent=<name>` label is gone — grouping replaces it.
-    expect(cap.stdout).not.toContain("agent=");
-  });
-
-  test("agent filter narrows to the selected agent only", async () => {
-    const cap = captureOutput();
-    let code: number;
-    try {
-      code = await workflowListCommand({ agent: "claude" }, { list: () => fixture });
-    } finally {
-      cap.restore();
-    }
-    expect(code).toBe(0);
-    // Every workflow with a claude variant appears.
-    expect(cap.stdout).toContain("ralph");
-    expect(cap.stdout).toContain("deep-research-codebase");
-    expect(cap.stdout).toContain("open-claude-design");
-    // Non-matching agents should not appear in the listing. We check for
-    // the agent-badge separator, not the strings themselves — a workflow
-    // named "open-claude-design" legitimately contains the token
-    // "claude" outside the badge list.
-    expect(cap.stdout).not.toContain("copilot");
-    expect(cap.stdout).not.toContain("opencode");
-    // Filtered output suppresses the agent-badge line entirely, since
-    // the filter itself provides the context.
-    expect(cap.stdout).not.toContain(" · ");
-  });
-
-  test("unknown agent returns non-zero and writes an error message", async () => {
-    const cap = captureOutput();
-    let code: number;
-    try {
-      code = await workflowListCommand({ agent: "bogus" }, { list: () => fixture });
-    } finally {
-      cap.restore();
-    }
-    expect(code).toBe(1);
-    expect(cap.stderr).toContain("Unknown agent 'bogus'");
-  });
-
-  test("empty registry prints a helpful placeholder", async () => {
-    const cap = captureOutput();
-    let code: number;
-    try {
-      code = await workflowListCommand({}, { list: () => [] });
-    } finally {
-      cap.restore();
-    }
-    expect(code).toBe(0);
-    expect(cap.stdout).toContain("No workflows registered.");
-  });
-
-  test("agent filter with zero matches prints the placeholder, not an error", async () => {
-    const cap = captureOutput();
-    let code: number;
-    try {
-      code = await workflowListCommand(
-        { agent: "opencode" },
-        { list: () => [def("claude", "ralph")] },
-      );
-    } finally {
-      cap.restore();
-    }
-    expect(code).toBe(0);
-    expect(cap.stdout).toContain("No workflows registered.");
-  });
-
-  test("groups are sorted alphabetically by workflow name", async () => {
-    const shuffled = [
-      def("opencode", "ralph"),
-      def("claude", "deep-research-codebase"),
-      def("claude", "ralph"),
-      def("copilot", "ralph"),
-    ];
-    const cap = captureOutput();
-    try {
-      await workflowListCommand({}, { list: () => shuffled });
-    } finally {
-      cap.restore();
-    }
-    const deepIdx = cap.stdout.indexOf("deep-research-codebase");
-    const ralphIdx = cap.stdout.indexOf("ralph");
-    expect(deepIdx).toBeGreaterThan(-1);
-    expect(ralphIdx).toBeGreaterThan(deepIdx);
-  });
-
-  test("agents within a group are sorted alphabetically", async () => {
-    const shuffled = [
-      def("opencode", "ralph", "plan"),
-      def("claude", "ralph", "plan"),
-      def("copilot", "ralph", "plan"),
-    ];
-    const cap = captureOutput();
-    try {
-      await workflowListCommand({}, { list: () => shuffled });
-    } finally {
-      cap.restore();
-    }
-    const claudeIdx = cap.stdout.indexOf("claude");
-    const copilotIdx = cap.stdout.indexOf("copilot");
-    const opencodeIdx = cap.stdout.indexOf("opencode");
-    expect(claudeIdx).toBeGreaterThan(-1);
-    expect(claudeIdx).toBeLessThan(copilotIdx);
-    expect(copilotIdx).toBeLessThan(opencodeIdx);
-  });
-
-  test("variants with differing descriptions print as separate groups", async () => {
-    // Two variants of `ralph` with different descriptions — the grouping
-    // should keep them separate so no information is lost, instead of
-    // silently collapsing to one arbitrary description.
-    const entries = [
-      def("claude", "ralph", "plan version A"),
-      def("copilot", "ralph", "plan version B"),
-    ];
-    const cap = captureOutput();
-    try {
-      await workflowListCommand({}, { list: () => entries });
-    } finally {
-      cap.restore();
-    }
-    expect(cap.stdout).toContain("plan version A");
-    expect(cap.stdout).toContain("plan version B");
-    // Two separate groups means "ralph" appears as a heading twice.
-    expect(cap.stdout.match(/\bralph\b/g)?.length).toBe(2);
-  });
-});
-
-// mock import kept at module scope to match the lint pattern used by
-// other test files — suppresses an unused-import warning if any.
-void mock;

package/src/commands/cli/workflow-status.test.ts

@@ -1,451 +0,0 @@
-/**
- * Tests for `atomic workflow status` — covers the dependency-injected
- * command shape end-to-end with no real tmux server, no real
- * filesystem outside a temp dir, and JSON output capture so assertions
- * can run on parsed objects.
- */
-
-import { describe, test, expect, beforeAll, afterAll, beforeEach, mock } from "bun:test";
-import { mkdtemp, mkdir, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { workflowStatusCommand, type StatusDeps } from "./workflow-status.ts";
-import {
-  buildSnapshot,
-  writeSnapshot,
-  type WorkflowStatusSnapshot,
-} from "../../sdk/runtime/status-writer.ts";
-import type { TmuxSession } from "../../sdk/runtime/tmux.ts";
-import type { SessionData } from "../../sdk/components/orchestrator-panel-types.ts";
-
-// ─── output capture ────────────────────────────────────────────────
-
-function captureStdout(): { read: () => string; restore: () => void } {
-  const chunks: string[] = [];
-  const orig = process.stdout.write;
-  process.stdout.write = ((c: string | Uint8Array) => {
-    chunks.push(typeof c === "string" ? c : new TextDecoder().decode(c));
-    return true;
-  }) as typeof process.stdout.write;
-  return {
-    read: () => chunks.join(""),
-    restore: () => {
-      process.stdout.write = orig;
-    },
-  };
-}
-
-let originalNoColor: string | undefined;
-beforeAll(() => {
-  originalNoColor = process.env.NO_COLOR;
-  process.env.NO_COLOR = "1";
-});
-afterAll(() => {
-  if (originalNoColor === undefined) delete process.env.NO_COLOR;
-  else process.env.NO_COLOR = originalNoColor;
-});
-
-function tmuxSession(name: string): TmuxSession {
-  return {
-    name,
-    windows: 1,
-    created: new Date().toISOString(),
-    attached: false,
-    type: "workflow",
-    agent: "claude",
-  };
-}
-
-function panelSession(
-  name: string,
-  status: SessionData["status"],
-  extra: Partial<SessionData> = {},
-): SessionData {
-  return {
-    name,
-    status,
-    parents: [],
-    startedAt: 1000,
-    endedAt: null,
-    ...extra,
-  };
-}
-
-function snapshotOf(
-  workflowName: string,
-  agent: string,
-  sessions: SessionData[],
-  opts: { fatalError?: string | null; completionReached?: boolean } = {},
-): WorkflowStatusSnapshot {
-  return buildSnapshot({
-    workflowRunId: "abcd1234",
-    tmuxSession: `atomic-wf-${agent}-${workflowName}-abcd1234`,
-    workflowName,
-    agent,
-    prompt: "",
-    fatalError: opts.fatalError ?? null,
-    completionReached: opts.completionReached ?? false,
-    sessions,
-  });
-}
-
-interface Mocks {
-  isTmuxInstalled: ReturnType<typeof mock>;
-  sessionExists: ReturnType<typeof mock>;
-  listSessions: ReturnType<typeof mock>;
-  readSnapshot: ReturnType<typeof mock>;
-}
-
-function makeDeps(sessionsBaseDir: string): { deps: StatusDeps; mocks: Mocks } {
-  const mocks: Mocks = {
-    isTmuxInstalled: mock(() => true),
-    sessionExists: mock(() => true),
-    listSessions: mock<() => TmuxSession[]>(() => []),
-    readSnapshot: mock(async () => null),
-  };
-  const deps: StatusDeps = {
-    isTmuxInstalled: mocks.isTmuxInstalled,
-    sessionExists: mocks.sessionExists,
-    listSessions: mocks.listSessions as unknown as StatusDeps["listSessions"],
-    readSnapshot: mocks.readSnapshot as unknown as StatusDeps["readSnapshot"],
-    sessionsBaseDir,
-  };
-  return { deps, mocks };
-}
-
-// ─── tests ─────────────────────────────────────────────────────────
-
-describe("workflowStatusCommand", () => {
-  let tmpDir = "";
-  beforeEach(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), "atomic-status-cmd-"));
-  });
-
-  test("prints empty list when no workflow sessions are running", async () => {
-    const { deps } = makeDeps(tmpDir);
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand({ format: "json" }, deps);
-      expect(code).toBe(0);
-      const parsed = JSON.parse(cap.read());
-      expect(parsed).toEqual({ workflows: [] });
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("derives 'in_progress' for an alive workflow with a running stage", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.listSessions.mockReturnValue([
-      tmuxSession("atomic-wf-claude-ralph-abcd1234"),
-    ]);
-    mocks.readSnapshot.mockResolvedValue(
-      snapshotOf("ralph", "claude", [panelSession("orchestrator", "running")]),
-    );
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand({ format: "json" }, deps);
-      expect(code).toBe(0);
-      const parsed = JSON.parse(cap.read());
-      expect(parsed.workflows).toHaveLength(1);
-      expect(parsed.workflows[0].overall).toBe("in_progress");
-      expect(parsed.workflows[0].alive).toBe(true);
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("returns 'needs_review' when any stage is awaiting input (HIL)", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.listSessions.mockReturnValue([
-      tmuxSession("atomic-wf-claude-ralph-abcd1234"),
-    ]);
-    mocks.readSnapshot.mockResolvedValue(
-      snapshotOf("ralph", "claude", [
-        panelSession("orchestrator", "running"),
-        panelSession("loop", "awaiting_input"),
-      ]),
-    );
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand(
-        { format: "json", id: "atomic-wf-claude-ralph-abcd1234" },
-        deps,
-      );
-      expect(code).toBe(0);
-      const parsed = JSON.parse(cap.read());
-      expect(parsed.overall).toBe("needs_review");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("returns 'completed' when completionReached and no errors", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.listSessions.mockReturnValue([
-      tmuxSession("atomic-wf-claude-ralph-abcd1234"),
-    ]);
-    mocks.readSnapshot.mockResolvedValue(
-      snapshotOf(
-        "ralph",
-        "claude",
-        [panelSession("orchestrator", "complete")],
-        { completionReached: true },
-      ),
-    );
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand(
-        { format: "json", id: "atomic-wf-claude-ralph-abcd1234" },
-        deps,
-      );
-      expect(code).toBe(0);
-      const parsed = JSON.parse(cap.read());
-      expect(parsed.overall).toBe("completed");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("returns 'error' when fatalError is present in the snapshot", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.listSessions.mockReturnValue([
-      tmuxSession("atomic-wf-claude-ralph-abcd1234"),
-    ]);
-    mocks.readSnapshot.mockResolvedValue(
-      snapshotOf("ralph", "claude", [panelSession("orchestrator", "running")], {
-        fatalError: "boom",
-      }),
-    );
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand(
-        { format: "json", id: "atomic-wf-claude-ralph-abcd1234" },
-        deps,
-      );
-      expect(code).toBe(0);
-      const parsed = JSON.parse(cap.read());
-      expect(parsed.overall).toBe("error");
-      expect(parsed.fatalError).toBe("boom");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("returns 1 with a JSON error envelope when the requested id is unknown", async () => {
-    const { deps } = makeDeps(tmpDir);
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand(
-        { format: "json", id: "atomic-wf-claude-ralph-deadbeef" },
-        deps,
-      );
-      expect(code).toBe(1);
-      const parsed = JSON.parse(cap.read());
-      expect(parsed.error).toContain("not found");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("falls back to a minimal report when the orchestrator hasn't written a snapshot yet", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.listSessions.mockReturnValue([
-      tmuxSession("atomic-wf-claude-ralph-abcd1234"),
-    ]);
-    mocks.readSnapshot.mockResolvedValue(null);
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand({ format: "json" }, deps);
-      expect(code).toBe(0);
-      const parsed = JSON.parse(cap.read());
-      expect(parsed.workflows).toHaveLength(1);
-      expect(parsed.workflows[0].overall).toBe("in_progress");
-      expect(parsed.workflows[0].workflowName).toBe("");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("recognises a stale snapshot as 'error' when the tmux session is gone", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.listSessions.mockReturnValue([]);
-    // Place a real snapshot on disk so the dead-session post-mortem
-    // path can read it.
-    const sessionDir = join(tmpDir, "abcd1234");
-    await mkdir(sessionDir, { recursive: true });
-    await writeSnapshot(
-      sessionDir,
-      snapshotOf("ralph", "claude", [panelSession("orchestrator", "running")]),
-    );
-    // Use the real reader for this test so the dead-session lookup
-    // hits the file we just wrote.
-    deps.readSnapshot = (await import(
-      "../../sdk/runtime/status-writer.ts"
-    )).readSnapshot;
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand(
-        { format: "json", id: "atomic-wf-claude-ralph-abcd1234" },
-        deps,
-      );
-      expect(code).toBe(0);
-      const parsed = JSON.parse(cap.read());
-      expect(parsed.alive).toBe(false);
-      expect(parsed.overall).toBe("error");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("text format: empty list prints the 'no workflows running' hint", async () => {
-    const { deps } = makeDeps(tmpDir);
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand({ format: "text" }, deps);
-      expect(code).toBe(0);
-      expect(cap.read()).toContain("no workflows running");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("text format: renders a workflow list with indicator, id, and status", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.listSessions.mockReturnValue([
-      tmuxSession("atomic-wf-claude-ralph-abcd1234"),
-    ]);
-    mocks.readSnapshot.mockResolvedValue(
-      snapshotOf("ralph", "claude", [panelSession("orchestrator", "running")]),
-    );
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand({ format: "text" }, deps);
-      expect(code).toBe(0);
-      const out = cap.read();
-      expect(out).toContain("atomic-wf-claude-ralph-abcd1234");
-      expect(out).toContain("in_progress");
-      expect(out).toContain("ralph");
-      // singular noun when list has exactly one workflow
-      expect(out).toContain("1");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("text format: list uses '(no snapshot)' placeholder when workflowName is empty", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.listSessions.mockReturnValue([
-      tmuxSession("atomic-wf-claude-ralph-abcd1234"),
-    ]);
-    mocks.readSnapshot.mockResolvedValue(null);
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand({ format: "text" }, deps);
-      expect(code).toBe(0);
-      expect(cap.read()).toContain("(no snapshot)");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("text format: single-report render includes workflow, stages, fatal error, and updatedAt", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.listSessions.mockReturnValue([
-      tmuxSession("atomic-wf-claude-ralph-abcd1234"),
-    ]);
-    mocks.readSnapshot.mockResolvedValue(
-      snapshotOf(
-        "ralph",
-        "claude",
-        [
-          panelSession("orchestrator", "error", { error: "stage boom" }),
-        ],
-        { fatalError: "the whole thing" },
-      ),
-    );
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand(
-        { format: "text", id: "atomic-wf-claude-ralph-abcd1234" },
-        deps,
-      );
-      expect(code).toBe(0);
-      const out = cap.read();
-      expect(out).toContain("atomic-wf-claude-ralph-abcd1234");
-      expect(out).toContain("workflow:");
-      expect(out).toContain("ralph");
-      expect(out).toContain("stages:");
-      expect(out).toContain("orchestrator");
-      expect(out).toContain("stage boom");
-      expect(out).toContain("the whole thing");
-      expect(out).toContain("updated:");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("text format: unknown id writes 'not found' to stderr and returns 1", async () => {
-    const { deps } = makeDeps(tmpDir);
-    const errChunks: string[] = [];
-    const origErr = process.stderr.write;
-    process.stderr.write = ((c: string | Uint8Array) => {
-      errChunks.push(typeof c === "string" ? c : new TextDecoder().decode(c));
-      return true;
-    }) as typeof process.stderr.write;
-    try {
-      const code = await workflowStatusCommand(
-        { format: "text", id: "atomic-wf-claude-ralph-deadbeef" },
-        deps,
-      );
-      expect(code).toBe(1);
-      expect(errChunks.join("")).toContain("not found");
-    } finally {
-      process.stderr.write = origErr;
-    }
-  });
-
-  test("reports zero workflows when tmux is not installed", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.isTmuxInstalled.mockReturnValue(false);
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand({ format: "json" }, deps);
-      expect(code).toBe(0);
-      const parsed = JSON.parse(cap.read());
-      expect(parsed).toEqual({ workflows: [] });
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("text format: tmux not installed prints the 'no sessions running' hint", async () => {
-    const { deps, mocks } = makeDeps(tmpDir);
-    mocks.isTmuxInstalled.mockReturnValue(false);
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand({ format: "text" }, deps);
-      expect(code).toBe(0);
-      expect(cap.read()).toContain("tmux is not installed");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("defaults format to 'json' when omitted", async () => {
-    const { deps } = makeDeps(tmpDir);
-    const cap = captureStdout();
-    try {
-      const code = await workflowStatusCommand({}, deps);
-      expect(code).toBe(0);
-      // JSON parses cleanly
-      JSON.parse(cap.read());
-    } finally {
-      cap.restore();
-    }
-  });
-
-  afterAll(async () => {
-    if (tmpDir) await rm(tmpDir, { recursive: true, force: true });
-  });
-});