muonroi-cli 1.8.1 → 1.8.4

package/dist/src/chat/__tests__/verdict-resolver.test.js

@@ -1,308 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { discordAwaitVerdict } from "../verdict-resolver.js";
-function makeClient(over = {}) {
-    return {
-        createChannel: vi.fn(),
-        getChannelMessages: vi.fn().mockResolvedValue([]),
-        postMessage: vi.fn().mockResolvedValue({ id: "bot-msg" }),
-        addChannelPermission: vi.fn(),
-        getCurrentUserId: vi.fn().mockResolvedValue("bot"),
-        listGuildChannels: vi.fn(),
-        ...over,
-    };
-}
-function msg(id, content, authorId = "user") {
-    return { id, content, author: { id: authorId, username: "u" }, timestamp: new Date().toISOString() };
-}
-describe("discordAwaitVerdict", () => {
-    let flowDir;
-    const runId = "r-v";
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `vr-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(path.join(flowDir, "runs", runId), { recursive: true });
-    });
-    function baseArgs(over = {}) {
-        return {
-            flowDir,
-            runId,
-            phaseId: "phase-1",
-            sprintN: 1,
-            productSlug: "abc",
-            channelId: "c1",
-            client: makeClient(),
-            leader: { generate: vi.fn() },
-            capUsd: 10,
-            remainingUsd: async () => 5,
-            reviewSummary: "Sprint 1 complete.",
-            backoffDelays: [1, 1, 1],
-            pollIntervalMs: 1,
-            timeoutMs: 60_000,
-            sleep: async () => { },
-            now: () => Date.now(),
-            fallback: vi.fn().mockResolvedValue({ verdict: "accept" }),
-            ...over,
-        };
-    }
-    it("happy accept: single customer message classified accept", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "OK accept it")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "Great!" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("accept");
-        expect(out.feedback).toBeUndefined();
-    });
-    it("reject returns customer message as feedback", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "Please fix the auth flow")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "reject", reply: "noted" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("reject");
-        expect(out.feedback).toContain("auth flow");
-    });
-    it("abort returns abort verdict", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "Stop the whole thing")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "abort", reply: "OK stopping" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("abort");
-    });
-    it("timeout returns abort with [timeout-24h]", async () => {
-        let nowVal = 0;
-        const client = makeClient({ getChannelMessages: vi.fn().mockResolvedValue([]) });
-        const out = await discordAwaitVerdict(baseArgs({
-            client,
-            timeoutMs: 100,
-            now: () => {
-                nowVal += 200;
-                return nowVal;
-            },
-        }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("[timeout-24h]");
-    });
-    it("VERDICT_FLOOR boundary aborts with budget-exhausted", async () => {
-        const out = await discordAwaitVerdict(baseArgs({
-            capUsd: 10,
-            remainingUsd: async () => 0.05,
-        }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("budget-exhausted");
-    });
-    it("cap_usd=0 immediately aborts", async () => {
-        const out = await discordAwaitVerdict(baseArgs({ capUsd: 0, remainingUsd: async () => 0 }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("budget-exhausted");
-    });
-    it("MAX_VERDICT_MESSAGES cap → fallback", async () => {
-        const messages = Array.from({ length: 25 }, (_, i) => msg(`m${i}`, "discuss please"));
-        const client = makeClient({
-            getChannelMessages: vi.fn().mockResolvedValueOnce(messages).mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "discuss", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        const fallback = vi.fn().mockResolvedValue({ verdict: "accept", feedback: "via-fallback" });
-        const out = await discordAwaitVerdict(baseArgs({ client, leader, fallback }));
-        expect(fallback).toHaveBeenCalled();
-        expect(out.feedback).toBe("via-fallback");
-    });
-    it("malformed JSON counts as discuss then continues", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "something")])
-                .mockResolvedValueOnce([msg("m2", "I accept")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi
-                .fn()
-                .mockResolvedValueOnce({ content: "not json", costUsd: 0.01 })
-                .mockResolvedValueOnce({ content: JSON.stringify({ intent: "accept", reply: "OK" }), costUsd: 0.01 }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("accept");
-    });
-    it("unknown intent ×5 → fallback", async () => {
-        const messages = Array.from({ length: 5 }, (_, i) => msg(`m${i}`, "msg"));
-        const client = makeClient({
-            getChannelMessages: vi.fn().mockResolvedValueOnce(messages).mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "maybe", reply: "..." }),
-                costUsd: 0.01,
-            }),
-        };
-        const fallback = vi.fn().mockResolvedValue({ verdict: "reject", feedback: "via-fallback" });
-        const out = await discordAwaitVerdict(baseArgs({ client, leader, fallback }));
-        expect(fallback).toHaveBeenCalled();
-        expect(out.feedback).toBe("via-fallback");
-    });
-    it("leader transient failure ×3 → fallback", async () => {
-        const messages = Array.from({ length: 3 }, (_, i) => msg(`m${i}`, "msg"));
-        const client = makeClient({
-            getChannelMessages: vi.fn().mockResolvedValueOnce(messages).mockResolvedValue([]),
-        });
-        const leader = { generate: vi.fn().mockRejectedValue(new Error("net")) };
-        const fallback = vi.fn().mockResolvedValue({ verdict: "abort", feedback: "via-fallback" });
-        const _out = await discordAwaitVerdict(baseArgs({ client, leader, fallback }));
-        expect(fallback).toHaveBeenCalled();
-    });
-    it("404 on getChannelMessages → fallback", async () => {
-        const err = Object.assign(new Error("404"), { status: 404 });
-        const client = makeClient({ getChannelMessages: vi.fn().mockRejectedValue(err) });
-        const fallback = vi.fn().mockResolvedValue({ verdict: "accept", feedback: "via-fallback" });
-        const _out = await discordAwaitVerdict(baseArgs({ client, fallback }));
-        expect(fallback).toHaveBeenCalled();
-    });
-    it("filters out bot's own messages", async () => {
-        const client = makeClient({
-            getCurrentUserId: vi.fn().mockResolvedValue("bot"),
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "I am bot", "bot"), msg("m2", "I accept", "user")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(leader.generate).toHaveBeenCalledOnce();
-        expect(out.verdict).toBe("accept");
-    });
-    it("persists poll cursor in state.md", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m99", "I accept")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        await discordAwaitVerdict(baseArgs({ client, leader }));
-        const stateFile = path.join(flowDir, "runs", runId, "state.md");
-        const content = await fs.readFile(stateFile, "utf8");
-        expect(content).toContain("Discord Poll Cursor");
-        expect(content).toContain("m99");
-    });
-    it("cursor advance is AFTER bot reply post (resume safety)", async () => {
-        const order = [];
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "I accept")])
-                .mockResolvedValue([]),
-            postMessage: vi.fn().mockImplementation(async () => {
-                order.push("postReply");
-                return { id: "bot" };
-            }),
-        });
-        const leader = {
-            generate: vi.fn().mockImplementation(async () => {
-                order.push("leaderCall");
-                return { content: JSON.stringify({ intent: "accept", reply: "ok" }), costUsd: 0.01 };
-            }),
-        };
-        await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(order).toEqual(["leaderCall", "postReply"]);
-    });
-    it("403 on getChannelMessages → fallback", async () => {
-        const err = Object.assign(new Error("403"), { status: 403 });
-        const client = makeClient({ getChannelMessages: vi.fn().mockRejectedValue(err) });
-        const fallback = vi.fn().mockResolvedValue({ verdict: "reject", feedback: "via-fallback" });
-        const out = await discordAwaitVerdict(baseArgs({ client, fallback }));
-        expect(fallback).toHaveBeenCalled();
-        expect(out.verdict).toBe("reject");
-    });
-    it("cursor update replaces existing entry (not appended)", async () => {
-        // Two verdicts on different sprints, cursor for phase-1/sprint-1 gets updated
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m10", "I accept")])
-                .mockResolvedValueOnce([msg("m20", "I accept")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        // First run
-        await discordAwaitVerdict(baseArgs({ client, leader }));
-        // Second run same phase/sprint - cursor entry should be updated (same idx)
-        const client2 = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m20", "I accept")])
-                .mockResolvedValue([]),
-        });
-        await discordAwaitVerdict(baseArgs({ client: client2, leader }));
-        const stateFile = path.join(flowDir, "runs", runId, "state.md");
-        const content = await fs.readFile(stateFile, "utf8");
-        // Should have exactly one cursor entry, not two
-        const matches = content.match(/"phaseId"/g);
-        expect(matches?.length).toBe(1);
-    });
-    it("budget-exhausted during poll loop aborts with feedback", async () => {
-        let remaining = 10;
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "discuss")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockImplementation(async () => {
-                remaining = 0; // exhaust budget after first process
-                return { content: JSON.stringify({ intent: "discuss", reply: "ok" }), costUsd: 0.01 };
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader, capUsd: 10, remainingUsd: async () => remaining }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("budget-exhausted");
-    });
-});
-//# sourceMappingURL=verdict-resolver.test.js.map

package/dist/src/cli/__tests__/bw-vault.test.d.ts

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

package/dist/src/cli/__tests__/bw-vault.test.js

@@ -1,87 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { writeBwSecureNote } from "../bw-vault.js";
-function makeRunner(scripted) {
-    const calls = [];
-    let i = 0;
-    const runner = (cmd, args, input) => {
-        calls.push({ cmd, args, input });
-        const next = scripted[i++] ?? { status: 0, stdout: "", stderr: "" };
-        return {
-            pid: 0,
-            output: [],
-            stdout: next.stdout ?? "",
-            stderr: next.stderr ?? "",
-            status: next.status,
-            signal: null,
-        };
-    };
-    return { runner, calls };
-}
-describe("writeBwSecureNote", () => {
-    let origSession;
-    beforeEach(() => {
-        origSession = process.env.BW_SESSION;
-        process.env.BW_SESSION = "fake-session-token";
-    });
-    afterEach(() => {
-        if (origSession === undefined)
-            delete process.env.BW_SESSION;
-        else
-            process.env.BW_SESSION = origSession;
-    });
-    it("creates a new Secure Note when item does not exist", async () => {
-        const { runner, calls } = makeRunner([
-            { status: 0, stdout: "2026.4.0\n" }, // bw --version
-            { status: 0, stdout: '{"status":"unlocked"}' }, // bw status
-            { status: 0, stdout: "[]" }, // bw list items (empty)
-            { status: 0, stdout: "ZW5jb2RlZA==" }, // bw encode
-            { status: 0, stdout: '{"id":"new-uuid"}' }, // bw create item
-            { status: 0, stdout: "Syncing complete." }, // bw sync
-        ]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-test-1234567890", { runner });
-        expect(res).toEqual({ ok: true, action: "created" });
-        expect(calls[3].cmd).toBe("bw");
-        expect(calls[3].args[0]).toBe("encode");
-        expect(calls[3].input).toContain("tvly-test-1234567890");
-        expect(calls[4].args.slice(0, 3)).toEqual(["create", "item", "ZW5jb2RlZA=="]);
-    });
-    it("updates an existing item rather than creating a duplicate", async () => {
-        const { runner, calls } = makeRunner([
-            { status: 0, stdout: "2026.4.0\n" },
-            { status: 0, stdout: '{"status":"unlocked"}' },
-            {
-                status: 0,
-                stdout: JSON.stringify([{ id: "existing-uuid", name: "muonroi-cli/tavily", notes: "old-key", type: 2 }]),
-            },
-            { status: 0, stdout: "ZW5jb2RlZA==" },
-            { status: 0, stdout: '{"id":"existing-uuid"}' }, // bw edit
-            { status: 0, stdout: "Syncing complete." },
-        ]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-new-1234567890", { runner });
-        expect(res).toEqual({ ok: true, action: "updated" });
-        expect(calls[4].args.slice(0, 3)).toEqual(["edit", "item", "existing-uuid"]);
-    });
-    it("returns ok:false when bw is not installed", async () => {
-        const { runner } = makeRunner([{ status: 127, stderr: "command not found" }]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-x", { runner });
-        expect(res.ok).toBe(false);
-        expect(res.error).toMatch(/Bitwarden CLI/);
-    });
-    it("returns ok:false when BW_SESSION is missing", async () => {
-        delete process.env.BW_SESSION;
-        const { runner } = makeRunner([{ status: 0, stdout: "2026.4.0" }]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-x", { runner });
-        expect(res.ok).toBe(false);
-        expect(res.error).toMatch(/BW_SESSION/);
-    });
-    it("returns ok:false when vault is locked", async () => {
-        const { runner } = makeRunner([
-            { status: 0, stdout: "2026.4.0" },
-            { status: 0, stdout: '{"status":"locked"}' },
-        ]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-x", { runner });
-        expect(res.ok).toBe(false);
-        expect(res.error).toMatch(/not unlocked/i);
-    });
-});
-//# sourceMappingURL=bw-vault.test.js.map

package/dist/src/cli/__tests__/keys-bundle.test.d.ts

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

package/dist/src/cli/__tests__/keys-bundle.test.js

@@ -1,40 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { decryptBundle, encryptBundle } from "../keys-bundle.js";
-describe("keys-bundle round-trip", () => {
-    const sample = {
-        providers: {
-            deepseek: "sk-mock-deepseek-test-fixture-only",
-            siliconflow: "sk-mock-siliconflow-test-fixture-only",
-        },
-    };
-    test("encrypts and decrypts back to identical payload", () => {
-        const bundle = encryptBundle(sample, "correct-horse-battery");
-        const restored = decryptBundle(bundle, "correct-horse-battery");
-        expect(restored).toEqual(sample);
-    });
-    test("each encryption produces unique salt+iv+ct", () => {
-        const a = encryptBundle(sample, "passphrase-aaa");
-        const b = encryptBundle(sample, "passphrase-aaa");
-        expect(a.salt).not.toBe(b.salt);
-        expect(a.iv).not.toBe(b.iv);
-        expect(a.ct).not.toBe(b.ct);
-    });
-    test("wrong passphrase throws decryption error", () => {
-        const bundle = encryptBundle(sample, "correct-passphrase");
-        expect(() => decryptBundle(bundle, "wrong-passphrase")).toThrow(/Decryption failed/);
-    });
-    test("rejects passphrase shorter than 8 chars", () => {
-        expect(() => encryptBundle(sample, "short")).toThrow(/at least 8/);
-    });
-    test("rejects unsupported bundle version", () => {
-        const bundle = encryptBundle(sample, "passphrase-xyz");
-        const tampered = { ...bundle, v: 2 };
-        expect(() => decryptBundle(tampered, "passphrase-xyz")).toThrow(/Unsupported bundle version/);
-    });
-    test("tampered ciphertext fails auth", () => {
-        const bundle = encryptBundle(sample, "passphrase-xyz");
-        const tampered = { ...bundle, ct: Buffer.from("not-the-real-ciphertext-here").toString("base64") };
-        expect(() => decryptBundle(tampered, "passphrase-xyz")).toThrow(/Decryption failed/);
-    });
-});
-//# sourceMappingURL=keys-bundle.test.js.map

package/dist/src/cli/__tests__/share-cmd.test.d.ts

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

package/dist/src/cli/__tests__/share-cmd.test.js

@@ -1,175 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { runShareCommand } from "../share-cmd.js";
-function makeClient(over = {}) {
-    return {
-        createChannel: vi.fn(),
-        getChannelMessages: vi.fn(),
-        postMessage: vi.fn().mockResolvedValue({ id: "m" }),
-        addChannelPermission: vi.fn().mockResolvedValue(undefined),
-        getCurrentUserId: vi.fn().mockResolvedValue("bot"),
-        listGuildChannels: vi.fn().mockResolvedValue([]),
-        ...over,
-    };
-}
-describe("runShareCommand", () => {
-    let tmpHome;
-    let prevHome;
-    let cwd;
-    beforeEach(async () => {
-        tmpHome = path.join(os.tmpdir(), `share-${Math.random().toString(36).slice(2)}`);
-        cwd = path.join(tmpHome, "cwd");
-        await fs.mkdir(cwd, { recursive: true });
-        prevHome = process.env.MUONROI_CLI_HOME;
-        process.env.MUONROI_CLI_HOME = tmpHome;
-    });
-    afterEach(() => {
-        if (prevHome === undefined)
-            delete process.env.MUONROI_CLI_HOME;
-        else
-            process.env.MUONROI_CLI_HOME = prevHome;
-    });
-    it("explicit --product slug + raw user ID + existing channel", async () => {
-        await fs.writeFile(path.join(tmpHome, "discord-channels.json"), JSON.stringify({
-            version: 1,
-            items: {
-                "abc-myprod": {
-                    productSlug: "abc-myprod",
-                    channelId: "c1",
-                    guildId: "g1",
-                    createdAtUtc: "t",
-                    displayName: "MyProd",
-                },
-            },
-        }));
-        const client = makeClient();
-        const result = await runShareCommand({
-            cwd,
-            user: "123456789012345678",
-            product: "abc-myprod",
-            client,
-        });
-        expect(result.kind).toBe("granted");
-        expect(client.addChannelPermission).toHaveBeenCalled();
-    });
-    it("parses <@id> mention format", async () => {
-        const client = makeClient();
-        const result = await runShareCommand({
-            cwd,
-            user: "<@123456789012345678>",
-            product: "abc",
-            client,
-        });
-        expect(result.kind).toBe("acl-only");
-    });
-    it("parses <@!id> escaped mention format", async () => {
-        const client = makeClient();
-        const result = await runShareCommand({
-            cwd,
-            user: "<@!555555555555555555>",
-            product: "abc",
-            client,
-        });
-        expect(result.kind).toBe("acl-only");
-    });
-    it("rejects malformed user ID", async () => {
-        const client = makeClient();
-        const result = await runShareCommand({
-            cwd,
-            user: "@no-digits-here",
-            product: "abc",
-            client,
-        });
-        expect(result.kind).toBe("error");
-        expect(client.addChannelPermission).not.toHaveBeenCalled();
-    });
-    it("missing channel → acl-only result, no API call", async () => {
-        const client = makeClient();
-        const result = await runShareCommand({
-            cwd,
-            user: "111111111111111111",
-            product: "abc",
-            client,
-        });
-        expect(result.kind).toBe("acl-only");
-        expect(client.addChannelPermission).not.toHaveBeenCalled();
-    });
-    it("re-adding same user → already-stakeholder result", async () => {
-        const { addStakeholder } = await import("../../product-loop/stakeholder-acl.js");
-        await addStakeholder("abc", {
-            discordUserId: "111111111111111111",
-            displayName: "u",
-            addedAtUtc: "t",
-            addedBy: "cli",
-        });
-        const client = makeClient();
-        const result = await runShareCommand({
-            cwd,
-            user: "111111111111111111",
-            product: "abc",
-            client,
-        });
-        expect(result.kind).toBe("already-stakeholder");
-    });
-    it("50007 permission error → error result, ACL persisted", async () => {
-        await fs.writeFile(path.join(tmpHome, "discord-channels.json"), JSON.stringify({
-            version: 1,
-            items: { abc: { productSlug: "abc", channelId: "c1", guildId: "g1", createdAtUtc: "t", displayName: "x" } },
-        }));
-        const err = Object.assign(new Error("50007"), { status: 403 });
-        const client = makeClient({ addChannelPermission: vi.fn().mockRejectedValue(err) });
-        const result = await runShareCommand({
-            cwd,
-            user: "111111111111111111",
-            product: "abc",
-            client,
-        });
-        expect(result.kind).toBe("perm-error");
-        const { listStakeholders } = await import("../../product-loop/stakeholder-acl.js");
-        expect(await listStakeholders("abc")).toHaveLength(1);
-    });
-    it("--product missing AND no recent manifest → error", async () => {
-        const client = makeClient();
-        const result = await runShareCommand({ cwd, user: "111111111111111111", client });
-        expect(result.kind).toBe("error");
-    });
-    it("derives product from most recent manifest when --product absent", async () => {
-        const flowDir = path.join(cwd, ".flow", "runs", "r1");
-        await fs.mkdir(flowDir, { recursive: true });
-        await fs.writeFile(path.join(flowDir, "manifest.json"), JSON.stringify({
-            idea: "Build a chat app",
-            capUsd: 10,
-            maxSprints: 6,
-            doneThreshold: 0.8,
-            createdAt: new Date().toISOString(),
-        }));
-        const client = makeClient();
-        const result = await runShareCommand({ cwd, user: "111111111111111111", client });
-        expect(result.kind).toBe("acl-only");
-    });
-    it("skips corrupt manifest JSON when scanning runs dir", async () => {
-        const flowDir = path.join(cwd, ".flow", "runs", "r1");
-        await fs.mkdir(flowDir, { recursive: true });
-        // Write a corrupt manifest — should be skipped gracefully
-        await fs.writeFile(path.join(flowDir, "manifest.json"), "{ bad json");
-        const client = makeClient();
-        // Should fall through to "no manifest found" → error
-        const result = await runShareCommand({ cwd, user: "111111111111111111", client });
-        expect(result.kind).toBe("error");
-    });
-    it("corrupt channel mapping JSON → treated as missing channel (acl-only)", async () => {
-        await fs.writeFile(path.join(tmpHome, "discord-channels.json"), "{ corrupt }");
-        const client = makeClient();
-        const result = await runShareCommand({
-            cwd,
-            user: "111111111111111111",
-            product: "abc",
-            client,
-        });
-        // Corrupt mapping = null mapping = acl-only result
-        expect(result.kind).toBe("acl-only");
-    });
-});
-//# sourceMappingURL=share-cmd.test.js.map

package/dist/src/cli/config/__tests__/model-picker.test.d.ts

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