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 { DEFAULT_SERVER_SETTINGS, ProviderDriverKind, ProviderInstanceId } from "@akeru/contracts";
import { createModelSelection } from "@akeru/shared/model";
import { assert, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Duration from "effect/Duration";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as PlatformError from "effect/PlatformError";
import * as Stream from "effect/Stream";
import * as SqlClient from "effect/unstable/sql/SqlClient";
import * as ServerSecretStore from "./auth/ServerSecretStore.ts";
import * as ServerConfig from "./config.ts";
import { SqlitePersistenceMemory } from "./persistence/Layers/Sqlite.ts";
import * as ServerSettingsModule from "./serverSettings.ts";
import {
makeServerSettingsLayer,
decodeSettingsPatch,
decodeServerSettings,
} from "./serverSettingsTestSupport.ts";
it.layer(NodeServices.layer)("server settings", (it) => {
it.effect("identifies provider history query failures", () =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const sql = yield* SqlClient.SqlClient;
yield* sql`DROP TABLE projection_thread_sessions`;
const error = yield* Effect.flip(serverSettings.getSettings);
assert.deepInclude(error, {
_tag: "ServerSettingsError",
operation: "read-provider-history",
settingsPath: serverConfig.settingsPath,
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("reports an analytics opt-out deletion failure", () =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const baseDir = yield* fileSystem.makeTempDirectoryScoped({
prefix: "t3code-server-settings-analytics-opt-out-",
});
const configLayer = ServerConfig.layerTest(process.cwd(), baseDir);
const config = yield* ServerConfig.ServerConfig.pipe(Effect.provide(configLayer));
const cause = PlatformError.systemError({
_tag: "PermissionDenied",
module: "FileSystem",
method: "remove",
pathOrDescriptor: config.analyticsStatePath,
});
let failAnalyticsStateRemoval = true;
const failingFileSystem = FileSystem.FileSystem.of({
...fileSystem,
remove: (path, options) =>
failAnalyticsStateRemoval && path === config.analyticsStatePath
? Effect.fail(cause)
: fileSystem.remove(path, options),
});
const settingsLayer = ServerSettingsModule.layer.pipe(
Layer.provide(ServerSecretStore.layer),
Layer.provideMerge(Layer.fresh(SqlitePersistenceMemory)),
Layer.provideMerge(configLayer),
Layer.provide(Layer.succeed(FileSystem.FileSystem, failingFileSystem)),
);
yield* fileSystem.writeFileString(config.analyticsStatePath, "queued analytics");
yield* fileSystem.writeFileString(config.anonymousIdPath, "legacy identity");
const { error, stateRemained, analyticsEnabled } = yield* Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const error = yield* Effect.flip(
serverSettings.updateSettings({ analyticsEnabled: false }),
);
const stateRemained = yield* fileSystem.exists(config.analyticsStatePath);
failAnalyticsStateRemoval = false;
const settings = yield* serverSettings.updateSettings({ analyticsEnabled: false });
return { error, stateRemained, analyticsEnabled: settings.analyticsEnabled };
}).pipe(Effect.provide(settingsLayer));
assert.deepInclude(error, {
_tag: "ServerSettingsError",
operation: "remove-analytics-state",
settingsPath: config.analyticsStatePath,
});
assert.strictEqual(error.cause, cause);
assert.isTrue(stateRemained);
assert.isFalse(analyticsEnabled);
assert.isFalse(yield* fileSystem.exists(config.analyticsStatePath));
assert.isFalse(yield* fileSystem.exists(config.anonymousIdPath));
}),
);
it.effect("decodes nested settings patches", () =>
Effect.gen(function* () {
assert.deepEqual(
yield* decodeSettingsPatch({ providers: { codex: { binaryPath: "/tmp/codex" } } }),
{
providers: { codex: { binaryPath: "/tmp/codex" } },
},
);
assert.deepEqual(
yield* decodeSettingsPatch({
textGenerationModelSelection: {
options: [{ id: "fastMode", value: false }],
},
}),
{
textGenerationModelSelection: {
options: [{ id: "fastMode", value: false }],
},
},
);
}),
);
it.effect(
"decodes legacy object-shaped textGenerationModelSelection.options from settings.json",
() =>
Effect.gen(function* () {
const decoded = yield* decodeServerSettings({
textGenerationModelSelection: {
provider: ProviderDriverKind.make("codex"),
model: "gpt-5.4-mini",
options: { reasoningEffort: "low" },
},
});
assert.deepEqual(decoded.textGenerationModelSelection, {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.4-mini",
options: [{ id: "reasoningEffort", value: "low" }],
});
}),
);
it.effect("deep merges nested settings updates without dropping siblings", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* serverSettings.updateSettings({
providers: {
codex: {
binaryPath: "/usr/local/bin/codex",
homePath: "/Users/julius/.codex",
},
claudeAgent: {
binaryPath: "/usr/local/bin/claude",
customModels: ["claude-custom"],
},
},
textGenerationModelSelection: {
instanceId: ProviderInstanceId.make("codex"),
model: DEFAULT_SERVER_SETTINGS.textGenerationModelSelection.model,
options: createModelSelection(
ProviderInstanceId.make("codex"),
DEFAULT_SERVER_SETTINGS.textGenerationModelSelection.model,
[
{ id: "reasoningEffort", value: "high" },
{ id: "fastMode", value: true },
],
).options!,
},
});
const next = yield* serverSettings.updateSettings({
providers: {
codex: {
binaryPath: "/opt/homebrew/bin/codex",
},
},
textGenerationModelSelection: {
options: [{ id: "fastMode", value: false }],
},
});
assert.deepEqual(next.providers.codex, {
enabled: true,
binaryPath: "/opt/homebrew/bin/codex",
homePath: "/Users/julius/.codex",
shadowHomePath: "",
launchArgs: "",
customModels: [],
});
assert.deepEqual(next.providers.claudeAgent, {
enabled: true,
binaryPath: "/usr/local/bin/claude",
homePath: "",
customModels: ["claude-custom"],
launchArgs: "",
autoCompactWindow: "",
});
assert.deepEqual(
next.textGenerationModelSelection,
createModelSelection(
ProviderInstanceId.make("codex"),
DEFAULT_SERVER_SETTINGS.textGenerationModelSelection.model,
[
{ id: "reasoningEffort", value: "high" },
{ id: "fastMode", value: false },
],
),
);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("buffers changes after a subscription is acquired but before it is consumed", () =>
Effect.scoped(
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const changes = yield* serverSettings.subscribeChanges;
yield* serverSettings.updateSettings({
providers: {
codex: {
binaryPath: "/usr/local/bin/codex-next",
},
},
});
const firstChange = yield* changes.pipe(Stream.runHead, Effect.timeout("1 second"));
assert.equal(
Option.getOrUndefined(firstChange)?.providers.codex.binaryPath,
"/usr/local/bin/codex-next",
);
}),
).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("preserves model when switching providers via textGenerationModelSelection", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
// Start with Claude text generation selection
yield* serverSettings.updateSettings({
textGenerationModelSelection: {
instanceId: ProviderInstanceId.make("claudeAgent"),
model: "claude-sonnet-4-6",
options: createModelSelection(
ProviderInstanceId.make("claudeAgent"),
"claude-sonnet-4-6",
[{ id: "effort", value: "high" }],
).options!,
},
});
// Switch to Codex — the stale Claude "effort" in options must not
// cause the update to lose the selected model.
const next = yield* serverSettings.updateSettings({
textGenerationModelSelection: {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.4",
options: createModelSelection(ProviderInstanceId.make("codex"), "gpt-5.4", [
{ id: "reasoningEffort", value: "high" },
]).options!,
},
});
assert.deepEqual(
next.textGenerationModelSelection,
createModelSelection(ProviderInstanceId.make("codex"), "gpt-5.4", [
{ id: "reasoningEffort", value: "high" },
]),
);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("preserves custom provider instance text generation selections", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const next = yield* serverSettings.updateSettings({
providerInstances: {
[ProviderInstanceId.make("claude_openrouter")]: {
driver: ProviderDriverKind.make("claudeAgent"),
enabled: true,
config: { customModels: ["openai/gpt-5.5"] },
},
},
textGenerationModelSelection: {
instanceId: ProviderInstanceId.make("claude_openrouter"),
model: "openai/gpt-5.5",
},
});
assert.deepEqual(next.textGenerationModelSelection, {
instanceId: ProviderInstanceId.make("claude_openrouter"),
model: "openai/gpt-5.5",
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect(
"uses explicit provider instance enabled state over legacy provider enabled state",
() =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const instanceId = ProviderInstanceId.make("claude_openrouter");
const next = yield* serverSettings.updateSettings({
providers: {
claudeAgent: {
enabled: false,
},
},
providerInstances: {
[instanceId]: {
driver: ProviderDriverKind.make("claudeAgent"),
enabled: true,
config: { customModels: ["openai/gpt-5.5"] },
},
},
textGenerationModelSelection: {
instanceId,
model: "openai/gpt-5.5",
},
});
assert.deepEqual(next.textGenerationModelSelection, {
instanceId,
model: "openai/gpt-5.5",
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("preserves enabled text generation selections for non-built-in drivers", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const instanceId = ProviderInstanceId.make("openrouter_text");
const next = yield* serverSettings.updateSettings({
providerInstances: {
[instanceId]: {
driver: ProviderDriverKind.make("openrouter"),
enabled: true,
config: { customModels: ["openai/gpt-5.5"] },
},
},
textGenerationModelSelection: {
instanceId,
model: "openai/gpt-5.5",
},
});
assert.deepEqual(next.textGenerationModelSelection, {
instanceId,
model: "openai/gpt-5.5",
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect(
"preserves the source control writer selection when its provider instance is disabled",
() =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const instanceId = ProviderInstanceId.make("codex_writer");
const sourceControlWriterModelSelection = {
instanceId,
model: "gpt-5.4-mini",
};
yield* serverSettings.updateSettings({
providerInstances: {
[instanceId]: {
driver: ProviderDriverKind.make("codex"),
enabled: true,
config: {},
},
},
sourceControlWriterModelSelection,
});
const next = yield* serverSettings.updateSettings({
providerInstances: {
[instanceId]: {
driver: ProviderDriverKind.make("codex"),
enabled: false,
config: {},
},
},
});
assert.deepEqual(next.sourceControlWriterModelSelection, sourceControlWriterModelSelection);
assert.deepEqual(
(yield* serverSettings.getSettings).sourceControlWriterModelSelection,
sourceControlWriterModelSelection,
);
const raw = yield* fileSystem.readFileString(serverConfig.settingsPath);
assert.deepEqual(
JSON.parse(raw).sourceControlWriterModelSelection,
sourceControlWriterModelSelection,
);
const restored = yield* serverSettings.updateSettings({
providerInstances: {
[instanceId]: {
driver: ProviderDriverKind.make("codex"),
enabled: true,
config: {},
},
},
});
assert.deepEqual(
restored.sourceControlWriterModelSelection,
sourceControlWriterModelSelection,
);
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("drops stale text generation options when resetting model selection", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
yield* serverSettings.updateSettings({
textGenerationModelSelection: {
instanceId: ProviderInstanceId.make("codex"),
model: DEFAULT_SERVER_SETTINGS.textGenerationModelSelection.model,
options: createModelSelection(
ProviderInstanceId.make("codex"),
DEFAULT_SERVER_SETTINGS.textGenerationModelSelection.model,
[
{ id: "reasoningEffort", value: "high" },
{ id: "fastMode", value: true },
],
).options!,
},
});
const next = yield* serverSettings.updateSettings({
textGenerationModelSelection: {
instanceId: DEFAULT_SERVER_SETTINGS.textGenerationModelSelection.instanceId,
model: DEFAULT_SERVER_SETTINGS.textGenerationModelSelection.model,
},
});
assert.deepEqual(next.textGenerationModelSelection, {
instanceId: DEFAULT_SERVER_SETTINGS.textGenerationModelSelection.instanceId,
model: DEFAULT_SERVER_SETTINGS.textGenerationModelSelection.model,
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("replaces provider instance maps when clearing optional fields", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const codexId = ProviderInstanceId.make("codex");
yield* serverSettings.updateSettings({
providerInstances: {
[codexId]: {
driver: ProviderDriverKind.make("codex"),
displayName: "Codex Work",
accentColor: "#7c3aed",
enabled: true,
config: { homePath: "~/.codex" },
},
},
});
const next = yield* serverSettings.updateSettings({
providerInstances: {
[codexId]: {
driver: ProviderDriverKind.make("codex"),
displayName: "Codex Work",
enabled: true,
config: { homePath: "~/.codex" },
},
},
});
assert.deepEqual(next.providerInstances[codexId], {
driver: ProviderDriverKind.make("codex"),
displayName: "Codex Work",
enabled: true,
config: { homePath: "~/.codex" },
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("trims provider path settings when updates are applied", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const next = yield* serverSettings.updateSettings({
providers: {
codex: {
binaryPath: " /opt/homebrew/bin/codex ",
homePath: " ",
},
claudeAgent: {
binaryPath: " /opt/homebrew/bin/claude ",
},
opencode: {
binaryPath: " /opt/homebrew/bin/opencode ",
serverUrl: " http://127.0.0.1:4096 ",
serverPassword: " secret-password ",
},
},
});
assert.deepEqual(next.providers.codex, {
enabled: true,
binaryPath: "/opt/homebrew/bin/codex",
homePath: "",
shadowHomePath: "",
launchArgs: "",
customModels: [],
});
assert.deepEqual(next.providers.claudeAgent, {
enabled: true,
binaryPath: "/opt/homebrew/bin/claude",
homePath: "",
customModels: [],
launchArgs: "",
autoCompactWindow: "",
});
assert.deepEqual(next.providers.opencode, {
// OpenCode is disabled by default; this update only touches paths.
enabled: false,
binaryPath: "/opt/homebrew/bin/opencode",
serverUrl: "http://127.0.0.1:4096",
serverPassword: "secret-password",
customModels: [],
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("trims observability settings when updates are applied", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const next = yield* serverSettings.updateSettings({
addProjectBaseDirectory: " ~/Development ",
observability: {
otlpTracesUrl: " http://localhost:4318/v1/traces ",
otlpMetricsUrl: " http://localhost:4318/v1/metrics ",
},
});
assert.equal(next.addProjectBaseDirectory, "~/Development");
assert.deepEqual(next.observability, {
otlpTracesUrl: "http://localhost:4318/v1/traces",
otlpMetricsUrl: "http://localhost:4318/v1/metrics",
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("defaults blank binary paths to provider executables", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const next = yield* serverSettings.updateSettings({
providers: {
codex: {
binaryPath: " ",
},
claudeAgent: {
binaryPath: "",
},
},
});
assert.equal(next.providers.codex.binaryPath, "codex");
assert.equal(next.providers.claudeAgent.binaryPath, "claude");
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("persists shared bot sandbox and browser sharing", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const next = yield* serverSettings.updateSettings({
botSandboxBrowserSharing: "shared",
});
assert.equal(next.botSandboxBrowserSharing, "shared");
const raw = yield* fileSystem.readFileString(serverConfig.settingsPath);
assert.equal(JSON.parse(raw).botSandboxBrowserSharing, "shared");
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("writes non-default settings and explicit optional provider defaults to disk", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const serverConfig = yield* ServerConfig.ServerConfig;
const fileSystem = yield* FileSystem.FileSystem;
const next = yield* serverSettings.updateSettings({
addProjectBaseDirectory: "~/Development",
observability: {
otlpTracesUrl: "http://localhost:4318/v1/traces",
otlpMetricsUrl: "http://localhost:4318/v1/metrics",
},
providers: {
codex: {
binaryPath: "/opt/homebrew/bin/codex",
},
opencode: {
serverUrl: "http://127.0.0.1:4096",
serverPassword: "secret-password",
},
},
automaticGitFetchInterval: Duration.seconds(10),
});
assert.equal(next.providers.codex.binaryPath, "/opt/homebrew/bin/codex");
const raw = yield* fileSystem.readFileString(serverConfig.settingsPath);
assert.deepEqual(JSON.parse(raw), {
addProjectBaseDirectory: "~/Development",
observability: {
otlpTracesUrl: "http://localhost:4318/v1/traces",
otlpMetricsUrl: "http://localhost:4318/v1/metrics",
},
providers: {
codex: {
binaryPath: "/opt/homebrew/bin/codex",
},
grok: {
enabled: false,
},
opencode: {
enabled: false,
serverUrl: "http://127.0.0.1:4096",
serverPassword: "secret-password",
},
},
backgroundActivity: {
schemaVersion: 1,
profile: "custom",
baseProfile: "balanced",
overrides: {
automaticGitFetchInterval: 10_000,
},
},
automaticGitFetchInterval: 10_000,
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
it.effect("rejects incomplete sandbox connections", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
const error = yield* Effect.flip(
serverSettings.updateSettings({
sandbox: {
providers: {
vercel: {
environment: [
{ name: "VERCEL_TOKEN", value: "secret", sensitive: true },
{ name: "VERCEL_TEAM_ID", value: "team", sensitive: false },
],
},
},
},
}),
);
assert.deepInclude(error, {
operation: "validate-sandbox",
providerInstanceId: "sandbox:vercel",
environmentVariable: "VERCEL_PROJECT_ID",
});
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
});