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 { afterEach, describe, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as PlatformError from "effect/PlatformError";
import * as References from "effect/References";
import * as Schema from "effect/Schema";
import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
import { HostProcessHostname, HostProcessPlatform } from "@akeru/shared/hostProcess";
import { vi } from "vite-plus/test";
import * as ProcessRunner from "../processRunner.ts";
import * as ServerEnvironmentLabel from "./ServerEnvironmentLabel.ts";
const isServerEnvironmentLabelFileError = Schema.is(
ServerEnvironmentLabel.ServerEnvironmentLabelFileError,
);
const isServerEnvironmentLabelCommandError = Schema.is(
ServerEnvironmentLabel.ServerEnvironmentLabelCommandError,
);
interface CapturedLog {
readonly message: unknown;
readonly annotations: typeof References.CurrentLogAnnotations.Service;
}
const runMock = vi.fn<ProcessRunner.ProcessRunner["Service"]["run"]>();
const ProcessRunnerTest = Layer.succeed(
ProcessRunner.ProcessRunner,
ProcessRunner.ProcessRunner.of({
run: (input) => runMock(input),
}),
);
const NoopFileSystemLayer = FileSystem.layerNoop({});
const TestLayer = Layer.merge(NoopFileSystemLayer, ProcessRunnerTest);
const LinuxMachineInfoLayer = Layer.merge(
ProcessRunnerTest,
FileSystem.layerNoop({
exists: (path) => Effect.succeed(path === "/etc/machine-info"),
readFileString: (path) =>
path === "/etc/machine-info"
? Effect.succeed('PRETTY_HOSTNAME="Build Agent 01"\nICON_NAME="computer-vm"\n')
: Effect.succeed(""),
}),
);
const withHostPlatform = <ROut, E, RIn>(
layer: Layer.Layer<ROut, E, RIn>,
platform: NodeJS.Platform,
hostname: string,
) =>
Layer.mergeAll(
layer,
Layer.succeed(HostProcessPlatform, platform),
Layer.succeed(HostProcessHostname, hostname),
);
afterEach(() => {
runMock.mockReset();
});
describe("resolveServerEnvironmentLabel", () => {
it.effect("uses hostname fallback regardless of launch mode", () =>
Effect.gen(function* () {
const result = yield* ServerEnvironmentLabel.resolveServerEnvironmentLabel({
cwdBaseName: "t3code",
}).pipe(Effect.provide(withHostPlatform(TestLayer, "win32", "macbook-pro")));
expect(result).toBe("macbook-pro");
}),
);
it.effect("prefers the macOS ComputerName", () =>
Effect.gen(function* () {
runMock.mockReturnValueOnce(
Effect.succeed({
stdout: " Julius's MacBook Pro \n",
stderr: "",
code: ChildProcessSpawner.ExitCode(0),
timedOut: false,
stdoutTruncated: false,
stderrTruncated: false,
stdoutInvalidUtf8: false,
stderrInvalidUtf8: false,
}),
);
const result = yield* ServerEnvironmentLabel.resolveServerEnvironmentLabel({
cwdBaseName: "t3code",
}).pipe(Effect.provide(withHostPlatform(TestLayer, "darwin", "macbook-pro")));
expect(result).toBe("Julius's MacBook Pro");
expect(runMock).toHaveBeenCalledWith(
expect.objectContaining({
command: "scutil",
args: ["--get", "ComputerName"],
timeoutBehavior: "timedOutResult",
}),
);
}),
);
it.effect("prefers Linux PRETTY_HOSTNAME from machine-info", () =>
Effect.gen(function* () {
const result = yield* ServerEnvironmentLabel.resolveServerEnvironmentLabel({
cwdBaseName: "t3code",
}).pipe(Effect.provide(withHostPlatform(LinuxMachineInfoLayer, "linux", "buildbox")));
expect(result).toBe("Build Agent 01");
expect(runMock).not.toHaveBeenCalled();
}),
);
it.effect("falls back to hostnamectl pretty hostname on Linux", () =>
Effect.gen(function* () {
runMock.mockReturnValueOnce(
Effect.succeed({
stdout: "CI Runner\n",
stderr: "",
code: ChildProcessSpawner.ExitCode(0),
timedOut: false,
stdoutTruncated: false,
stderrTruncated: false,
stdoutInvalidUtf8: false,
stderrInvalidUtf8: false,
}),
);
const result = yield* ServerEnvironmentLabel.resolveServerEnvironmentLabel({
cwdBaseName: "t3code",
}).pipe(Effect.provide(withHostPlatform(TestLayer, "linux", "runner-01")));
expect(result).toBe("CI Runner");
expect(runMock).toHaveBeenCalledWith(
expect.objectContaining({
command: "hostnamectl",
args: ["--pretty"],
timeoutBehavior: "timedOutResult",
}),
);
}),
);
it.effect("falls back to the hostname when friendly labels are unavailable", () =>
Effect.gen(function* () {
const result = yield* ServerEnvironmentLabel.resolveServerEnvironmentLabel({
cwdBaseName: "t3code",
}).pipe(Effect.provide(withHostPlatform(TestLayer, "win32", "JULIUS-LAPTOP")));
expect(result).toBe("JULIUS-LAPTOP");
}),
);
it.effect("falls back to the hostname when the friendly-label command is missing", () => {
const logs: CapturedLog[] = [];
const logger = Logger.make(({ fiber, message }) => {
logs.push({
message,
annotations: fiber.getRef(References.CurrentLogAnnotations),
});
});
const spawnCause = new Error("spawn scutil ENOENT");
const processError = new ProcessRunner.ProcessSpawnError({
command: "scutil",
argumentCount: 2,
cause: spawnCause,
});
runMock.mockReturnValueOnce(Effect.fail(processError));
return Effect.gen(function* () {
const result = yield* ServerEnvironmentLabel.resolveServerEnvironmentLabel({
cwdBaseName: "t3code",
});
expect(result).toBe("macbook-pro");
expect(logs[0]?.message).toEqual([
"Failed to run environment-label probe 'macos-computer-name' with scutil.",
]);
const error = logs[0]?.annotations.cause;
expect(isServerEnvironmentLabelCommandError(error)).toBe(true);
if (isServerEnvironmentLabelCommandError(error)) {
expect(error.probe).toBe("macos-computer-name");
expect(error.executable).toBe("scutil");
expect(error.argumentCount).toBe(2);
expect(error).not.toHaveProperty("args");
expect(error.message).not.toContain("--get");
expect(error.message).not.toContain("ComputerName");
expect(error.cause).toBe(processError);
expect(processError.cause).toBe(spawnCause);
}
}).pipe(
Effect.provide(
Layer.mergeAll(
withHostPlatform(TestLayer, "darwin", "macbook-pro"),
Logger.layer([logger], { mergeWithExisting: false }),
Layer.succeed(References.MinimumLogLevel, "Debug"),
),
),
);
});
it.effect("continues to hostnamectl after a machine-info inspect failure", () => {
const logs: CapturedLog[] = [];
const logger = Logger.make(({ fiber, message }) => {
logs.push({
message,
annotations: fiber.getRef(References.CurrentLogAnnotations),
});
});
const fileCause = new Error("permission denied");
const platformError = PlatformError.systemError({
_tag: "PermissionDenied",
module: "FileSystem",
method: "exists",
pathOrDescriptor: "/etc/machine-info",
cause: fileCause,
});
const fileSystemLayer = FileSystem.layerNoop({
exists: () => Effect.fail(platformError),
});
runMock.mockReturnValueOnce(
Effect.succeed({
stdout: "CI Runner\n",
stderr: "",
code: ChildProcessSpawner.ExitCode(0),
timedOut: false,
stdoutTruncated: false,
stderrTruncated: false,
stdoutInvalidUtf8: false,
stderrInvalidUtf8: false,
}),
);
return Effect.gen(function* () {
const result = yield* ServerEnvironmentLabel.resolveServerEnvironmentLabel({
cwdBaseName: "t3code",
});
expect(result).toBe("CI Runner");
expect(logs[0]?.message).toEqual([
"Failed to inspect environment-label file at /etc/machine-info.",
]);
const error = logs[0]?.annotations.cause;
expect(isServerEnvironmentLabelFileError(error)).toBe(true);
if (isServerEnvironmentLabelFileError(error)) {
expect(error.operation).toBe("inspect");
expect(error.path).toBe("/etc/machine-info");
expect(error.cause).toBe(platformError);
expect(platformError.cause).toBe(fileCause);
}
}).pipe(
Effect.provide(
Layer.mergeAll(
withHostPlatform(Layer.merge(ProcessRunnerTest, fileSystemLayer), "linux", "buildbox"),
Logger.layer([logger], { mergeWithExisting: false }),
Layer.succeed(References.MinimumLogLevel, "Debug"),
),
),
);
});
it.effect("falls back to the cwd basename when the hostname is blank", () =>
Effect.gen(function* () {
runMock.mockReturnValueOnce(
Effect.succeed({
stdout: " ",
stderr: "",
code: ChildProcessSpawner.ExitCode(0),
timedOut: false,
stdoutTruncated: false,
stderrTruncated: false,
stdoutInvalidUtf8: false,
stderrInvalidUtf8: false,
}),
);
const result = yield* ServerEnvironmentLabel.resolveServerEnvironmentLabel({
cwdBaseName: "t3code",
}).pipe(Effect.provide(withHostPlatform(TestLayer, "linux", " ")));
expect(result).toBe("t3code");
}),
);
});