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 {
CommandId,
DEFAULT_MODEL,
DEFAULT_PROVIDER_INTERACTION_MODE,
type ModelSelection,
PLACEHOLDER_THREAD_TITLE,
ProjectId,
ProviderInstanceId,
ThreadId,
} from "@akeru/contracts";
import * as Crypto from "effect/Crypto";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as ServerConfig from "./config.ts";
import * as ExternalLauncher from "./process/externalLauncher.ts";
import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts";
import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts";
import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";
import { formatHostForUrl, isWildcardHost } from "./startupAccess.ts";
export const getAutoBootstrapDefaultModelSelection = (): ModelSelection => ({
instanceId: ProviderInstanceId.make("codex"),
model: DEFAULT_MODEL,
});
export const resolveWelcomeBase = Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const segments = serverConfig.cwd.split(/[/\\]/).filter(Boolean);
const projectName = segments[segments.length - 1] ?? "project";
return {
cwd: serverConfig.cwd,
projectName,
} as const;
});
export const resolveAutoBootstrapWelcomeTargets = Effect.gen(function* () {
const crypto = yield* Crypto.Crypto;
const randomUUID = crypto.randomUUIDv4;
const serverConfig = yield* ServerConfig.ServerConfig;
const projectionReadModelQuery = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery;
const orchestrationEngine = yield* OrchestrationEngine.OrchestrationEngineService;
const path = yield* Path.Path;
let bootstrapProjectId: ProjectId | undefined;
let bootstrapThreadId: ThreadId | undefined;
// Akeru Bot always lands in a chat: with no active project, a bot click
// would dead-end at the add-project wall, so first run provisions a
// workspace from the server cwd even without the explicit flag.
let shouldBootstrap = serverConfig.autoBootstrapProjectFromCwd;
if (!shouldBootstrap) {
const readModel = yield* projectionReadModelQuery.getCommandReadModel();
shouldBootstrap = !readModel.projects.some((project) => project.deletedAt === null);
}
if (shouldBootstrap) {
yield* Effect.gen(function* () {
const existingProject = yield* projectionReadModelQuery.getActiveProjectByWorkspaceRoot(
serverConfig.cwd,
);
let nextProjectId: ProjectId;
let nextProjectDefaultModelSelection: ModelSelection;
if (Option.isNone(existingProject)) {
const createdAt = DateTime.formatIso(yield* DateTime.now);
nextProjectId = ProjectId.make(yield* randomUUID);
const bootstrapProjectTitle = path.basename(serverConfig.cwd) || "project";
nextProjectDefaultModelSelection = getAutoBootstrapDefaultModelSelection();
yield* orchestrationEngine.dispatch({
type: "project.create",
commandId: CommandId.make(yield* randomUUID),
projectId: nextProjectId,
title: bootstrapProjectTitle,
workspaceRoot: serverConfig.cwd,
defaultModelSelection: nextProjectDefaultModelSelection,
createdAt,
});
} else {
nextProjectId = existingProject.value.id;
nextProjectDefaultModelSelection =
existingProject.value.defaultModelSelection ?? getAutoBootstrapDefaultModelSelection();
}
const existingThreadId =
yield* projectionReadModelQuery.getFirstActiveThreadIdByProjectId(nextProjectId);
if (Option.isNone(existingThreadId)) {
const createdAt = DateTime.formatIso(yield* DateTime.now);
const createdThreadId = ThreadId.make(yield* randomUUID);
yield* orchestrationEngine.dispatch({
type: "thread.create",
commandId: CommandId.make(yield* randomUUID),
threadId: createdThreadId,
projectId: nextProjectId,
title: PLACEHOLDER_THREAD_TITLE,
modelSelection: nextProjectDefaultModelSelection,
interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
runtimeMode: "full-access",
branch: null,
worktreePath: null,
createdAt,
});
bootstrapProjectId = nextProjectId;
bootstrapThreadId = createdThreadId;
} else {
bootstrapProjectId = nextProjectId;
bootstrapThreadId = existingThreadId.value;
}
});
}
return {
...(bootstrapProjectId ? { bootstrapProjectId } : {}),
...(bootstrapThreadId ? { bootstrapThreadId } : {}),
} as const;
});
export const resolveStartupBrowserTarget = Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const localUrl = `http://localhost:${serverConfig.port}`;
const bindUrl =
serverConfig.host && !isWildcardHost(serverConfig.host)
? `http://${formatHostForUrl(serverConfig.host)}:${serverConfig.port}`
: localUrl;
const baseTarget = serverConfig.devUrl?.toString() ?? bindUrl;
return yield* Effect.succeed(serverConfig.mode === "desktop" ? baseTarget : undefined).pipe(
Effect.flatMap((target) =>
target ? Effect.succeed(target) : serverAuth.issueStartupPairingUrl(baseTarget),
),
);
});
export const maybeOpenBrowser = (target: string) =>
Effect.gen(function* () {
const serverConfig = yield* ServerConfig.ServerConfig;
if (serverConfig.noBrowser) {
return;
}
const externalLauncher = yield* ExternalLauncher.ExternalLauncher;
yield* externalLauncher.launchBrowser(target).pipe(
Effect.catch(() =>
Effect.logInfo("browser auto-open unavailable", {
hint: `Open ${target} in your browser.`,
}),
),
);
});