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 DateTime from "effect/DateTime";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as Result from "effect/Result";
import * as Scope from "effect/Scope";
import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
import * as CodexErrors from "effect-codex-app-server/errors";
import type { CodexSettings, ServerProvider } from "@akeru/contracts";
import { ServerSettingsError } from "@akeru/contracts";
import { resolveCodexLaunchArgs } from "./codexLaunchArgs.ts";
import {
AUTH_PROBE_TIMEOUT_MS,
buildServerProvider,
type ServerProviderDraft,
} from "../providerSnapshot.ts";
import {
isCodexAppServerSpawnError,
probeCodexAppServerProvider,
} from "./codex/CodexCapabilitiesProbe.ts";
import {
CODEX_PRESENTATION,
type CodexAppServerProviderSnapshot,
} from "./codex/CodexProviderState.ts";
import { codexAccountAuthLabel, codexAccountEmail } from "./codex/CodexAccountMetadata.ts";
const emptyCodexModelsFromSettings = (codexSettings: CodexSettings): ServerProvider["models"] => {
const models = new Set<string>();
for (const model of codexSettings.customModels) {
const trimmed = model.trim();
if (trimmed.length > 0) {
models.add(trimmed);
}
}
return Array.from(models, (model) => ({
slug: model,
name: model,
isCustom: true,
capabilities: null,
}));
};
const pendingCodexProvider = (codexSettings: CodexSettings): Effect.Effect<ServerProviderDraft> =>
Effect.gen(function* () {
const checkedAt = yield* Effect.map(DateTime.now, DateTime.formatIso);
const models = emptyCodexModelsFromSettings(codexSettings);
if (!codexSettings.enabled) {
return buildServerProvider({
presentation: CODEX_PRESENTATION,
enabled: false,
checkedAt,
models,
skills: [],
probe: {
installed: false,
version: null,
status: "warning",
auth: { status: "unknown" },
message: "Codex is disabled in Akeru Bot settings.",
},
});
}
return buildServerProvider({
presentation: CODEX_PRESENTATION,
enabled: true,
checkedAt,
models,
skills: [],
probe: {
installed: false,
version: null,
status: "warning",
auth: { status: "unknown" },
message: "Codex provider status has not been checked in this session yet.",
},
});
});
type CodexAccountProbeStatus = Pick<ServerProvider, "auth" | "message"> & {
readonly status: Exclude<ServerProvider["status"], "disabled">;
};
function accountProbeStatus(
account: CodexAppServerProviderSnapshot["account"],
): CodexAccountProbeStatus {
const authLabel = codexAccountAuthLabel(account.account);
const authEmail = codexAccountEmail(account.account);
const auth = {
status: account.account ? ("authenticated" as const) : ("unknown" as const),
...(account.account?.type ? { type: account.account?.type } : {}),
...(authLabel ? { label: authLabel } : {}),
...(authEmail ? { email: authEmail } : {}),
} satisfies ServerProvider["auth"];
if (account.account) {
return { status: "ready", auth };
}
if (account.requiresOpenaiAuth) {
return {
status: "error",
auth: { status: "unauthenticated" },
message: "Codex CLI is not authenticated. Run `codex login` and try again.",
};
}
return { status: "ready", auth };
}
export const checkCodexProviderStatus = Effect.fn("checkCodexProviderStatus")(function* (
codexSettings: CodexSettings,
probe: (input: {
readonly binaryPath: string;
readonly homePath?: string;
readonly launchArgs?: string;
readonly cwd: string;
readonly customModels: ReadonlyArray<string>;
readonly environment?: NodeJS.ProcessEnv;
}) => Effect.Effect<
CodexAppServerProviderSnapshot,
CodexErrors.CodexAppServerError,
ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path | Scope.Scope
> = probeCodexAppServerProvider,
environment?: NodeJS.ProcessEnv,
): Effect.fn.Return<
ServerProviderDraft,
ServerSettingsError,
ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path
> {
const resolvedEnvironment = environment ?? process.env;
const checkedAt = DateTime.formatIso(yield* DateTime.now);
const emptyModels = emptyCodexModelsFromSettings(codexSettings);
if (!codexSettings.enabled) {
return buildServerProvider({
presentation: CODEX_PRESENTATION,
enabled: false,
checkedAt,
models: emptyModels,
skills: [],
probe: {
installed: false,
version: null,
status: "warning",
auth: { status: "unknown" },
message: "Codex is disabled in Akeru Bot settings.",
},
});
}
const probeResult = yield* probe({
binaryPath: codexSettings.binaryPath,
homePath: codexSettings.homePath,
launchArgs: resolveCodexLaunchArgs(codexSettings.launchArgs, resolvedEnvironment),
cwd: process.cwd(),
customModels: codexSettings.customModels,
environment: resolvedEnvironment,
}).pipe(
Effect.scoped,
Effect.timeoutOption(Duration.millis(AUTH_PROBE_TIMEOUT_MS)),
Effect.result,
);
if (Result.isFailure(probeResult)) {
const error = probeResult.failure;
const installed = !isCodexAppServerSpawnError(error);
return buildServerProvider({
presentation: CODEX_PRESENTATION,
enabled: codexSettings.enabled,
checkedAt,
models: emptyModels,
skills: [],
probe: {
installed,
version: null,
status: "error",
auth: { status: "unknown" },
message: installed
? `Codex app-server provider probe failed: ${error.message}.`
: "Codex CLI (`codex`) was not found on PATH.",
},
});
}
if (Option.isNone(probeResult.success)) {
return buildServerProvider({
presentation: CODEX_PRESENTATION,
enabled: codexSettings.enabled,
checkedAt,
models: emptyModels,
skills: [],
probe: {
installed: true,
version: null,
status: "error",
auth: { status: "unknown" },
message: "Timed out while checking Codex app-server provider status.",
},
});
}
const snapshot = probeResult.success.value;
const accountStatus = accountProbeStatus(snapshot.account);
return buildServerProvider({
presentation: CODEX_PRESENTATION,
enabled: codexSettings.enabled,
checkedAt,
models: snapshot.models,
skills: snapshot.skills,
slashCommands: [
{
name: "feedback",
description: "Send this chat and Codex logs to OpenAI",
input: { hint: "Describe the issue (optional)" },
},
],
probe: {
installed: true,
version: snapshot.version ?? null,
status: accountStatus.status,
auth: accountStatus.auth,
...(accountStatus.message ? { message: accountStatus.message } : {}),
},
});
});
// NOTE: the singleton `CodexProviderLive` Layer has been removed as part of
// the per-instance-driver refactor. `CodexDriver.create()` builds a managed
// snapshot per instance (each with its own `CodexSettings`) and hands the
// resulting `ServerProviderShape` back as `ProviderInstance.snapshot`.
//
// The `pendingCodexProvider` and `checkCodexProviderStatus` helpers are
// re-exported for use by `CodexDriver`.
export { pendingCodexProvider };
export { type CodexAppServerProviderSnapshot } from "./codex/CodexProviderState.ts";
export { mapCodexModelCapabilities, applyPreferredCodexDefaultModel } from "./codex/CodexModels.ts";
export {
parseCodexSkillsListResponse,
buildCodexInitializeParams,
} from "./codex/CodexCapabilitiesProbe.ts";