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 Match from "effect/Match";
import * as Predicate from "effect/Predicate";
import * as NodeOS from "node:os";
import * as NodeChildProcess from "node:child_process";
const PATH_CAPTURE_START = "__T3CODE_PATH_START__";
const PATH_CAPTURE_END = "__T3CODE_PATH_END__";
const SHELL_ENV_NAME_PATTERN = /^[A-Z0-9_]+$/;
export const WINDOWS_PATH_DELIMITER = ";";
const POSIX_PATH_DELIMITER = ":";
const WINDOWS_SHELL_CANDIDATES = ["pwsh.exe", "powershell.exe"] as const;
type ExecFileSyncLike = (
file: string,
args: ReadonlyArray<string>,
options: { encoding: "utf8"; timeout: number },
) => string;
export interface WindowsEnvironmentProbeOptions {
readonly loadProfile?: boolean;
}
function trimNonEmpty(value: string | null | undefined): string | undefined {
const trimmed = value?.trim();
return trimmed && trimmed.length > 0 ? trimmed : undefined;
}
function readUserLoginShell(): string | undefined {
try {
return trimNonEmpty(NodeOS.userInfo().shell);
} catch {
return undefined;
}
}
export function listLoginShellCandidates(
platform: NodeJS.Platform,
shell: string | undefined,
userShell = readUserLoginShell(),
): ReadonlyArray<string> {
const fallbackShell = Match.value(platform).pipe(
Match.when("darwin", () => "/bin/zsh"),
Match.when("linux", () => "/bin/bash"),
Match.orElse(() => undefined),
);
const seen = new Set<string>();
const candidates: string[] = [];
for (const candidate of [trimNonEmpty(shell), trimNonEmpty(userShell), fallbackShell]) {
if (!candidate || seen.has(candidate)) {
continue;
}
seen.add(candidate);
candidates.push(candidate);
}
return candidates;
}
export function extractPathFromShellOutput(output: string): string | null {
const startIndex = output.indexOf(PATH_CAPTURE_START);
if (startIndex === -1) return null;
const valueStartIndex = startIndex + PATH_CAPTURE_START.length;
const endIndex = output.indexOf(PATH_CAPTURE_END, valueStartIndex);
if (endIndex === -1) return null;
const pathValue = output.slice(valueStartIndex, endIndex).trim();
return pathValue.length > 0 ? pathValue : null;
}
export function readPathFromLoginShell(
shell: string,
execFile: ExecFileSyncLike = NodeChildProcess.execFileSync,
): string | undefined {
return readEnvironmentFromLoginShell(shell, ["PATH"], execFile).PATH;
}
export function readPathFromLaunchctl(
execFile: ExecFileSyncLike = NodeChildProcess.execFileSync,
): string | undefined {
try {
return trimNonEmpty(
execFile("/bin/launchctl", ["getenv", "PATH"], {
encoding: "utf8",
timeout: 2000,
}),
);
} catch {
return undefined;
}
}
export function mergePathEntries(
preferredPath: string | undefined,
inheritedPath: string | undefined,
platform: NodeJS.Platform,
): string | undefined {
const delimiter = platform === "win32" ? ";" : ":";
const merged: string[] = [];
const seen = new Set<string>();
for (const pathValue of [preferredPath, inheritedPath]) {
if (!pathValue) continue;
for (const entry of pathValue.split(delimiter)) {
const trimmedEntry = entry.trim();
if (!trimmedEntry || seen.has(trimmedEntry)) {
continue;
}
seen.add(trimmedEntry);
merged.push(trimmedEntry);
}
}
return merged.length > 0 ? merged.join(delimiter) : undefined;
}
function envCaptureStart(name: string): string {
return `__T3CODE_ENV_${name}_START__`;
}
function envCaptureEnd(name: string): string {
return `__T3CODE_ENV_${name}_END__`;
}
function buildEnvironmentCaptureCommand(names: ReadonlyArray<string>): string {
return names
.map((name) => {
if (!SHELL_ENV_NAME_PATTERN.test(name)) {
throw new Error(`Unsupported environment variable name: ${name}`);
}
return [
`printf '%s\\n' '${envCaptureStart(name)}'`,
`printenv ${name} || true`,
`printf '%s\\n' '${envCaptureEnd(name)}'`,
].join("; ");
})
.join("; ");
}
function buildWindowsEnvironmentCaptureCommand(names: ReadonlyArray<string>): string {
return [
"$ErrorActionPreference = 'Stop'",
...names.flatMap((name) => {
if (!SHELL_ENV_NAME_PATTERN.test(name)) {
throw new Error(`Unsupported environment variable name: ${name}`);
}
return [
`Write-Output '${envCaptureStart(name)}'`,
`$value = [Environment]::GetEnvironmentVariable('${name}')`,
"if ($null -ne $value -and $value.Length -gt 0) { Write-Output $value }",
`Write-Output '${envCaptureEnd(name)}'`,
];
}),
].join("; ");
}
function extractEnvironmentValue(output: string, name: string): string | undefined {
const startMarker = envCaptureStart(name);
const endMarker = envCaptureEnd(name);
const startIndex = output.indexOf(startMarker);
if (startIndex === -1) return undefined;
const valueStartIndex = startIndex + startMarker.length;
const endIndex = output.indexOf(endMarker, valueStartIndex);
if (endIndex === -1) return undefined;
const value = output
.slice(valueStartIndex, endIndex)
.replace(/^\r?\n/, "")
.replace(/\r?\n$/, "");
return value.length > 0 ? value : undefined;
}
export type ShellEnvironmentReader = (
shell: string,
names: ReadonlyArray<string>,
execFile?: ExecFileSyncLike,
) => Partial<Record<string, string>>;
export const readEnvironmentFromLoginShell: ShellEnvironmentReader = (
shell,
names,
execFile = NodeChildProcess.execFileSync,
) => {
if (names.length === 0) {
return {};
}
const output = execFile(shell, ["-ilc", buildEnvironmentCaptureCommand(names)], {
encoding: "utf8",
timeout: 5000,
});
const environment: Partial<Record<string, string>> = {};
for (const name of names) {
const value = extractEnvironmentValue(output, name);
if (value !== undefined) {
environment[name] = value;
}
}
return environment;
};
export type WindowsShellEnvironmentReader = (
names: ReadonlyArray<string>,
options?: WindowsEnvironmentProbeOptions,
) => Partial<Record<string, string>>;
export function readEnvironmentFromWindowsShell(
names: ReadonlyArray<string>,
execFile?: ExecFileSyncLike,
): Partial<Record<string, string>>;
export function readEnvironmentFromWindowsShell(
names: ReadonlyArray<string>,
options?: WindowsEnvironmentProbeOptions,
execFile?: ExecFileSyncLike,
): Partial<Record<string, string>>;
export function readEnvironmentFromWindowsShell(
names: ReadonlyArray<string>,
optionsOrExecFile?: WindowsEnvironmentProbeOptions | ExecFileSyncLike,
maybeExecFile?: ExecFileSyncLike,
) {
if (names.length === 0) {
return {};
}
const options = Predicate.isFunction(optionsOrExecFile)
? ({} satisfies WindowsEnvironmentProbeOptions)
: (optionsOrExecFile ?? {});
const execFile: ExecFileSyncLike = Predicate.isFunction(optionsOrExecFile)
? optionsOrExecFile
: (maybeExecFile ?? NodeChildProcess.execFileSync);
const command = buildWindowsEnvironmentCaptureCommand(names);
const args = [
"-NoLogo",
...(options.loadProfile ? ([] as const) : (["-NoProfile"] as const)),
"-NonInteractive",
"-Command",
command,
];
for (const shell of WINDOWS_SHELL_CANDIDATES) {
try {
const output = execFile(shell, args, { encoding: "utf8", timeout: 5000 });
const environment: Partial<Record<string, string>> = {};
for (const name of names) {
const value = extractEnvironmentValue(output, name);
if (value !== undefined) {
environment[name] = value;
}
}
return environment;
} catch {
continue;
}
}
return {};
}
export function stripWrappingQuotes(value: string): string {
return value.replace(/^"+|"+$/g, "");
}
export function pathDelimiterForPlatform(platform: NodeJS.Platform): string {
return platform === "win32" ? WINDOWS_PATH_DELIMITER : POSIX_PATH_DELIMITER;
}
function normalizePathEntryForComparison(entry: string, platform: NodeJS.Platform): string {
const normalized = stripWrappingQuotes(entry.trim());
return platform === "win32" ? normalized.toLowerCase() : normalized;
}
export function mergePathValues(
preferredPath: string | undefined,
inheritedPath: string | undefined,
platform: NodeJS.Platform,
): string | undefined {
const delimiter = pathDelimiterForPlatform(platform);
const merged: string[] = [];
const seen = new Set<string>();
for (const rawValue of [preferredPath, inheritedPath]) {
if (!rawValue) continue;
for (const entry of rawValue.split(delimiter)) {
const trimmed = entry.trim();
if (trimmed.length === 0) continue;
const normalized = normalizePathEntryForComparison(trimmed, platform);
if (normalized.length === 0 || seen.has(normalized)) continue;
seen.add(normalized);
merged.push(trimmed);
}
}
return merged.length > 0 ? merged.join(delimiter) : undefined;
}
export function readEnvPath(env: NodeJS.ProcessEnv): string | undefined {
return env.PATH ?? env.Path ?? env.path;
}
export function resolvePathEnvironmentVariable(env: NodeJS.ProcessEnv): string {
return readEnvPath(env) ?? "";
}
export function readWindowsEnvironmentSafely(
readEnvironment: WindowsShellEnvironmentReader,
names: ReadonlyArray<string>,
options?: WindowsEnvironmentProbeOptions,
): Partial<Record<string, string>> {
try {
return readEnvironment(names, options);
} catch {
return {};
}
}
export function mergeWindowsEnv(
currentEnv: NodeJS.ProcessEnv,
patch: Partial<Record<string, string>>,
): NodeJS.ProcessEnv {
const nextEnv: NodeJS.ProcessEnv = { ...currentEnv };
for (const [key, value] of Object.entries(patch)) {
if (value !== undefined) {
nextEnv[key] = value;
}
}
return nextEnv;
}