sailfork / t3code-github / apps/ mobile/ src/ features/ threads/ thread-provider-instance.test.ts

import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
import {
  EnvironmentId,
  ProjectId,
  ProviderInstanceId,
  ThreadId,
  type ServerConfig,
} from "@t3tools/contracts";
import { describe, expect, it } from "vite-plus/test";
import { Atom, AtomRegistry } from "effect/reactivity";

import { computeThreadMoveAvailability, createThreadMovePlanner } from "./threadOrder";
import { makeThreadShellFixture } from "../../test-fixtures";
import { createThreadListEnvironmentsAtom } from "../../state/thread-list-environments";

import {
  createThreadRowProviderInstanceResolver,
  resolveThreadProviderInstance,
} from "./thread-provider-instance";

function makeConfig(
  providers: ReadonlyArray<{
    readonly instanceId: string;
    readonly driver: string;
    readonly displayName?: string;
    readonly accentColor?: string;
  }>,
): ServerConfig {
  return {
    providers: providers.map((provider) => ({ enabled: true, ...provider })),
    environment: { capabilities: {}, platform: { machine: "laptop" } },
    settings: {},
  } as unknown as ServerConfig;
}

function makeThread(environmentId: EnvironmentId, instanceId: string): EnvironmentThreadShell {
  return {
    environmentId,
    id: ThreadId.make("thread-1"),
    projectId: ProjectId.make("project-1"),
    title: "Thread",
    modelSelection: { instanceId: ProviderInstanceId.make(instanceId), model: "gpt-5.4" },
    runtimeMode: "full-access",
    interactionMode: "default",
    branch: null,
    worktreePath: null,
    latestRun: null,
    createdAt: "2026-06-01T00:00:00.000Z",
    updatedAt: "2026-06-01T00:00:00.000Z",
    archivedAt: null,
    settledOverride: null,
    settledAt: null,
    runtime: null,
    latestUserMessageAt: null,
    hasPendingApprovals: false,
    hasPendingUserInput: false,
    hasActionableProposedPlan: false,
  } as unknown as EnvironmentThreadShell;
}

describe("resolveThreadProviderInstance", () => {
  it("resolves two environments with the same default instance id independently", () => {
    const environmentA = EnvironmentId.make("environment-a");
    const environmentB = EnvironmentId.make("environment-b");
    const serverConfigs = new Map<EnvironmentId, ServerConfig>([
      [
        environmentA,
        makeConfig([{ instanceId: "codex", driver: "codex", accentColor: "#ff8800" }]),
      ],
      [environmentB, makeConfig([{ instanceId: "codex", driver: "codex" }])],
    ]);

    const threadA = makeThread(environmentA, "codex");
    const threadB = makeThread(environmentB, "codex");

    expect(
      resolveThreadProviderInstance(serverConfigs.get(environmentA)?.providers, threadA)
        ?.accentColor,
    ).toBe("#ff8800");
    expect(
      resolveThreadProviderInstance(serverConfigs.get(environmentB)?.providers, threadB)
        ?.accentColor,
    ).toBeUndefined();
  });

  it("uses the current runtime owner after a provider handoff", () => {
    const environmentId = EnvironmentId.make("environment-a");
    const serverConfigs = new Map<EnvironmentId, ServerConfig>([
      [
        environmentId,
        makeConfig([
          { instanceId: "claudeAgent", driver: "claudeAgent" },
          { instanceId: "codex", driver: "codex", displayName: "Codex" },
          { instanceId: "codex_work", driver: "codex", displayName: "Codex" },
        ]),
      ],
    ]);
    const thread = {
      ...makeThread(environmentId, "claudeAgent"),
      runtime: {
        status: "running" as const,
        activeRunId: null,
        providerInstanceId: ProviderInstanceId.make("codex_work"),
        providerName: "Codex",
        lastError: null,
        updatedAt: "2026-06-01T00:01:00.000Z",
      },
    };

    expect(
      resolveThreadProviderInstance(serverConfigs.get(environmentId)?.providers, thread),
    ).toMatchObject({
      driverKind: "codex",
      displayName: "Codex Work",
      showBadge: true,
    });
  });
});

describe("createThreadRowProviderInstanceResolver", () => {
  it("updates thread badges through the environment projection when a sibling is disabled and re-enabled", () => {
    const environmentId = EnvironmentId.make("environment-a");
    const personal = makeThread(environmentId, "codex");
    const work = makeThread(environmentId, "codex_work");
    const config = makeConfig([
      { instanceId: "codex", driver: "codex" },
      { instanceId: "codex_work", driver: "codex" },
    ]);
    const configs = Atom.make<ReadonlyMap<EnvironmentId, ServerConfig>>(
      new Map([[environmentId, config]]),
    );
    const environments = createThreadListEnvironmentsAtom(configs, Atom.make([environmentId]));
    const registry = AtomRegistry.make();
    registry.mount(environments);
    try {
      const before = createThreadRowProviderInstanceResolver(
        registry.get(environments).providersByEnvironmentId,
      );
      expect(before(personal)?.showBadge).toBe(true);
      expect(before(work)?.showBadge).toBe(true);

      registry.set(
        configs,
        new Map([
          [
            environmentId,
            {
              ...config,
              providers: config.providers.map((provider) =>
                provider.instanceId === "codex_work" ? { ...provider, enabled: false } : provider,
              ),
            },
          ],
        ]),
      );
      const disabled = createThreadRowProviderInstanceResolver(
        registry.get(environments).providersByEnvironmentId,
      );
      expect(disabled(personal)?.showBadge).toBe(false);
      expect(disabled(work)?.showBadge).toBe(true);

      registry.set(configs, new Map([[environmentId, config]]));
      const restored = createThreadRowProviderInstanceResolver(
        registry.get(environments).providersByEnvironmentId,
      );
      expect(restored(personal)?.showBadge).toBe(true);
      expect(restored(work)?.showBadge).toBe(true);
    } finally {
      registry.dispose();
    }
  });
});

describe("thread list reorder availability", () => {
  it.each(["active", "pinned"] as const)(
    "updates %s moves on disconnect and reconnect without changing cached config",
    (section) => {
      const onlineId = EnvironmentId.make("online");
      const offlineId = EnvironmentId.make("offline");
      const config = makeConfig([{ instanceId: "codex", driver: "codex" }]);
      const configs = Atom.make<ReadonlyMap<EnvironmentId, ServerConfig>>(
        new Map([
          [onlineId, config],
          [offlineId, config],
        ]),
      );
      const connected = Atom.make<ReadonlyArray<EnvironmentId>>([onlineId, offlineId]);
      const environments = createThreadListEnvironmentsAtom(configs, connected);
      const registry = AtomRegistry.make();
      registry.mount(environments);
      try {
        const ordered = [onlineId, offlineId].map((environmentId, index) =>
          makeThreadShellFixture({
            environmentId,
            id: ThreadId.make(`thread-${index}`),
            pinnedAt: section === "pinned" ? "2026-09-02T00:00:00.000Z" : null,
          }),
        );
        const movedId = `${onlineId}:thread-0`;
        const plannerInput = () => {
          const current = registry.get(environments);
          return {
            ordered,
            section,
            reorderableEnvironmentIds:
              section === "pinned"
                ? current.pinReorderEnvironmentIds
                : current.activeReorderEnvironmentIds,
          };
        };
        expect(createThreadMovePlanner(plannerInput())(movedId, "down")).toHaveLength(2);
        const before = registry.get(environments);

        registry.set(connected, [onlineId]);

        expect(createThreadMovePlanner(plannerInput())(movedId, "down")).toBeNull();
        expect(computeThreadMoveAvailability(plannerInput()).get(movedId)?.canMoveDown).toBe(false);
        expect(registry.get(environments).pinningEnvironmentIds.has(offlineId)).toBe(true);
        expect(registry.get(environments).settlementEnvironmentIds.has(offlineId)).toBe(true);
        expect(registry.get(environments).providersByEnvironmentId.get(offlineId)).toBe(
          before.providersByEnvironmentId.get(offlineId),
        );

        const keyedInput = {
          ...plannerInput(),
          ordered: ordered.map((row, index) => ({
            ...row,
            pinOrderKey: section === "pinned" ? (index === 0 ? "bb" : "dd") : null,
            activeOrderKey: section === "active" ? (index === 0 ? "bb" : "dd") : null,
          })),
        };
        expect(createThreadMovePlanner(keyedInput)(movedId, "down")).toEqual([
          expect.objectContaining({ id: movedId }),
        ]);
        expect(createThreadMovePlanner(keyedInput)(`${offlineId}:thread-1`, "up")).toBeNull();
        expect(computeThreadMoveAvailability(keyedInput).get(movedId)?.canMoveDown).toBe(true);
        expect(computeThreadMoveAvailability(keyedInput).get(`${offlineId}:thread-1`)).toEqual({
          canMoveUp: false,
          canMoveDown: false,
        });

        const updatedConfig = {
          ...config,
          settings: {
            ...config.settings,
            snoozePresets: [{ kind: "after" as const, minutes: 90 }],
          },
        };
        registry.set(
          configs,
          new Map([
            [onlineId, config],
            [offlineId, updatedConfig],
          ]),
        );

        const updated = registry.get(environments);
        expect(updated.snoozePresetsByEnvironmentId.get(offlineId)).toEqual(
          updatedConfig.settings.snoozePresets,
        );
        expect(updated.pinReorderEnvironmentIds.has(offlineId)).toBe(false);
        expect(updated.activeReorderEnvironmentIds.has(offlineId)).toBe(false);
        expect(createThreadMovePlanner(plannerInput())(movedId, "down")).toBeNull();

        registry.set(
          configs,
          new Map([
            [onlineId, config],
            [
              offlineId,
              {
                ...updatedConfig,
                settings: {
                  ...updatedConfig.settings,
                  snoozePresets: updatedConfig.settings.snoozePresets.map((preset) => ({
                    ...preset,
                  })),
                },
              },
            ],
          ]),
        );
        expect(registry.get(environments)).toBe(updated);

        registry.set(connected, [onlineId, offlineId]);

        expect(createThreadMovePlanner(plannerInput())(movedId, "down")).toHaveLength(2);
        expect(computeThreadMoveAvailability(plannerInput()).get(movedId)?.canMoveDown).toBe(true);
        expect(registry.get(environments).snoozePresetsByEnvironmentId.get(offlineId)).toBe(
          updated.snoozePresetsByEnvironmentId.get(offlineId),
        );

        registry.set(configs, new Map([[onlineId, config]]));

        expect(createThreadMovePlanner(plannerInput())(movedId, "down")).toBeNull();
        expect(computeThreadMoveAvailability(plannerInput()).get(movedId)?.canMoveDown).toBe(false);
      } finally {
        registry.dispose();
      }
    },
  );
});