@united-workforce/cli 0.4.0 → 0.6.0

package/src/__tests__/log-text-renderer.test.ts

@@ -0,0 +1,294 @@
+import { describe, expect, test } from "vitest";
+import { formatOutput, getTextRenderer, TEXT_RENDERERS } from "../format.js";
+import { renderLogList, renderLogShow } from "../text-renderers.js";
+
+describe("log list — text renderer registration", () => {
+  test("TEXT_RENDERERS contains 'log list'", () => {
+    expect(getTextRenderer("log list")).toBeDefined();
+    expect(typeof getTextRenderer("log list")).toBe("function");
+  });
+
+  test("TEXT_RENDERERS['log list'] is the same reference as renderLogList", () => {
+    expect(TEXT_RENDERERS["log list"]).toBe(renderLogList);
+  });
+
+  test("renderLogList is exported from text-renderers.ts", () => {
+    expect(typeof renderLogList).toBe("function");
+  });
+});
+
+describe("log show — text renderer registration", () => {
+  test("TEXT_RENDERERS contains 'log show'", () => {
+    expect(getTextRenderer("log show")).toBeDefined();
+    expect(typeof getTextRenderer("log show")).toBe("function");
+  });
+
+  test("TEXT_RENDERERS['log show'] is the same reference as renderLogShow", () => {
+    expect(TEXT_RENDERERS["log show"]).toBe(renderLogShow);
+  });
+
+  test("renderLogShow is exported from text-renderers.ts", () => {
+    expect(typeof renderLogShow).toBe("function");
+  });
+});
+
+describe("renderLogList — output shape", () => {
+  test("returns a string for full payload", () => {
+    const out = renderLogList([
+      { name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" },
+      { name: "2026-06-11.jsonl", size: 8192, date: "2026-06-11" },
+    ]);
+    expect(typeof out).toBe("string");
+  });
+
+  test("includes file names, dates, and sizes for each row", () => {
+    const out = renderLogList([
+      { name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" },
+      { name: "2026-06-11.jsonl", size: 8192, date: "2026-06-11" },
+    ]);
+    expect(out).toContain("2026-06-10.jsonl");
+    expect(out).toContain("2026-06-10");
+    expect(out).toContain("2026-06-11.jsonl");
+    expect(out).toContain("2026-06-11");
+  });
+
+  test("includes a header line", () => {
+    const out = renderLogList([{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }]);
+    const lines = out.split("\n");
+    expect(lines.length).toBeGreaterThanOrEqual(2);
+    // header should mention NAME or DATE or SIZE
+    const header = lines[0]?.toUpperCase() ?? "";
+    const hasHeader = header.includes("NAME") || header.includes("DATE") || header.includes("SIZE");
+    expect(hasHeader).toBe(true);
+  });
+
+  test("does NOT begin with '{' or '[' (not raw JSON)", () => {
+    const out = renderLogList([{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }]);
+    const trimmed = out.trimStart();
+    expect(trimmed.startsWith("{")).toBe(false);
+    expect(trimmed.startsWith("[")).toBe(false);
+  });
+
+  test("does NOT contain literal 'undefined'", () => {
+    const out = renderLogList([{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }]);
+    expect(out).not.toContain("undefined");
+  });
+
+  test("empty array — returns string, no 'undefined'", () => {
+    const out = renderLogList([]);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("null payload — returns string, does not throw", () => {
+    expect(() => renderLogList(null)).not.toThrow();
+    const out = renderLogList(null);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("non-array payload — returns string, does not throw", () => {
+    expect(() => renderLogList({ name: "x" })).not.toThrow();
+    const out = renderLogList({ name: "x" });
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("partial item (missing size) — returns string, no 'undefined'", () => {
+    const out = renderLogList([{ name: "2026-06-10.jsonl", date: "2026-06-10" }]);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+});
+
+describe("renderLogShow — output shape", () => {
+  test("returns a string for full payload", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "Loading workflow...",
+        thread: "01JTEST000000000000THREAD1",
+        workflow: "WF1234567890A",
+      },
+    ]);
+    expect(typeof out).toBe("string");
+  });
+
+  test("includes ts, pid, tag, and msg for each entry", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "Loading workflow...",
+        thread: null,
+        workflow: null,
+      },
+    ]);
+    expect(out).toContain("2026-06-12T10:00:00.000Z");
+    expect(out).toContain("12345");
+    expect(out).toContain("4KNMR2PX");
+    expect(out).toContain("Loading workflow...");
+  });
+
+  test("includes thread id when present", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "Loading workflow...",
+        thread: "01JTEST000000000000THREAD1",
+        workflow: null,
+      },
+    ]);
+    expect(out).toContain("01JTEST000000000000THREAD1");
+  });
+
+  test("does NOT begin with '{' or '[' (not raw JSON)", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "Loading workflow...",
+        thread: null,
+        workflow: null,
+      },
+    ]);
+    const trimmed = out.trimStart();
+    expect(trimmed.startsWith("{")).toBe(false);
+    expect(trimmed.startsWith("[")).toBe(false);
+  });
+
+  test("does NOT contain literal 'undefined'", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "Loading workflow...",
+        thread: null,
+        workflow: null,
+      },
+    ]);
+    expect(out).not.toContain("undefined");
+  });
+
+  test("empty array — returns string, no 'undefined'", () => {
+    const out = renderLogShow([]);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("null payload — returns string, does not throw", () => {
+    expect(() => renderLogShow(null)).not.toThrow();
+    const out = renderLogShow(null);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("non-array payload — returns string, does not throw", () => {
+    expect(() => renderLogShow({ ts: "x" })).not.toThrow();
+    const out = renderLogShow({ ts: "x" });
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+
+  test("partial entry (missing thread) — returns string, no 'undefined'", () => {
+    const out = renderLogShow([
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "hello",
+      },
+    ]);
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+  });
+});
+
+describe("formatOutput integration — log list", () => {
+  test("formatOutput(data, 'text', 'log list') uses renderer", () => {
+    const data = [{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }];
+    const out = formatOutput(data, "text", "log list");
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+    expect(out.trimStart().startsWith("{")).toBe(false);
+    expect(out.trimStart().startsWith("[")).toBe(false);
+    expect(out).toContain("2026-06-10.jsonl");
+  });
+
+  test("formatOutput(data, 'json', 'log list') still emits parseable JSON", () => {
+    const data = [{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }];
+    const out = formatOutput(data, "json", "log list");
+    const parsed = JSON.parse(out);
+    expect(parsed).toEqual(data);
+  });
+
+  test("formatOutput(data, 'yaml', 'log list') still emits YAML", () => {
+    const data = [{ name: "2026-06-10.jsonl", size: 4096, date: "2026-06-10" }];
+    const out = formatOutput(data, "yaml", "log list");
+    expect(typeof out).toBe("string");
+    expect(out).toContain("name:");
+    expect(out).toContain("2026-06-10.jsonl");
+  });
+});
+
+describe("formatOutput integration — log show", () => {
+  test("formatOutput(data, 'text', 'log show') uses renderer", () => {
+    const data = [
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "hello",
+        thread: null,
+        workflow: null,
+      },
+    ];
+    const out = formatOutput(data, "text", "log show");
+    expect(typeof out).toBe("string");
+    expect(out).not.toContain("undefined");
+    expect(out.trimStart().startsWith("{")).toBe(false);
+    expect(out.trimStart().startsWith("[")).toBe(false);
+    expect(out).toContain("4KNMR2PX");
+    expect(out).toContain("hello");
+  });
+
+  test("formatOutput(data, 'json', 'log show') still emits parseable JSON", () => {
+    const data = [
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "hello",
+        thread: null,
+        workflow: null,
+      },
+    ];
+    const out = formatOutput(data, "json", "log show");
+    const parsed = JSON.parse(out);
+    expect(parsed).toEqual(data);
+  });
+
+  test("formatOutput(data, 'yaml', 'log show') still emits YAML", () => {
+    const data = [
+      {
+        ts: "2026-06-12T10:00:00.000Z",
+        pid: "12345",
+        tag: "4KNMR2PX",
+        msg: "hello",
+        thread: null,
+        workflow: null,
+      },
+    ];
+    const out = formatOutput(data, "yaml", "log show");
+    expect(typeof out).toBe("string");
+    expect(out).toContain("ts:");
+    expect(out).toContain("pid:");
+  });
+});

package/src/__tests__/output-mapper-thread-list-startedat.test.ts

@@ -0,0 +1,124 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import type { CasRef, ThreadId } from "@united-workforce/protocol";
+import { generateUlid } from "@united-workforce/util";
+import { describe, expect, test } from "vitest";
+import type { ThreadListItemWithStatus } from "../commands/thread.js";
+import { toThreadListPayload } from "../output-mappers.js";
+
+const OUTPUT_MAPPERS_PATH = fileURLToPath(new URL("../output-mappers.ts", import.meta.url));
+
+function makeItem(threadId: string): ThreadListItemWithStatus {
+  return {
+    thread: threadId as ThreadId,
+    workflow: "WORKFLOWHASH1" as CasRef,
+    head: "HEADHASH00001" as CasRef,
+    status: "idle",
+    currentRole: null,
+    statusDisplay: "idle",
+    workflowName: "test-workflow",
+  };
+}
+
+describe("toThreadListPayload — issue #343 (ULID timestamp decoded with padding stripped)", () => {
+  test("startedAt equals the millisecond timestamp originally passed to generateUlid", () => {
+    const ts = 1781219097830; // 2026-06-11T23:04:57.830Z
+    const ulid = generateUlid(ts);
+
+    const payload = toThreadListPayload([makeItem(ulid)]);
+
+    expect(payload.items).toHaveLength(1);
+    expect(payload.items[0]!.startedAt).toBe(ts);
+  });
+
+  test("startedAt is NOT the raw 50-bit value (i.e. NOT timestamp << 2)", () => {
+    const ts = 1781219097830;
+    const ulid = generateUlid(ts);
+
+    const payload = toThreadListPayload([makeItem(ulid)]);
+
+    // The buggy decoder produced ts * 4 = 7124876391323, pushing year to 2195.
+    expect(payload.items[0]!.startedAt).not.toBe(ts * 4);
+    expect(payload.items[0]!.startedAt).not.toBe(7124876391323);
+  });
+
+  test("startedAt decodes to year 2026 for the issue-reported ULID timestamp", () => {
+    const ts = 1781219097830;
+    const ulid = generateUlid(ts);
+
+    const payload = toThreadListPayload([makeItem(ulid)]);
+
+    const startedAt = payload.items[0]!.startedAt;
+    expect(startedAt).not.toBeNull();
+    if (startedAt === null) return;
+    const isoDate = new Date(startedAt).toISOString().slice(0, 10);
+    expect(isoDate).toBe("2026-06-11");
+  });
+
+  test("round-trips correctly across several timestamps", () => {
+    const timestamps = [
+      0,
+      Date.UTC(2020, 0, 1, 0, 0, 0),
+      Date.UTC(2023, 5, 15, 12, 30, 45),
+      Date.UTC(2026, 4, 20, 0, 0, 0),
+      Date.UTC(2030, 11, 31, 23, 59, 59),
+    ];
+    const items = timestamps.map((t) => makeItem(generateUlid(t)));
+
+    const payload = toThreadListPayload(items);
+
+    for (let i = 0; i < timestamps.length; i++) {
+      expect(payload.items[i]!.startedAt).toBe(timestamps[i]);
+    }
+  });
+
+  test("startedAt is null for thread ids that are not valid 26-char Crockford Base32 ULIDs", () => {
+    const cases = ["", "TOOSHORT", "TOOLONGAAAAAAAAAAAAAAAAAA", "INVALID!@#$%^&CHARACTERS"];
+    const items = cases.map((id) => makeItem(id));
+
+    const payload = toThreadListPayload(items);
+
+    for (const item of payload.items) {
+      expect(item.startedAt).toBeNull();
+    }
+  });
+
+  test("preserves other thread-list item fields verbatim", () => {
+    const ts = 1781219097830;
+    const ulid = generateUlid(ts);
+    const item: ThreadListItemWithStatus = {
+      thread: ulid as ThreadId,
+      workflow: "WORKFLOWHASH9" as CasRef,
+      head: "HEADHASH99999" as CasRef,
+      status: "running",
+      currentRole: "developer",
+      statusDisplay: "running",
+      workflowName: "solve-issue",
+    };
+
+    const payload = toThreadListPayload([item]);
+
+    expect(payload.items[0]).toEqual({
+      threadId: ulid,
+      workflowHash: "WORKFLOWHASH9",
+      workflowName: "solve-issue",
+      status: "running",
+      currentRole: "developer",
+      startedAt: ts,
+      completedAt: null,
+    });
+  });
+});
+
+describe("output-mappers.ts source — issue #343 refactor", () => {
+  test("does NOT contain a local extractUlidTime function (removed in favor of util)", async () => {
+    const source = await readFile(OUTPUT_MAPPERS_PATH, "utf8");
+    expect(source).not.toMatch(/function\s+extractUlidTime\b/);
+  });
+
+  test("imports extractUlidTimestamp from @united-workforce/util", async () => {
+    const source = await readFile(OUTPUT_MAPPERS_PATH, "utf8");
+    expect(source).toMatch(/extractUlidTimestamp/);
+    expect(source).toMatch(/@united-workforce\/util/);
+  });
+});

package/src/__tests__/output-mapper-workflow-add.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "vitest";
+import { toWorkflowAddPayload, type WorkflowAddPayload } from "../output-mappers.js";
+
+describe("toWorkflowAddPayload — issue #334", () => {
+  test("maps WorkflowAddOutput { name, hash } to plain payload shape", () => {
+    const out = toWorkflowAddPayload({ name: "review-pr", hash: "2TBP6T37TZAJZ" });
+    expect(out).toEqual({ name: "review-pr", hash: "2TBP6T37TZAJZ" });
+  });
+
+  test("returns a WorkflowAddPayload type with exactly two fields", () => {
+    const out: WorkflowAddPayload = toWorkflowAddPayload({
+      name: "solve-issue",
+      hash: "76C98RVXA5E4F",
+    });
+    expect(Object.keys(out).sort()).toEqual(["hash", "name"]);
+  });
+
+  test("performs no I/O — pure data mapping", () => {
+    // Repeated calls produce equal results
+    const a = toWorkflowAddPayload({ name: "a", hash: "AAA1234567890" });
+    const b = toWorkflowAddPayload({ name: "a", hash: "AAA1234567890" });
+    expect(a).toEqual(b);
+  });
+});

package/src/__tests__/pid-recycling.test.ts

@@ -13,17 +13,11 @@ import {
   listRunningThreads,
   readMarker,
 } from "../background/index.js";
-import { createUwfStore, type UwfStore } from "../store.js";
+import type { UwfStore } from "../store.js";
+import { makeUwfStore } from "./thread-test-helpers.js";
 
 // ── helpers ───────────────────────────────────────────────────────────────────
 
-async function makeUwfStore(storageRoot: string): Promise<UwfStore> {
-  const casDir = join(storageRoot, "cas");
-  await mkdir(casDir, { recursive: true });
-  process.env.OCAS_HOME = casDir;
-  return createUwfStore(storageRoot);
-}
-
 async function createTestWorkflow(uwf: UwfStore): Promise<CasRef> {
   const workflowPayload = {
     name: "test-workflow",
@@ -42,12 +36,19 @@ async function createTestWorkflow(uwf: UwfStore): Promise<CasRef> {
 // ── test setup ────────────────────────────────────────────────────────────────
 
 let tmpDir: string;
+let savedOcasHome: string | undefined;
 
 beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
   tmpDir = await mkdtemp(join(tmpdir(), "pid-recycling-test-"));
 });
 
 afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
   await rm(tmpDir, { recursive: true, force: true });
 });
 

package/src/__tests__/prompt.test.ts

@@ -135,8 +135,6 @@ describe("prompt commands", () => {
     // Fresh install scenario
     expect(result).toContain("Fresh Install");
     expect(result).toContain("uwf setup");
-    expect(result).toContain("--provider");
-    expect(result).toContain("--api-key");
     expect(result).toContain("agent adapter");
     // Upgrade scenario
     expect(result).toContain("Upgrade");
@@ -147,6 +145,49 @@ describe("prompt commands", () => {
     expect(result.length).toBeGreaterThan(100);
   });
 
+  // Skip: pure documentation content assertions on bootstrap prompt text.
+  test.skip("prompt bootstrap has no LLM provider/model references", () => {
+    const result = cmdPromptBootstrap();
+    // Must NOT contain provider/model flags
+    expect(result).not.toContain("--provider");
+    expect(result).not.toContain("--base-url");
+    expect(result).not.toContain("--api-key");
+    expect(result).not.toContain("--model");
+    // Must NOT contain old Step 2 about provider config
+    expect(result).not.toContain("Configure provider and model");
+    // Must NOT contain preset providers table
+    expect(result).not.toContain("openrouter");
+    expect(result).not.toContain("OpenRouter");
+    expect(result).not.toContain("xAI");
+    expect(result).not.toContain("dashscope");
+    // Must NOT show provider/model config keys
+    expect(result).not.toContain("providers:");
+    expect(result).not.toContain("defaultModel");
+    expect(result).not.toContain("models:");
+    // Setup step must show only --agent
+    expect(result).toContain("uwf setup --agent");
+    // Config example must show only agents, defaultAgent, agentOverrides
+    expect(result).toContain("agents:");
+    expect(result).toContain("defaultAgent:");
+    // Must mention per-adapter LLM config
+    expect(result).toMatch(/~\/\.uwf\/agents\//);
+  });
+
+  // Skip: pure documentation content assertions on bootstrap prompt text.
+  test.skip("prompt bootstrap step numbering has no gaps after removing old Step 2", () => {
+    const result = cmdPromptBootstrap();
+    // Extract only the Fresh Install section
+    const freshStart = result.indexOf("## Scenario A: Fresh Install");
+    const freshEnd = result.indexOf("## Scenario B:");
+    const freshSection = result.slice(freshStart, freshEnd);
+    const stepHeaders = freshSection.match(/### Step \d+/g) ?? [];
+    const stepNumbers = stepHeaders.map((h) => Number.parseInt(h.replace("### Step ", ""), 10));
+    // Verify sequential numbering (0, 1, 2, 3, ...)
+    for (let i = 0; i < stepNumbers.length; i++) {
+      expect(stepNumbers[i]).toBe(i);
+    }
+  });
+
   test("prompt help subcommand is suppressed", { timeout: 30_000 }, () => {
     const cliPath = join(__dirname, "..", "..", "dist", "cli.js");
     const output = execFileSync("node", [cliPath, "prompt", "--help"], {
@@ -165,7 +206,9 @@ describe("prompt commands", () => {
   });
 });
 
-describe("prompt adapter-developing — issue #214 v0.4 contract", () => {
+// Skip: pure documentation content assertions — text changes break these without
+// indicating real bugs. Verified by human review instead. See #299 discussion.
+describe.skip("prompt adapter-developing — issue #214 v0.4 contract", () => {
   const text = cmdPromptAdapterDeveloping();
   const lower = text.toLowerCase();
 
@@ -427,7 +470,8 @@ describe("prompt adapter-developing — issue #214 v0.4 contract", () => {
   });
 });
 
-describe("prompt workflow-authoring — issue #226 edge location field", () => {
+// Skip: pure documentation content assertions on reference text.
+describe.skip("prompt workflow-authoring — issue #226 edge location field", () => {
   const text = cmdPromptWorkflowAuthoring();
   const lower = text.toLowerCase();
 

package/src/__tests__/resolve-head-hash.test.ts

@@ -7,8 +7,10 @@ import { resolveHeadHash } from "../commands/shared.js";
 import { completeThread, createUwfStore, setThread } from "../store.js";
 
 let tmpDir: string;
+let savedOcasHome: string | undefined;
 
 beforeEach(async () => {
+  savedOcasHome = process.env.OCAS_HOME;
   tmpDir = await mkdtemp(join(tmpdir(), "cli-uwf-resolve-head-"));
   const casDir = join(tmpDir, "cas");
   await mkdir(casDir, { recursive: true });
@@ -16,6 +18,11 @@ beforeEach(async () => {
 });
 
 afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
   await rm(tmpDir, { recursive: true, force: true });
 });
 

package/src/__tests__/solve-issue-tea-worktree.test.ts

@@ -13,7 +13,9 @@ import { parse } from "yaml";
  * which fixes the "path segment [0] is empty" error in worktree directories.
  */
 
-describe("solve-issue workflow: Gitea API PR creation", () => {
+// Skip: pure workflow YAML prose content assertions — procedure text changes
+// break these without indicating real bugs. See #299 discussion.
+describe.skip("solve-issue workflow: Gitea API PR creation", () => {
   // Navigate up from packages/cli/src/__tests__ to repo root
   const workflowPath = join(
     dirname(fileURLToPath(import.meta.url)),

package/src/__tests__/step-ask.test.ts

@@ -41,12 +41,19 @@ const THREAD_ID = "01ASKSTEPTEST000000000" as ThreadId;
 const STEP_SESSION_ID = "ses-original-step-001";
 
 let tmpDir: string;
+let savedOcasHome: string | undefined;
 
 beforeEach(async () => {
-  tmpDir = await mkdtemp(join(tmpdir(), "cli-uwf-step-ask-test-"));
+  savedOcasHome = process.env.OCAS_HOME;
+  tmpDir = await mkdtemp(join(tmpdir(), "cli-uwf-ask-test-"));
 });
 
 afterEach(async () => {
+  if (savedOcasHome === undefined) {
+    delete process.env.OCAS_HOME;
+  } else {
+    process.env.OCAS_HOME = savedOcasHome;
+  }
   await rm(tmpDir, { recursive: true, force: true });
 });