Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

10.4 KB
Raw Blame
import { describe, expect, it } from "vite-plus/test";
import { ProviderDriverKind, ProviderInstanceId } from "./providerInstance.ts";
import {
  DEFAULT_SERVER_SETTINGS,
  defaultEnabledForDriver,
  resolveProviderInstanceEnabled,
} from "./settings.ts";
import {
  decodeServerSettings,
  decodeServerSettingsPatch,
  decodeServerSettingsRpcPatch,
  decodeClaudeSettings,
} from "./settings.test-support.ts";

describe("ServerSettings voice", () => {
  it("rejects unsupported providers and voices", () => {
    expect(() => decodeServerSettings({ voice: { provider: "xai" } })).toThrow();
    expect(() => decodeServerSettingsPatch({ voice: { voice: "unknown" } })).toThrow();
  });
});

describe("ClaudeSettings auto-compaction", () => {
  it("uses Claude's default threshold when no override is configured", () => {
    expect(decodeClaudeSettings({}).autoCompactWindow).toBe("");
  });

  it.each(["100000", "300000", "1000000"])(
    "accepts a supported auto-compaction threshold: %s",
    (value) => {
      expect(decodeClaudeSettings({ autoCompactWindow: value }).autoCompactWindow).toBe(value);
    },
  );

  it.each(["99999", "1000001", "300k", "invalid"])(
    "rejects an unsupported auto-compaction threshold: %s",
    (value) => {
      expect(() => decodeClaudeSettings({ autoCompactWindow: value })).toThrow();
    },
  );

  it("rejects an unsupported threshold at the settings patch boundary", () => {
    expect(() =>
      decodeServerSettingsPatch({ providers: { claudeAgent: { autoCompactWindow: "300k" } } }),
    ).toThrow();
    expect(
      decodeServerSettingsPatch({ providers: { claudeAgent: { autoCompactWindow: "300000" } } }),
    ).toBeDefined();
  });
});

describe("ServerSettings sandbox providers", () => {
  it("defaults to local with cloud providers disconnected", () => {
    expect(decodeServerSettings({}).sandbox).toEqual({
      defaultProvider: "local",
      autoIdle: true,
      providers: {
        e2b: { environment: [] },
        daytona: { environment: [] },
        vercel: { environment: [] },
        upstash: { environment: [] },
        ascii: { environment: [] },
        railway: { environment: [] },
        tenki: { environment: [] },
      },
    });
  });

  it("accepts a provider credential patch", () => {
    expect(
      decodeServerSettingsPatch({
        sandbox: {
          defaultProvider: "e2b",
          providers: {
            e2b: {
              environment: [{ name: "E2B_API_KEY", value: "secret", sensitive: true }],
            },
          },
        },
      }).sandbox,
    ).toEqual({
      defaultProvider: "e2b",
      providers: {
        e2b: {
          environment: [{ name: "E2B_API_KEY", value: "secret", sensitive: true }],
        },
      },
    });
  });

  it("accepts the Ascii Box credential", () => {
    expect(
      decodeServerSettingsPatch({
        sandbox: {
          providers: {
            ascii: {
              environment: [{ name: "BOX_API_KEY", value: "secret", sensitive: true }],
            },
          },
        },
      }).sandbox?.providers?.ascii?.environment,
    ).toEqual([{ name: "BOX_API_KEY", value: "secret", sensitive: true }]);
  });

  it("accepts Tenki's secret API key", () => {
    expect(
      decodeServerSettingsRpcPatch({
        sandbox: {
          providers: {
            tenki: {
              environment: [{ name: "TENKI_API_KEY", value: "secret", sensitive: true }],
            },
          },
        },
      }).sandbox?.providers?.tenki?.environment,
    ).toEqual([{ name: "TENKI_API_KEY", value: "secret", sensitive: true }]);
  });

  it("keeps automatic idle cleanup enabled", () => {
    expect(() => decodeServerSettingsPatch({ sandbox: { autoIdle: false } })).toThrow();
  });
});

describe("ServerSettings.providerInstances (slice-2 invariant)", () => {
  it("defaults text generation to Luna at low reasoning effort", () => {
    expect(DEFAULT_SERVER_SETTINGS.textGenerationModelSelection).toEqual({
      instanceId: ProviderInstanceId.make("codex"),
      model: "gpt-6-luna",
      options: [{ id: "reasoningEffort", value: "low" }],
    });
  });

  it("defaults to an empty record so legacy configs without the key still decode", () => {
    expect(DEFAULT_SERVER_SETTINGS.providerInstances).toEqual({});
  });

  it("decodes a fully empty config (legacy on-disk shape) without complaint", () => {
    const decoded = decodeServerSettings({});
    expect(decoded.providerInstances).toEqual({});
    // Legacy `providers` struct is still hydrated with its per-driver defaults
    // so existing call sites keep working through the migration.
    expect(decoded.providers.codex.enabled).toBe(true);
  });

  it("decodes a multi-instance map mixing first-party and fork drivers", () => {
    const decoded = decodeServerSettings({
      providerInstances: {
        codex_personal: {
          driver: "codex",
          displayName: "Codex (personal)",
          config: { homePath: "~/.codex_personal" },
        },
        codex_work: {
          driver: "codex",
          config: { homePath: "~/.codex_work" },
        },
        ollama_local: {
          driver: "ollama",
          displayName: "Ollama (local)",
          config: { endpoint: "http://localhost:11434" },
        },
      },
    });

    const personalId = ProviderInstanceId.make("codex_personal");
    const workId = ProviderInstanceId.make("codex_work");
    const ollamaId = ProviderInstanceId.make("ollama_local");

    expect(decoded.providerInstances[personalId]?.driver).toBe("codex");
    expect(decoded.providerInstances[workId]?.config).toEqual({ homePath: "~/.codex_work" });
    // Critical: a config naming a driver this build does not know about
    // (`ollama` is not in `ProviderDriverKind`) must round-trip without loss.
    // The runtime handles "driver not installed" — the schema must not.
    expect(decoded.providerInstances[ollamaId]?.driver).toBe("ollama");
    expect(decoded.providerInstances[ollamaId]?.config).toEqual({
      endpoint: "http://localhost:11434",
    });
  });

  it("rejects instance keys that violate the slug pattern", () => {
    expect(() =>
      decodeServerSettings({
        providerInstances: { "1bad": { driver: "codex" } },
      }),
    ).toThrow();
  });
});

describe("provider enabled defaults", () => {
  it("enables only the stable bindings by default", () => {
    const decoded = decodeServerSettings({});
    expect(decoded.providers.codex.enabled).toBe(true);
    expect(decoded.providers.claudeAgent.enabled).toBe(true);
    expect(decoded.providers.grok.enabled).toBe(false);
    expect(decoded.providers.grok.verboseProtocolLogging).toBe(false);
    expect(decoded.providers.opencode.enabled).toBe(false);
    expect(decoded.providers.opencodeGo.enabled).toBe(true);
  });

  it("decodes ACP protocol logging opt-ins for Grok", () => {
    const decoded = decodeServerSettings({
      providers: {
        grok: { verboseProtocolLogging: true },
      },
    });

    expect(decoded.providers.grok.verboseProtocolLogging).toBe(true);
  });

  it("derives per-driver defaults from the settings schemas", () => {
    expect(defaultEnabledForDriver(ProviderDriverKind.make("codex"))).toBe(true);
    expect(defaultEnabledForDriver(ProviderDriverKind.make("grok"))).toBe(false);
    expect(defaultEnabledForDriver(ProviderDriverKind.make("opencodeGo"))).toBe(true);
    // Unknown fork drivers stay enabled; their own build decides otherwise.
    expect(defaultEnabledForDriver(ProviderDriverKind.make("ollama"))).toBe(true);
  });

  it("still decodes settings that name the retired Cursor provider", () => {
    const cursor = ProviderDriverKind.make("cursor");
    const cursorId = ProviderInstanceId.make("cursor");

    const decoded = decodeServerSettings({
      providers: { cursor: { enabled: true, binaryPath: "cursor-agent" } },
      providerInstances: {
        [cursorId]: { driver: cursor, enabled: true, config: { binaryPath: "cursor-agent" } },
      },
    });

    // The legacy map drops the key; the instance envelope survives opaquely and
    // the registry reports it as an unavailable driver.
    expect(decoded.providers).not.toHaveProperty("cursor");
    expect(decoded.providerInstances[cursorId]?.driver).toBe(cursor);
    expect(decodeServerSettingsPatch({ providers: { cursor: { enabled: false } } })).toEqual({
      providers: {},
    });
  });

  it("resolves instance enabled state with explicit false winning", () => {
    const grok = ProviderDriverKind.make("grok");
    const codex = ProviderDriverKind.make("codex");
    // No flags anywhere: driver default applies.
    expect(resolveProviderInstanceEnabled({ driver: grok, config: {} })).toBe(false);
    expect(resolveProviderInstanceEnabled({ driver: codex, config: {} })).toBe(true);
    // Envelope flag wins over the driver default.
    expect(resolveProviderInstanceEnabled({ driver: grok, enabled: true, config: {} })).toBe(true);
    expect(resolveProviderInstanceEnabled({ driver: codex, enabled: false, config: {} })).toBe(
      false,
    );
    // Legacy in-config flag fills in when the envelope is silent.
    expect(resolveProviderInstanceEnabled({ driver: grok, config: { enabled: true } })).toBe(true);
    // Conflicting flags: the explicit false wins, whichever side it is on.
    expect(
      resolveProviderInstanceEnabled({ driver: grok, enabled: true, config: { enabled: false } }),
    ).toBe(false);
    expect(
      resolveProviderInstanceEnabled({ driver: codex, enabled: false, config: { enabled: true } }),
    ).toBe(false);
  });
});

describe("ServerSettingsPatch.providerInstances", () => {
  it("treats providerInstances as an optional whole-map replacement", () => {
    const patch = decodeServerSettingsPatch({});
    expect(patch.providerInstances).toBeUndefined();

    const replacement = decodeServerSettingsPatch({
      providerInstances: {
        codex_personal: { driver: "codex", config: { homePath: "~/.codex" } },
      },
    });

    expect(replacement.providerInstances).toBeDefined();
    expect(replacement.providerInstances?.[ProviderInstanceId.make("codex_personal")]?.driver).toBe(
      "codex",
    );
  });

  it("preserves a fork-defined driver entry through patch decoding", () => {
    const patch = decodeServerSettingsPatch({
      providerInstances: {
        ollama_local: {
          driver: "ollama",
          config: { endpoint: "http://localhost:11434" },
        },
      },
    });

    const ollamaId = ProviderInstanceId.make("ollama_local");
    expect(patch.providerInstances?.[ollamaId]?.driver).toBe("ollama");
  });
});