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 {
createAdvertisedEndpoint,
type CreateAdvertisedEndpointInput,
} from "@akeru/shared/advertisedEndpoint";
import {
type AdvertisedEndpoint,
type AdvertisedEndpointProvider,
type DesktopServerExposureMode,
type DesktopServerExposureState,
} from "@akeru/contracts";
import { isTailscaleIpv4Address } from "@akeru/tailscale";
import * as Option from "effect/Option";
import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
import * as DesktopNetworkInterfaces from "./DesktopNetworkInterfaces.ts";
export const DESKTOP_LOOPBACK_HOST = "127.0.0.1";
export const DESKTOP_LAN_BIND_HOST = "0.0.0.0";
export interface ResolvedDesktopServerExposure {
readonly mode: DesktopServerExposureMode;
readonly bindHost: string;
readonly localHttpUrl: string;
readonly localWsUrl: string;
readonly endpointUrl: string | null;
readonly advertisedHost: string | null;
}
export interface DesktopAdvertisedEndpointInput {
readonly port: number;
readonly exposure: ResolvedDesktopServerExposure;
readonly customHttpsEndpointUrls?: readonly string[];
}
export const DESKTOP_CORE_ENDPOINT_PROVIDER: AdvertisedEndpointProvider = {
id: "desktop-core",
label: "Desktop",
kind: "core",
isAddon: false,
};
export const DESKTOP_MANUAL_ENDPOINT_PROVIDER: AdvertisedEndpointProvider = {
id: "manual",
label: "Manual",
kind: "manual",
isAddon: false,
};
export const normalizeOptionalHost = (value: string | undefined): string | undefined => {
const normalized = value?.trim();
return normalized && normalized.length > 0 ? normalized : undefined;
};
export const isUsableLanIpv4Address = (address: string): boolean =>
!address.startsWith("127.") &&
!address.startsWith("169.254.") &&
!isTailscaleIpv4Address(address);
export const isHttpsEndpointUrl = (value: string): boolean => {
try {
return new URL(value).protocol === "https:";
} catch {
return false;
}
};
export const resolveLanAdvertisedHost = (
networkInterfaces: DesktopNetworkInterfaces.NetworkInterfaces,
explicitHost: string | undefined,
): string | null => {
const normalizedExplicitHost = normalizeOptionalHost(explicitHost);
if (normalizedExplicitHost) {
return normalizedExplicitHost;
}
for (const interfaceAddresses of Object.values(networkInterfaces)) {
if (!interfaceAddresses) continue;
for (const address of interfaceAddresses) {
if (address.internal) continue;
if (address.family !== "IPv4") continue;
if (!isUsableLanIpv4Address(address.address)) continue;
return address.address;
}
}
return null;
};
export const resolveDesktopServerExposure = (input: {
readonly mode: DesktopServerExposureMode;
readonly port: number;
readonly networkInterfaces: DesktopNetworkInterfaces.NetworkInterfaces;
readonly advertisedHostOverride?: string;
}): ResolvedDesktopServerExposure => {
const localHttpUrl = `http://${DESKTOP_LOOPBACK_HOST}:${input.port}`;
const localWsUrl = `ws://${DESKTOP_LOOPBACK_HOST}:${input.port}`;
if (input.mode === "local-only") {
return {
mode: input.mode,
bindHost: DESKTOP_LOOPBACK_HOST,
localHttpUrl,
localWsUrl,
endpointUrl: null,
advertisedHost: null,
};
}
const advertisedHost = resolveLanAdvertisedHost(
input.networkInterfaces,
input.advertisedHostOverride,
);
return {
mode: input.mode,
bindHost: DESKTOP_LAN_BIND_HOST,
localHttpUrl,
localWsUrl,
endpointUrl: advertisedHost ? `http://${advertisedHost}:${input.port}` : null,
advertisedHost,
};
};
export const createDesktopEndpoint = (
input: Omit<CreateAdvertisedEndpointInput, "provider" | "source">,
): AdvertisedEndpoint =>
createAdvertisedEndpoint({
...input,
provider: DESKTOP_CORE_ENDPOINT_PROVIDER,
source: "desktop-core",
});
export const createManualEndpoint = (
input: Omit<CreateAdvertisedEndpointInput, "provider" | "source">,
): AdvertisedEndpoint =>
createAdvertisedEndpoint({
...input,
provider: DESKTOP_MANUAL_ENDPOINT_PROVIDER,
source: "user",
});
export const resolveDesktopCoreAdvertisedEndpoints = (
input: DesktopAdvertisedEndpointInput,
): readonly AdvertisedEndpoint[] => {
const endpoints: AdvertisedEndpoint[] = [
createDesktopEndpoint({
id: `desktop-loopback:${input.port}`,
label: "This machine",
httpBaseUrl: input.exposure.localHttpUrl,
reachability: "loopback",
status: "available",
description: "Loopback endpoint for this desktop app.",
}),
];
if (input.exposure.endpointUrl) {
endpoints.push(
createDesktopEndpoint({
id: `desktop-lan:${input.exposure.endpointUrl}`,
label: "Local network",
httpBaseUrl: input.exposure.endpointUrl,
reachability: "lan",
status: "available",
isDefault: true,
description: "Reachable from devices on the same network.",
}),
);
}
for (const customEndpointUrl of input.customHttpsEndpointUrls ?? []) {
try {
const isHttpsEndpoint = isHttpsEndpointUrl(customEndpointUrl);
endpoints.push(
createManualEndpoint({
id: `manual:${customEndpointUrl}`,
label: isHttpsEndpoint ? "Custom HTTPS" : "Custom endpoint",
httpBaseUrl: customEndpointUrl,
reachability: "public",
...(isHttpsEndpoint ? ({ hostedHttpsCompatibility: "compatible" } as const) : {}),
status: "unknown",
description: isHttpsEndpoint
? "User-configured HTTPS endpoint for this desktop backend."
: "User-configured endpoint for this desktop backend.",
}),
);
} catch {
// Ignore malformed user-configured endpoints without dropping valid endpoints.
}
}
return endpoints;
};
export interface DesktopServerExposureBackendConfig {
readonly port: number;
readonly bindHost: string;
readonly httpBaseUrl: URL;
readonly tailscaleServeEnabled: boolean;
readonly tailscaleServePort: number;
}
export interface DesktopServerExposureChange {
readonly state: DesktopServerExposureState;
readonly requiresRelaunch: boolean;
}
export interface RuntimeState {
readonly requestedMode: DesktopServerExposureMode;
readonly mode: DesktopServerExposureMode;
readonly port: number;
readonly bindHost: string;
readonly localHttpUrl: string;
readonly localWsUrl: string;
readonly httpBaseUrl: URL;
readonly endpointUrl: Option.Option<string>;
readonly advertisedHost: Option.Option<string>;
readonly tailscaleServeEnabled: boolean;
readonly tailscaleServePort: number;
}
export interface ResolvedRuntimeState {
readonly state: RuntimeState;
readonly unavailable: boolean;
}
export const initialRuntimeState = (): RuntimeState =>
runtimeStateFromResolvedExposure({
requestedMode: DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS.serverExposureMode,
settings: DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
exposure: resolveDesktopServerExposure({
mode: DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS.serverExposureMode,
port: 0,
networkInterfaces: {},
}),
port: 0,
});
export const toContractState = (state: RuntimeState): DesktopServerExposureState => ({
mode: state.mode,
endpointUrl: Option.getOrNull(state.endpointUrl),
advertisedHost: Option.getOrNull(state.advertisedHost),
tailscaleServeEnabled: state.tailscaleServeEnabled,
tailscaleServePort: state.tailscaleServePort,
});
export const toBackendConfig = (state: RuntimeState): DesktopServerExposureBackendConfig => ({
port: state.port,
bindHost: state.bindHost,
httpBaseUrl: state.httpBaseUrl,
tailscaleServeEnabled: state.tailscaleServeEnabled,
tailscaleServePort: state.tailscaleServePort,
});
export const toResolvedExposure = (state: RuntimeState): ResolvedDesktopServerExposure => ({
mode: state.mode,
bindHost: state.bindHost,
localHttpUrl: state.localHttpUrl,
localWsUrl: state.localWsUrl,
endpointUrl: Option.getOrNull(state.endpointUrl),
advertisedHost: Option.getOrNull(state.advertisedHost),
});
export function runtimeStateFromResolvedExposure(input: {
readonly requestedMode: DesktopServerExposureMode;
readonly settings: DesktopAppSettings.DesktopSettings;
readonly exposure: ResolvedDesktopServerExposure;
readonly port: number;
}): RuntimeState {
return {
requestedMode: input.requestedMode,
mode: input.exposure.mode,
port: input.port,
bindHost: input.exposure.bindHost,
localHttpUrl: input.exposure.localHttpUrl,
localWsUrl: input.exposure.localWsUrl,
httpBaseUrl: new URL(input.exposure.localHttpUrl),
endpointUrl: Option.fromNullishOr(input.exposure.endpointUrl),
advertisedHost: Option.fromNullishOr(input.exposure.advertisedHost),
tailscaleServeEnabled: input.settings.tailscaleServeEnabled,
tailscaleServePort: input.settings.tailscaleServePort,
};
}
export function resolveRuntimeState(input: {
readonly requestedMode: DesktopServerExposureMode;
readonly settings: DesktopAppSettings.DesktopSettings;
readonly port: number;
readonly networkInterfaces: DesktopNetworkInterfaces.NetworkInterfaces;
readonly advertisedHostOverride: Option.Option<string>;
}): ResolvedRuntimeState {
const advertisedHostOverride = Option.getOrUndefined(input.advertisedHostOverride);
const requestedExposure = resolveDesktopServerExposure({
mode: input.requestedMode,
port: input.port,
networkInterfaces: input.networkInterfaces,
...(advertisedHostOverride ? { advertisedHostOverride } : {}),
});
const unavailable =
input.requestedMode === "network-accessible" &&
requestedExposure.endpointUrl === null &&
!Object.values(input.networkInterfaces).some((addresses) =>
addresses?.some(
(address) =>
!address.internal && address.family === "IPv4" && isTailscaleIpv4Address(address.address),
),
);
const exposure = unavailable
? resolveDesktopServerExposure({
mode: "local-only",
port: input.port,
networkInterfaces: input.networkInterfaces,
...(advertisedHostOverride ? { advertisedHostOverride } : {}),
})
: requestedExposure;
return {
state: runtimeStateFromResolvedExposure({
requestedMode: input.requestedMode,
settings: input.settings,
exposure,
port: input.port,
}),
unavailable,
};
}
export const requiresBackendRelaunch = (previous: RuntimeState, next: RuntimeState): boolean =>
previous.port !== next.port ||
previous.bindHost !== next.bindHost ||
previous.localHttpUrl !== next.localHttpUrl;