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 Predicate from "effect/Predicate";
import type {
AuthClientMetadata,
AuthClientMetadataDeviceType,
AuthClientPresentationMetadata,
} from "@akeru/contracts";
import type * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
import * as NodeCrypto from "node:crypto";
import * as Encoding from "effect/Encoding";
import * as Result from "effect/Result";
const SESSION_COOKIE_NAME = "t3_session";
/**
* Cookies are scoped by host but *not* by port, so any two servers that can be
* live on one hostname at once need separate names — otherwise the second
* clobbers the first's session and both sides see "Invalid session token
* signature" until someone clears cookies by hand.
*
* Remote web servers use their persisted environment identity and omit the
* port, so the name survives state-directory moves and public port changes.
*
* Desktop scans upward from 3773 for a free port and binds
* 127.0.0.1, so a second instance lands on a different port and the same host.
*/
export function resolveSessionCookieName(input: {
readonly mode: "web" | "desktop";
readonly port: number;
readonly host: string | undefined;
readonly instanceKey: string;
readonly environmentId: string;
readonly development: boolean;
}): string {
if (input.mode === "desktop") {
return `${SESSION_COOKIE_NAME}_${input.port}`;
}
const instanceHash = NodeCrypto.createHash("sha256")
.update(
!input.development && isRemoteReachableHost(input.host)
? input.environmentId
: input.instanceKey,
)
.digest("hex")
.slice(0, 12);
if (!input.development && isRemoteReachableHost(input.host)) {
return `${SESSION_COOKIE_NAME}_${instanceHash}`;
}
// Cookies are scoped by host, not port. Loopback development servers need an
// instance-specific name or parallel agents overwrite each other's session,
// and a server that later reuses the port receives a token signed elsewhere.
return `${SESSION_COOKIE_NAME}_${input.port}_${instanceHash}`;
}
export function resolveLegacySessionCookieName(input: {
readonly mode: "web" | "desktop";
readonly host: string | undefined;
readonly development: boolean;
}): string | undefined {
return input.mode === "web" && !input.development && isRemoteReachableHost(input.host)
? SESSION_COOKIE_NAME
: undefined;
}
export function isRemoteReachableHost(host: string | undefined): boolean {
if (host === "0.0.0.0" || host === "::" || host === "[::]") {
return true;
}
if (!host || host.length === 0) {
return false;
}
return !(
host === "localhost" ||
host === "127.0.0.1" ||
host === "::1" ||
host === "[::1]" ||
host.startsWith("127.")
);
}
export function base64UrlEncode(input: string | Uint8Array): string {
return Predicate.isString(input)
? Encoding.encodeBase64Url(new TextEncoder().encode(input))
: Encoding.encodeBase64Url(input);
}
export function base64UrlDecodeUtf8(input: string): string {
return Result.getOrThrow(Encoding.decodeBase64UrlString(input));
}
export function signPayload(payload: string, secret: Uint8Array): string {
return NodeCrypto.createHmac("sha256", Buffer.from(secret)).update(payload).digest("base64url");
}
export function timingSafeEqualBase64Url(left: string, right: string): boolean {
const leftBuffer = Buffer.from(left, "base64url");
const rightBuffer = Buffer.from(right, "base64url");
if (leftBuffer.length !== rightBuffer.length) {
return false;
}
return NodeCrypto.timingSafeEqual(leftBuffer, rightBuffer);
}
function normalizeNonEmptyString(value: string | null | undefined): string | undefined {
if (!Predicate.isString(value)) {
return undefined;
}
const trimmed = value.trim();
return trimmed.length > 0 ? trimmed : undefined;
}
function normalizeIpAddress(value: string | null | undefined): string | undefined {
const normalized = normalizeNonEmptyString(value);
if (!normalized) {
return undefined;
}
return normalized.startsWith("::ffff:") ? normalized.slice("::ffff:".length) : normalized;
}
function inferDeviceType(userAgent: string | undefined): AuthClientMetadataDeviceType {
if (!userAgent) {
return "unknown";
}
const normalized = userAgent.toLowerCase();
if (/bot|crawler|spider|slurp|curl|wget/.test(normalized)) {
return "bot";
}
if (/ipad|tablet/.test(normalized)) {
return "tablet";
}
if (/iphone|android.+mobile|mobile/.test(normalized)) {
return "mobile";
}
return "desktop";
}
function inferBrowser(userAgent: string | undefined): string | undefined {
if (!userAgent) {
return undefined;
}
const normalized = userAgent.toLowerCase();
if (/edg\//.test(normalized)) return "Edge";
if (/opr\//.test(normalized)) return "Opera";
if (/firefox\//.test(normalized)) return "Firefox";
if (/electron\//.test(normalized)) return "Electron";
if (/chrome\//.test(normalized) || /crios\//.test(normalized)) return "Chrome";
if (/safari\//.test(normalized) && !/chrome\//.test(normalized)) return "Safari";
return undefined;
}
function inferOs(userAgent: string | undefined): string | undefined {
if (!userAgent) {
return undefined;
}
const normalized = userAgent.toLowerCase();
if (/iphone|ipad|ipod/.test(normalized)) return "iOS";
if (/android/.test(normalized)) return "Android";
if (/mac os x|macintosh/.test(normalized)) return "macOS";
if (/windows nt/.test(normalized)) return "Windows";
if (/linux/.test(normalized)) return "Linux";
return undefined;
}
function readRemoteAddressFromSource(
source: HttpServerRequest.HttpServerRequest["source"],
): string | undefined {
if (!source || !Predicate.isObjectKeyword(source)) {
return undefined;
}
const socket = Predicate.hasProperty(source, "socket") ? source.socket : undefined;
const socketAddress = Predicate.hasProperty(socket, "remoteAddress")
? socket.remoteAddress
: undefined;
const directAddress = Predicate.hasProperty(source, "remoteAddress")
? source.remoteAddress
: undefined;
const address = socketAddress ?? directAddress;
return Predicate.isString(address) ? normalizeIpAddress(address) : undefined;
}
export function deriveAuthClientMetadata(input: {
readonly request: HttpServerRequest.HttpServerRequest;
readonly presented?: AuthClientPresentationMetadata;
}): AuthClientMetadata {
const userAgent = normalizeNonEmptyString(input.request.headers["user-agent"]);
const ipAddress = readRemoteAddressFromSource(input.request.source);
const os = input.presented?.os ?? inferOs(userAgent);
const browser = inferBrowser(userAgent);
return {
...(input.presented?.label ? { label: input.presented.label } : {}),
...(ipAddress ? { ipAddress } : {}),
...(userAgent ? { userAgent } : {}),
deviceType: input.presented?.deviceType ?? inferDeviceType(userAgent),
...(os ? { os } : {}),
...(browser ? { browser } : {}),
};
}