@gethmy/agent 1.3.0 → 1.4.1

package/dist/__tests__/state-store.test.js

@@ -1,132 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { newRunId, StateStore } from "../state-store.js";
-describe("StateStore", () => {
-    let dir;
-    let path;
-    beforeEach(() => {
-        dir = mkdtempSync(join(tmpdir(), "agent-state-"));
-        path = join(dir, "state.json");
-    });
-    afterEach(() => {
-        rmSync(dir, { recursive: true, force: true });
-    });
-    function sampleRun(overrides = {}) {
-        return {
-            runId: newRunId(),
-            cardId: "card-1",
-            cardShortId: 42,
-            pipeline: "implement",
-            workerId: 0,
-            sessionId: "sess-1",
-            worktreePath: "/tmp/wt",
-            branchName: "agent/42-thing",
-            daemonPid: process.pid,
-            phase: "preparing",
-            startedAt: Date.now(),
-            lastHeartbeatAt: Date.now(),
-            endedAt: null,
-            status: "active",
-            costCents: 0,
-            ...overrides,
-        };
-    }
-    it("loads empty state when file does not exist", () => {
-        const store = new StateStore(path);
-        expect(store.getActiveRuns()).toEqual([]);
-        expect(store.getDaemon()).toEqual({
-            daemonId: null,
-            daemonPid: null,
-            daemonStartedAt: null,
-        });
-    });
-    it("persists daemon metadata atomically", async () => {
-        const store = new StateStore(path);
-        await store.setDaemon("daemon-abc", 12345);
-        const raw = JSON.parse(readFileSync(path, "utf-8"));
-        expect(raw.daemonId).toBe("daemon-abc");
-        expect(raw.daemonPid).toBe(12345);
-    });
-    it("inserts, heartbeats, and ends a run", async () => {
-        const store = new StateStore(path);
-        const run = sampleRun();
-        await store.insertRun(run);
-        expect(store.getActiveRuns()).toHaveLength(1);
-        expect(store.getRun(run.runId)?.cardId).toBe("card-1");
-        const before = store.getRun(run.runId).lastHeartbeatAt;
-        await new Promise((r) => setTimeout(r, 5));
-        await store.heartbeat(run.runId);
-        expect(store.getRun(run.runId).lastHeartbeatAt).toBeGreaterThan(before);
-        await store.endRun(run.runId, "completed");
-        expect(store.getActiveRuns()).toHaveLength(0);
-        expect(store.getRun(run.runId).status).toBe("completed");
-        expect(store.getRun(run.runId).endedAt).not.toBeNull();
-    });
-    it("reloads persisted state after reopen", async () => {
-        const store = new StateStore(path);
-        await store.setDaemon("d1", 1);
-        await store.insertRun(sampleRun({ cardId: "card-7" }));
-        const reopened = new StateStore(path);
-        expect(reopened.getDaemon().daemonId).toBe("d1");
-        expect(reopened.getActiveRuns()[0].cardId).toBe("card-7");
-    });
-    it("tracks card attempts and resets on success", async () => {
-        const store = new StateStore(path);
-        expect(await store.incrementAttempt("c1")).toBe(1);
-        expect(await store.incrementAttempt("c1")).toBe(2);
-        await store.recordOutcome("c1", "failure");
-        expect(store.getCard("c1").attempts).toBe(2);
-        await store.recordOutcome("c1", "success");
-        expect(store.getCard("c1").attempts).toBe(0);
-    });
-    it("aggregates cost per card and per UTC day", async () => {
-        const store = new StateStore(path);
-        await store.addCost("c1", 100);
-        await store.addCost("c1", 250);
-        await store.addCost("c2", 50);
-        expect(store.getCard("c1").totalCostCents).toBe(350);
-        expect(store.getCard("c2").totalCostCents).toBe(50);
-        expect(store.getDailyCostCents()).toBe(400);
-    });
-    it("manages DLQ status", async () => {
-        const store = new StateStore(path);
-        expect(store.isDlq("c1")).toBe(false);
-        await store.markDlq("c1", "build failed 3x");
-        expect(store.isDlq("c1")).toBe(true);
-        expect(store.listDlq()).toHaveLength(1);
-        expect(store.getCard("c1").dlqReason).toBe("build failed 3x");
-        await store.clearDlq("c1");
-        expect(store.isDlq("c1")).toBe(false);
-        expect(store.listDlq()).toHaveLength(0);
-    });
-    it("serializes concurrent writes via the write queue", async () => {
-        const store = new StateStore(path);
-        const run = sampleRun();
-        await store.insertRun(run);
-        await Promise.all([
-            store.heartbeat(run.runId),
-            store.updateRun(run.runId, { phase: "running" }),
-            store.addCost(run.cardId, 10),
-            store.addCost(run.cardId, 20),
-        ]);
-        await store.flush();
-        const raw = JSON.parse(readFileSync(path, "utf-8"));
-        expect(raw.runs[0].phase).toBe("running");
-        expect(raw.cards.find((c) => c.cardId === run.cardId)
-            .totalCostCents).toBe(30);
-    });
-    it("handles corrupted state files by starting fresh", () => {
-        const brokenPath = join(dir, "broken.json");
-        require("node:fs").writeFileSync(brokenPath, "{not valid json", "utf-8");
-        const store = new StateStore(brokenPath);
-        expect(store.getActiveRuns()).toEqual([]);
-    });
-    it("migrates away from unknown schema versions", () => {
-        const future = join(dir, "future.json");
-        require("node:fs").writeFileSync(future, JSON.stringify({ version: 99, runs: [{}] }), "utf-8");
-        const store = new StateStore(future);
-        expect(store.getActiveRuns()).toEqual([]);
-    });
-});

package/dist/__tests__/stream-parser-selftest.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/stream-parser-selftest.test.js

@@ -1,23 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { StreamParser } from "../stream-parser.js";
-import { verifyStreamParserFormat } from "../stream-parser-selftest.js";
-describe("verifyStreamParserFormat", () => {
-    it("passes with the current stream-parser implementation", () => {
-        expect(() => verifyStreamParserFormat()).not.toThrow();
-    });
-    it("throws a descriptive error if the parser is silently broken", () => {
-        // Simulate CLI-format drift: stub StreamParser so `feed` is a no-op.
-        // The canary should notice that no events fired and fail loud.
-        const spy = vi
-            .spyOn(StreamParser.prototype, "feed")
-            .mockImplementation(() => {
-            // drop every line
-        });
-        try {
-            expect(() => verifyStreamParserFormat()).toThrow(/canary failed/i);
-        }
-        finally {
-            spy.mockRestore();
-        }
-    });
-});

package/dist/__tests__/stream-parser.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/stream-parser.test.js

@@ -1,199 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { StreamParser } from "../stream-parser.js";
-function collect(parser) {
-    const texts = [];
-    const toolStarts = [];
-    const toolEnds = [];
-    const results = [];
-    const costs = [];
-    const errors = [];
-    parser.on("text", (c) => texts.push(c));
-    parser.on("tool_start", (name, input) => toolStarts.push({ name, input }));
-    parser.on("tool_end", (name, id, content) => toolEnds.push({ name, id, content }));
-    parser.on("result", (stop) => results.push(stop));
-    parser.on("cost_update", (c) => costs.push(c));
-    parser.on("parse_error", (m) => errors.push(m));
-    return { texts, toolStarts, toolEnds, results, costs, errors };
-}
-describe("StreamParser", () => {
-    it("emits text from assistant content blocks (Claude CLI stream-json format)", () => {
-        const parser = new StreamParser();
-        const events = collect(parser);
-        parser.feed(`${JSON.stringify({
-            type: "assistant",
-            message: {
-                content: [
-                    {
-                        type: "text",
-                        text: '```json\n{"verdict":"approved","summary":"ok"}\n```',
-                    },
-                ],
-            },
-        })}\n`);
-        expect(events.texts).toHaveLength(1);
-        expect(events.texts[0]).toContain('"verdict":"approved"');
-    });
-    it("emits tool_start for tool_use blocks and tool_end for tool_result with matching name", () => {
-        const parser = new StreamParser();
-        const events = collect(parser);
-        parser.feed(`${JSON.stringify({
-            type: "assistant",
-            message: {
-                content: [
-                    {
-                        type: "tool_use",
-                        id: "toolu_1",
-                        name: "Bash",
-                        input: { command: "ls" },
-                    },
-                ],
-            },
-        })}\n`);
-        parser.feed(`${JSON.stringify({
-            type: "user",
-            message: {
-                content: [
-                    {
-                        type: "tool_result",
-                        tool_use_id: "toolu_1",
-                        content: "file1\nfile2",
-                    },
-                ],
-            },
-        })}\n`);
-        expect(events.toolStarts).toEqual([
-            { name: "Bash", input: { command: "ls" } },
-        ]);
-        expect(events.toolEnds).toEqual([
-            { name: "Bash", id: "toolu_1", content: "file1\nfile2" },
-        ]);
-    });
-    it("ignores thinking blocks", () => {
-        const parser = new StreamParser();
-        const events = collect(parser);
-        parser.feed(`${JSON.stringify({
-            type: "assistant",
-            message: {
-                content: [
-                    { type: "thinking", thinking: "pondering..." },
-                    { type: "text", text: "actual output" },
-                ],
-            },
-        })}\n`);
-        expect(events.texts).toEqual(["actual output"]);
-    });
-    it("falls back to result.result when no assistant text was streamed", () => {
-        const parser = new StreamParser();
-        const events = collect(parser);
-        parser.feed(`${JSON.stringify({
-            type: "result",
-            subtype: "success",
-            result: "final verdict text",
-            total_cost_usd: 0.5,
-            usage: {
-                input_tokens: 10,
-                output_tokens: 20,
-                cache_read_input_tokens: 100,
-                cache_creation_input_tokens: 5,
-            },
-            duration_ms: 1000,
-            duration_api_ms: 900,
-            num_turns: 3,
-        })}\n`);
-        expect(events.texts).toEqual(["final verdict text"]);
-        expect(events.costs).toEqual([
-            {
-                totalCostUsd: 0.5,
-                totalInputTokens: 10,
-                totalOutputTokens: 20,
-                totalCacheCreationInputTokens: 5,
-                totalCacheReadInputTokens: 100,
-                durationMs: 1000,
-                durationApiMs: 900,
-                numTurns: 3,
-                modelName: undefined,
-            },
-        ]);
-        expect(events.results).toEqual(["success"]);
-    });
-    it("does NOT duplicate text from result.result when assistant text was already emitted", () => {
-        const parser = new StreamParser();
-        const events = collect(parser);
-        parser.feed(`${JSON.stringify({
-            type: "assistant",
-            message: {
-                content: [{ type: "text", text: "the verdict" }],
-            },
-        })}\n${JSON.stringify({
-            type: "result",
-            subtype: "success",
-            result: "the verdict",
-            total_cost_usd: 0,
-        })}\n`);
-        expect(events.texts).toEqual(["the verdict"]);
-    });
-    it("handles split NDJSON chunks (partial line buffering)", () => {
-        const parser = new StreamParser();
-        const events = collect(parser);
-        const line = JSON.stringify({
-            type: "assistant",
-            message: { content: [{ type: "text", text: "hello" }] },
-        });
-        parser.feed(line.slice(0, 20));
-        parser.feed(`${line.slice(20)}\n`);
-        expect(events.texts).toEqual(["hello"]);
-    });
-    it("handles tool_result content as array of blocks", () => {
-        const parser = new StreamParser();
-        const events = collect(parser);
-        parser.feed(`${JSON.stringify({
-            type: "assistant",
-            message: {
-                content: [{ type: "tool_use", id: "t1", name: "Read", input: {} }],
-            },
-        })}\n${JSON.stringify({
-            type: "user",
-            message: {
-                content: [
-                    {
-                        type: "tool_result",
-                        tool_use_id: "t1",
-                        content: [{ type: "text", text: "line1" }],
-                    },
-                ],
-            },
-        })}\n`);
-        expect(events.toolEnds[0].content).toBe("line1");
-    });
-    it("skips non-JSON lines silently (no parse_error event)", () => {
-        const parser = new StreamParser();
-        const events = collect(parser);
-        parser.feed("not-json garbage\n");
-        parser.feed(`${JSON.stringify({
-            type: "assistant",
-            message: { content: [{ type: "text", text: "ok" }] },
-        })}\n`);
-        expect(events.errors).toHaveLength(0);
-        expect(events.texts).toEqual(["ok"]);
-    });
-    it("throws if attached twice", async () => {
-        const parser = new StreamParser();
-        const { Readable } = await import("node:stream");
-        parser.attach(Readable.from([]));
-        expect(() => parser.attach(Readable.from([]))).toThrow("StreamParser already attached");
-    });
-    it("reconstructs the full verdict JSON across multiple streamed text blocks", () => {
-        // Simulates the common case where Claude streams a final message with
-        // a preamble + fenced JSON block in a single text block. The StreamParser
-        // MUST surface that text so parseReviewOutput can pick up the verdict.
-        const parser = new StreamParser();
-        const events = collect(parser);
-        const finalText = 'All findings complete. Outputting verdict.\n\n```json\n{\n  "verdict": "approved",\n  "summary": "ok",\n  "findings": []\n}\n```';
-        parser.feed(`${JSON.stringify({
-            type: "assistant",
-            message: { content: [{ type: "text", text: finalText }] },
-        })}\n`);
-        const joined = events.texts.join("");
-        expect(joined).toContain('"verdict": "approved"');
-    });
-});

package/dist/__tests__/transitions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/transitions.test.js

@@ -1,130 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { runTransition, TransitionError } from "../transitions.js";
-function makeBoard() {
-    return {
-        columns: [
-            { id: "col-todo", name: "To Do" },
-            { id: "col-progress", name: "In Progress" },
-            { id: "col-review", name: "Review" },
-            { id: "col-done", name: "Done" },
-        ],
-        labels: [
-            { id: "lbl-agent", name: "agent" },
-            { id: "lbl-dlq", name: "dlq" },
-        ],
-    };
-}
-function makeCard(overrides = {}) {
-    return {
-        id: "card-1",
-        short_id: 42,
-        project_id: "proj",
-        title: "t",
-        column_id: "col-todo",
-        labelIds: [],
-        ...overrides,
-    };
-}
-function makeClient(overrides = {}) {
-    return {
-        getBoard: vi.fn().mockResolvedValue(makeBoard()),
-        moveCard: vi.fn().mockResolvedValue({}),
-        addLabelToCard: vi.fn().mockResolvedValue({}),
-        removeLabelFromCard: vi.fn().mockResolvedValue({}),
-        createLabel: vi.fn().mockResolvedValue({ label: { id: "lbl-new" } }),
-        updateCard: vi.fn().mockResolvedValue({}),
-        endAgentSession: vi.fn().mockResolvedValue({}),
-        ...overrides,
-    };
-}
-describe("runTransition", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("moves, labels, and ends session in order", async () => {
-        const client = makeClient();
-        const card = makeCard();
-        await runTransition(client, card, {
-            move: { columnName: "In Progress" },
-            addLabels: [{ name: "agent" }],
-            endSession: { status: "completed", progressPercent: 100 },
-        });
-        expect(client.moveCard).toHaveBeenCalledWith("card-1", "col-progress");
-        expect(client.addLabelToCard).toHaveBeenCalledWith("card-1", "lbl-agent");
-        expect(client.endAgentSession).toHaveBeenCalledWith("card-1", {
-            status: "completed",
-            progressPercent: 100,
-        });
-    });
-    it("is idempotent when the card is already in the target column", async () => {
-        const client = makeClient();
-        const card = makeCard({ column_id: "col-progress" });
-        await runTransition(client, card, { move: { columnName: "In Progress" } });
-        expect(client.moveCard).not.toHaveBeenCalled();
-    });
-    it("skips adding a label the card already has", async () => {
-        const client = makeClient();
-        const card = makeCard({ labelIds: ["lbl-agent"] });
-        await runTransition(client, card, { addLabels: [{ name: "agent" }] });
-        expect(client.addLabelToCard).not.toHaveBeenCalled();
-    });
-    it("creates missing labels on demand", async () => {
-        const client = makeClient();
-        const card = makeCard();
-        await runTransition(client, card, {
-            addLabels: [{ name: "agent-recovered", color: "#ff0000" }],
-        });
-        expect(client.createLabel).toHaveBeenCalledWith("proj", {
-            name: "agent-recovered",
-            color: "#ff0000",
-        });
-        expect(client.addLabelToCard).toHaveBeenCalledWith("card-1", "lbl-new");
-    });
-    it("removes labels idempotently", async () => {
-        const client = makeClient();
-        const card = makeCard({ labelIds: ["lbl-agent", "lbl-dlq"] });
-        await runTransition(client, card, { removeLabels: ["agent", "nope"] });
-        expect(client.removeLabelFromCard).toHaveBeenCalledTimes(1);
-        expect(client.removeLabelFromCard).toHaveBeenCalledWith("card-1", "lbl-agent");
-    });
-    it("retries a flaky step before giving up", async () => {
-        const moveCard = vi
-            .fn()
-            .mockRejectedValueOnce(new Error("502"))
-            .mockRejectedValueOnce(new Error("502"))
-            .mockResolvedValueOnce({});
-        const client = makeClient({ moveCard });
-        await runTransition(client, makeCard(), { move: { columnName: "Review" } }, { retries: 3, backoffMs: 1 });
-        expect(moveCard).toHaveBeenCalledTimes(3);
-    });
-    it("throws TransitionError with the failing step after retries exhausted", async () => {
-        const endAgentSession = vi
-            .fn()
-            .mockRejectedValue(new Error("upstream down"));
-        const client = makeClient({ endAgentSession });
-        await expect(runTransition(client, makeCard(), { endSession: { status: "paused" } }, { retries: 2, backoffMs: 1 })).rejects.toMatchObject({
-            name: "TransitionError",
-            step: "endSession",
-            attempts: 2,
-        });
-        expect(endAgentSession).toHaveBeenCalledTimes(2);
-    });
-    it("warns but continues when target column is missing in non-strict mode", async () => {
-        const client = makeClient();
-        await expect(runTransition(client, makeCard(), {
-            move: { columnName: "No Such Column" },
-        })).resolves.toBeUndefined();
-        expect(client.moveCard).not.toHaveBeenCalled();
-    });
-    it("throws when target column is missing in strict mode", async () => {
-        const client = makeClient();
-        await expect(runTransition(client, makeCard(), { move: { columnName: "No Such Column" } }, { strictColumn: true })).rejects.toBeInstanceOf(TransitionError);
-    });
-    it("heartbeats the state store when wired", async () => {
-        const client = makeClient();
-        const heartbeat = vi.fn().mockResolvedValue(undefined);
-        const store = { heartbeat };
-        await runTransition(client, makeCard(), { move: { columnName: "Done" } }, { store, runId: "r_1" });
-        expect(heartbeat).toHaveBeenCalledWith("r_1");
-    });
-});

package/dist/__tests__/worktree-gc.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/worktree-gc.test.js

@@ -1,137 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-vi.mock("../worktree.js", () => ({
-    cleanupWorktree: vi.fn((path) => {
-        // Make cleanupWorktree actually remove the directory so our
-        // assertions reflect reality without invoking git.
-        rmSync(path, { recursive: true, force: true });
-    }),
-}));
-import { newRunId, StateStore } from "../state-store.js";
-import { cleanupWorktree } from "../worktree.js";
-import { runWorktreeGc } from "../worktree-gc.js";
-function initRepo(dir) {
-    execFileSync("git", ["init", "-q", dir], { stdio: "pipe" });
-    execFileSync("git", ["-C", dir, "commit", "-q", "--allow-empty", "-m", "init"], {
-        stdio: "pipe",
-        env: {
-            ...process.env,
-            GIT_AUTHOR_NAME: "t",
-            GIT_AUTHOR_EMAIL: "t@t",
-            GIT_COMMITTER_NAME: "t",
-            GIT_COMMITTER_EMAIL: "t@t",
-        },
-    });
-}
-describe("runWorktreeGc", () => {
-    let repoDir;
-    let store;
-    beforeEach(() => {
-        // Realpath to collapse the /tmp → /private/tmp symlink on macOS so
-        // paths match what `git rev-parse --show-toplevel` returns.
-        repoDir = realpathSync(mkdtempSync(join(tmpdir(), "gc-repo-")));
-        initRepo(repoDir);
-        const stateDir = mkdtempSync(join(tmpdir(), "gc-state-"));
-        store = new StateStore(join(stateDir, "state.json"));
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        rmSync(repoDir, { recursive: true, force: true });
-    });
-    function makeWorktreeDir(name, ageMs = 0) {
-        const dir = join(repoDir, ".harmony-worktrees", name);
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(join(dir, "marker"), "x");
-        if (ageMs > 0) {
-            const mtime = new Date(Date.now() - ageMs);
-            execFileSync("touch", ["-m", "-t", formatMtime(mtime), dir]);
-        }
-        return dir;
-    }
-    function formatMtime(d) {
-        const pad = (n) => String(n).padStart(2, "0");
-        return (d.getFullYear().toString() +
-            pad(d.getMonth() + 1) +
-            pad(d.getDate()) +
-            pad(d.getHours()) +
-            pad(d.getMinutes()));
-    }
-    it("removes orphan worktrees older than minAgeMs", () => {
-        const cwd = process.cwd();
-        process.chdir(repoDir);
-        try {
-            makeWorktreeDir("agent-42-old", 2 * 60 * 60 * 1000);
-            const result = runWorktreeGc(".harmony-worktrees", store, {
-                minAgeMs: 60 * 60 * 1000,
-            });
-            expect(result.removed).toHaveLength(1);
-            expect(cleanupWorktree).toHaveBeenCalledTimes(1);
-        }
-        finally {
-            process.chdir(cwd);
-        }
-    });
-    it("keeps worktrees that match an active run", async () => {
-        const cwd = process.cwd();
-        process.chdir(repoDir);
-        try {
-            const wtPath = makeWorktreeDir("agent-99", 2 * 60 * 60 * 1000);
-            await store.insertRun({
-                runId: newRunId(),
-                cardId: "c1",
-                cardShortId: 99,
-                pipeline: "implement",
-                workerId: 0,
-                sessionId: null,
-                worktreePath: wtPath,
-                branchName: "agent/99",
-                daemonPid: process.pid,
-                phase: "running",
-                startedAt: Date.now(),
-                lastHeartbeatAt: Date.now(),
-                endedAt: null,
-                status: "active",
-                costCents: 0,
-            });
-            const result = runWorktreeGc(".harmony-worktrees", store, {
-                minAgeMs: 60 * 60 * 1000,
-            });
-            expect(result.removed).toHaveLength(0);
-            expect(result.skipped).toContain(wtPath);
-            expect(cleanupWorktree).not.toHaveBeenCalled();
-        }
-        finally {
-            process.chdir(cwd);
-        }
-    });
-    it("keeps worktrees younger than minAgeMs even if unclaimed", () => {
-        const cwd = process.cwd();
-        process.chdir(repoDir);
-        try {
-            const wt = makeWorktreeDir("agent-fresh", 0);
-            const result = runWorktreeGc(".harmony-worktrees", store, {
-                minAgeMs: 60 * 60 * 1000,
-            });
-            expect(result.removed).toHaveLength(0);
-            expect(result.skipped).toContain(wt);
-        }
-        finally {
-            process.chdir(cwd);
-        }
-    });
-    it("returns cleanly when the worktrees directory doesn't exist yet", () => {
-        const cwd = process.cwd();
-        process.chdir(repoDir);
-        try {
-            const result = runWorktreeGc(".harmony-worktrees", store);
-            expect(result.checked).toBe(0);
-            expect(result.errors).toEqual([]);
-        }
-        finally {
-            process.chdir(cwd);
-        }
-    });
-});