import { describe, expect, it, vi } from "vitest";

import { createCommandHandlers } from "./tui-command-handlers.js";

import {

TUI_RECENT_SESSIONS_ACTIVE_MINUTES,

TUI_SESSION_PICKER_LIMIT,

} from "./tui-session-list-policy.js";

type LoadHistoryMock = ReturnType<typeof vi.fn> & (() => Promise<void>);

type RunAuthFlow = NonNullable<Parameters<typeof createCommandHandlers>[0]["runAuthFlow"]>;

function createHarness(params?: {

sendChat?: ReturnType<typeof vi.fn>;

getGatewayStatus?: ReturnType<typeof vi.fn>;

listSessions?: ReturnType<typeof vi.fn>;

patchSession?: ReturnType<typeof vi.fn>;

resetSession?: ReturnType<typeof vi.fn>;

runAuthFlow?: RunAuthFlow;

}) {

const sendChat = params?.sendChat ?? vi.fn().mockResolvedValue({ runId: "r1" });

const getGatewayStatus = params?.getGatewayStatus ?? vi.fn().mockResolvedValue({});

const listSessions = params?.listSessions ?? vi.fn().mockResolvedValue({ sessions: [] });

const patchSession = params?.patchSession ?? vi.fn().mockResolvedValue({});

const resetSession = params?.resetSession ?? vi.fn().mockResolvedValue({ ok: true });

const setSession = params?.setSession ?? (vi.fn().mockResolvedValue(undefined) as SetSessionMock);

sessionInfo: {},

};

const { handleCommand } = createCommandHandlers({

client: { sendChat, getGatewayStatus, patchSession, resetSession } as never,

const { handleCommand, openSessionSelector } = createCommandHandlers({

client: { sendChat, getGatewayStatus, listSessions, patchSession, resetSession } as never,

chatLog: { addUser, addSystem } as never,

tui: { requestRender } as never,

opts: params?.opts ?? {},

return {

handleCommand,

getGatewayStatus,

listSessions,

sendChat,

openSessionSelector,

openOverlay,

closeOverlay,

patchSession,

}

describe("tui command handlers", () => {

it("bounds session picker hydration to recent TUI sessions", async () => {

const listSessions = vi.fn().mockResolvedValue({

sessions: [

{

key: "agent:main:main",

displayName: "main",

updatedAt: Date.now(),

},

],

});

const { openSessionSelector } = createHarness({ listSessions });

await openSessionSelector();

expect(listSessions).toHaveBeenCalledWith({

limit: TUI_SESSION_PICKER_LIMIT,

activeMinutes: TUI_RECENT_SESSIONS_ACTIVE_MINUTES,

includeGlobal: false,

includeUnknown: false,

includeDerivedTitles: true,

includeLastMessage: true,

agentId: "main",

});

});

it("renders the sending indicator before chat.send resolves", async () => {

let resolveSend: (value: { runId: string }) => void = () => {

throw new Error("sendChat promise resolver was not initialized");