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.
import * as NodeServices from "@effect/platform-node/NodeServices";
import {
ProviderDriverKind,
ProviderInstanceId,
resolveProviderInstanceEnabled,
} from "@akeru/contracts";
import { assert, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as SqlClient from "effect/unstable/sql/SqlClient";
import * as ServerConfig from "./config.ts";
import * as ServerSettingsModule from "./serverSettings.ts";
import { recordProviderUsage, makeServerSettingsLayer } from "./serverSettingsTestSupport.ts";
it.layer(NodeServices.layer)("server settings", (it) => {
it.effect("enables previously used providers from sparse settings files", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* fileSystem.writeFileString(
serverConfig.settingsPath,
'{"providers":{"opencode":{"serverUrl":"http://127.0.0.1:4096"}}}',
);
yield* recordProviderUsage("opencode");
const settings = yield* serverSettings.getSettings;
assert.isFalse(settings.providers.grok.enabled);
assert.isTrue(settings.providers.opencode.enabled);
assert.equal(settings.providers.opencode.serverUrl, "http://127.0.0.1:4096");
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("preserves existing provider instances without explicit enabled flags", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* fileSystem.writeFileString(
serverConfig.settingsPath,
'{"providerInstances":{"grok_work":{"driver":"grok","config":{}},"grok":{"driver":"grok","config":{}},"opencode_work":{"driver":"opencode","config":{"serverUrl":"http://127.0.0.1:4096"}},"opencode_unused":{"driver":"opencode","config":{}}}}',
);
yield* recordProviderUsage("grok", "grok_work");
yield* recordProviderUsage("grok", null);
yield* recordProviderUsage("opencode", "opencode_work");
const settings = yield* serverSettings.getSettings;
assert.isTrue(settings.providerInstances[ProviderInstanceId.make("grok_work")]?.enabled);
assert.isTrue(settings.providerInstances[ProviderInstanceId.make("grok")]?.enabled);
assert.isTrue(settings.providerInstances[ProviderInstanceId.make("opencode_work")]?.enabled);
const unused = settings.providerInstances[ProviderInstanceId.make("opencode_unused")];
assert.isDefined(unused);
assert.isFalse(resolveProviderInstanceEnabled(unused));
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("preserves explicit provider disables in existing settings files", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* fileSystem.writeFileString(
serverConfig.settingsPath,
'{"providers":{"grok":{"enabled":false},"opencode":{"enabled":false}},"providerInstances":{"grok":{"driver":"grok","enabled":false,"config":{}},"opencode":{"driver":"opencode","config":{"enabled":false}}}}',
);
yield* recordProviderUsage("grok");
yield* recordProviderUsage("opencode");
const settings = yield* serverSettings.getSettings;
assert.isFalse(settings.providers.grok.enabled);
assert.isFalse(settings.providers.opencode.enabled);
assert.isFalse(settings.providerInstances[ProviderInstanceId.make("grok")]?.enabled);
assert.isFalse(settings.providerInstances[ProviderInstanceId.make("opencode")]?.enabled);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("skips a disabled provider instance when picking the text generation fallback", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
// The Providers UI writes providerInstances only, so the legacy providers
// map decodes to defaults where codex is enabled and listed first.
yield* fileSystem.writeFileString(
serverConfig.settingsPath,
'{"providerInstances":{"codex":{"driver":"codex","enabled":false,"config":{}}}}',
);
const settings = yield* serverSettings.getSettings;
assert.equal(settings.textGenerationModelSelection.instanceId, "claudeAgent");
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("moves a saved Cursor text generation selection to a live provider", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* fileSystem.writeFileString(
serverConfig.settingsPath,
'{"providers":{"cursor":{"enabled":true}},"textGenerationModelSelection":{"instanceId":"cursor","model":"composer-2"}}',
);
const settings = yield* serverSettings.getSettings;
assert.equal(settings.textGenerationModelSelection.instanceId, "codex");
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("skips providers without text generation when leaving Cursor", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* fileSystem.writeFileString(
serverConfig.settingsPath,
'{"providers":{"codex":{"enabled":false},"claudeAgent":{"enabled":false},"cursor":{"enabled":true},"grok":{"enabled":false},"kimi":{"enabled":true},"opencode":{"enabled":true}},"textGenerationModelSelection":{"instanceId":"cursor","model":"composer-2"}}',
);
const settings = yield* serverSettings.getSettings;
assert.equal(settings.textGenerationModelSelection.instanceId, "opencode");
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("keeps unused providers disabled in existing sparse settings files", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* fileSystem.writeFileString(serverConfig.settingsPath, "{}");
const settings = yield* serverSettings.getSettings;
assert.isFalse(settings.providers.grok.enabled);
assert.isFalse(settings.providers.opencode.enabled);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("preserves provider history when no settings file exists", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* recordProviderUsage("grok");
const settings = yield* serverSettings.getSettings;
assert.isTrue(settings.providers.grok.enabled);
assert.isFalse(settings.providers.opencode.enabled);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("preserves provider history when the settings file is invalid", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* fileSystem.writeFileString(serverConfig.settingsPath, "{invalid json");
yield* recordProviderUsage("grok");
const settings = yield* serverSettings.getSettings;
assert.isTrue(settings.providers.grok.enabled);
assert.isFalse(settings.providers.opencode.enabled);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("preserves valid provider flags when another settings field is invalid", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* fileSystem.writeFileString(
serverConfig.settingsPath,
'{"addProjectBaseDirectory":42,"providers":{"opencode":{"enabled":false},"grok":{"enabled":true}}}',
);
yield* recordProviderUsage("opencode");
const settings = yield* serverSettings.getSettings;
assert.isFalse(settings.providers.opencode.enabled);
assert.isTrue(settings.providers.grok.enabled);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("restores providers from persisted runtime sessions", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const sql = yield* SqlClient.SqlClient;
yield* sql`
INSERT INTO provider_session_runtime (
thread_id,
provider_name,
provider_instance_id,
adapter_key,
status,
last_seen_at
)
VALUES (
${"thread-opencode-runtime"},
${"opencode"},
${"opencode"},
${"opencode"},
${"ready"},
${"2026-08-25T00:00:00.000Z"}
)
`;
const settings = yield* serverSettings.getSettings;
assert.isFalse(settings.providers.grok.enabled);
assert.isTrue(settings.providers.opencode.enabled);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("persists explicit disables after a provider has been used", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* recordProviderUsage("grok");
assert.isTrue((yield* serverSettings.getSettings).providers.grok.enabled);
const settings = yield* serverSettings.updateSettings({
providers: { grok: { enabled: false } },
});
assert.isFalse(settings.providers.grok.enabled);
const raw = yield* fileSystem.readFileString(serverConfig.settingsPath);
assert.isFalse(JSON.parse(raw).providers.grok.enabled);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("persists explicit provider enables before their first use", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* serverSettings.updateSettings({
providers: {
grok: { enabled: true },
opencode: { enabled: true },
},
});
yield* serverSettings.updateSettings({ addProjectBaseDirectory: "~/Development" });
const raw = yield* fileSystem.readFileString(serverConfig.settingsPath);
const persisted = JSON.parse(raw);
assert.isTrue(persisted.providers.grok.enabled);
assert.isTrue(persisted.providers.opencode.enabled);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("keeps optional providers disabled after a new installation writes settings", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const initial = yield* serverSettings.getSettings;
assert.isFalse(initial.providers.grok.enabled);
assert.isFalse(initial.providers.opencode.enabled);
const next = yield* serverSettings.updateSettings({
addProjectBaseDirectory: "~/Development",
providerInstances: {
[ProviderInstanceId.make("grok")]: {
driver: ProviderDriverKind.make("grok"),
config: {},
},
},
});
assert.isFalse(next.providers.grok.enabled);
assert.isFalse(next.providers.opencode.enabled);
const grok = next.providerInstances[ProviderInstanceId.make("grok")];
assert.isDefined(grok);
assert.isFalse(resolveProviderInstanceEnabled(grok));
const raw = yield* fileSystem.readFileString(serverConfig.settingsPath);
const persisted = JSON.parse(raw);
assert.isFalse(persisted.providers.grok.enabled);
assert.isFalse(persisted.providers.opencode.enabled);
assert.isUndefined(persisted.providerInstances.grok.enabled);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("keeps OpenCode Go disabled after settings reload", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* fileSystem.writeFileString(
serverConfig.settingsPath,
'{"providers":{"opencodeGo":{"enabled":false}}}',
);
const settings = yield* serverSettings.getSettings;
assert.isFalse(settings.providers.opencodeGo.enabled);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("folds a legacy in-config enabled flag into the envelope on load", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
// Old settings files can carry both flags with conflicting values.
// The explicit false must win so a user's disable sticks.
yield* fileSystem.writeFileString(
serverConfig.settingsPath,
'{"providerInstances":{"grok":{"driver":"grok","enabled":true,"config":{"enabled":false}},"codex_work":{"driver":"codex","config":{"enabled":true,"homePath":"~/.codex"}},"cursor":{"driver":"cursor","config":{"enabled":"nope"}}}}',
);
const settings = yield* serverSettings.getSettings;
const grokId = ProviderInstanceId.make("grok");
const codexWorkId = ProviderInstanceId.make("codex_work");
assert.deepEqual(settings.providerInstances[grokId], {
driver: ProviderDriverKind.make("grok"),
enabled: false,
config: {},
});
// A lone in-config flag is lifted to the envelope and stripped.
assert.deepEqual(settings.providerInstances[codexWorkId], {
driver: ProviderDriverKind.make("codex"),
enabled: true,
config: { homePath: "~/.codex" },
});
// A malformed flag is left alone so driver schema validation can
// surface it instead of the fold silently repairing the config.
assert.deepEqual(settings.providerInstances[ProviderInstanceId.make("cursor")], {
driver: ProviderDriverKind.make("cursor"),
config: { enabled: "nope" },
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("folds in-config enabled flags arriving through updates", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const grokId = ProviderInstanceId.make("grok");
const next = yield* serverSettings.updateSettings({
providerInstances: {
[grokId]: {
driver: ProviderDriverKind.make("grok"),
enabled: true,
config: { enabled: false, binaryPath: "/opt/grok" },
},
},
});
assert.deepEqual(next.providerInstances[grokId], {
driver: ProviderDriverKind.make("grok"),
enabled: false,
config: { binaryPath: "/opt/grok" },
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
});