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 Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import {
ancestorNodeModulesPaths,
copyDirectoryPreservingSymlinks,
} from "./build-desktop-artifact.ts";
import { assert, it } from "@effect/vitest";
import {
createStageWorkspaceConfig,
resolveDesktopRuntimeDependencies,
STAGE_INSTALL_ARGS,
} from "./build-desktop-artifact.ts";
it.layer(NodeServices.layer)("build-desktop-artifact", (it) => {
it("omits bundled workspace packages from staged desktop dependencies", () => {
assert.deepStrictEqual(
resolveDesktopRuntimeDependencies(
{
"@effect/platform-node": "catalog:",
"@akeru/contracts": "workspace:*",
"@akeru/shared": "workspace:*",
"@akeru/ssh": "workspace:*",
"@akeru/tailscale": "workspace:*",
effect: "catalog:",
electron: "41.5.0",
},
{
"@effect/platform-node": "4.0.0-beta.59",
effect: "4.0.0-beta.59",
},
),
{
"@effect/platform-node": "4.0.0-beta.59",
effect: "4.0.0-beta.59",
},
);
});
it("installs optional native dependencies for the target desktop architecture", () => {
assert.deepStrictEqual(STAGE_INSTALL_ARGS, ["install", "--prod"]);
assert.deepStrictEqual(createStageWorkspaceConfig({ platform: "mac", arch: "x64" }), {
supportedArchitectures: {
os: ["darwin"],
cpu: ["x64"],
},
});
assert.deepStrictEqual(createStageWorkspaceConfig({ platform: "linux", arch: "x64" }), {
supportedArchitectures: {
os: ["linux"],
cpu: ["x64"],
libc: ["glibc"],
},
});
// The Windows app stage only serves the desktop main process; the server
// sidecar stage is the one that needs Linux natives (below).
assert.deepStrictEqual(createStageWorkspaceConfig({ platform: "win", arch: "x64" }), {
supportedArchitectures: {
os: ["win32"],
cpu: ["x64"],
},
});
// The server sidecar stage bundles the same-architecture WSL (Linux,
// glibc) backend, so its install must fetch Linux native optional deps
// (e.g. ffi-rs) too — and must be hoisted so the tree survives asar
// packing and runtime extraction without symlinks.
assert.deepStrictEqual(
createStageWorkspaceConfig({ platform: "win", arch: "x64", linuxServerBackend: true }),
{
supportedArchitectures: {
os: ["win32", "linux"],
cpu: ["x64"],
libc: ["glibc"],
},
nodeLinker: "hoisted",
},
);
assert.deepStrictEqual(
createStageWorkspaceConfig({ platform: "win", arch: "arm64", linuxServerBackend: true }),
{
supportedArchitectures: {
os: ["win32", "linux"],
cpu: ["arm64"],
libc: ["glibc"],
},
nodeLinker: "hoisted",
},
);
assert.deepStrictEqual(createStageWorkspaceConfig({ platform: "mac", arch: "universal" }), {
supportedArchitectures: {
os: ["darwin"],
cpu: ["arm64", "x64"],
},
});
});
});
import * as NodeServices from "@effect/platform-node/NodeServices";
// The self-containment check runs the packaged tree in a scratch directory. Its
// own node_modules holds the sidecar externals and must be ignored, but any
// node_modules *above* it would let Node's parent walk satisfy an import that is
// missing from the package, so the probe refuses to run in that case.
it("lists ancestor node_modules, nearest first, excluding the start directory", () => {
assert.deepStrictEqual(ancestorNodeModulesPaths("C:\\tmp\\probe\\app", "\\"), [
"C:\\tmp\\probe\\node_modules",
"C:\\tmp\\node_modules",
"C:\\node_modules",
]);
});
it("includes the filesystem root for posix paths", () => {
assert.deepStrictEqual(ancestorNodeModulesPaths("/tmp/probe", "/"), [
"/tmp/node_modules",
"/node_modules",
]);
});
// A UNC root must keep its \\server\share prefix. Rebuilding it from segments
// produced relative paths, which fs.exists resolves against the build cwd, so
// the guard checked directories that do not exist and silently passed.
it("keeps the prefix of a UNC path instead of going relative", () => {
const paths = ancestorNodeModulesPaths("\\\\server\\share\\tmp\\app", "\\");
for (const candidate of paths) {
assert.ok(candidate.startsWith("\\\\server\\share"), candidate);
}
assert.deepStrictEqual(paths[0], "\\\\server\\share\\tmp\\node_modules");
});
it.effect("rebases packaged links into the isolated tree", () =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3code-copy-symlinks-" });
const source = path.join(root, "source");
const destination = path.join(root, "destination");
const packageDir = path.join(source, "node_modules/.pnpm/example@1/node_modules/example");
const relativePackageLink = path.join(source, "node_modules/example-relative");
const absolutePackageLink = path.join(source, "node_modules/example-absolute");
yield* fs.makeDirectory(packageDir, { recursive: true });
yield* fs.writeFileString(path.join(packageDir, "index.js"), "module.exports = true;\n");
yield* fs.symlink(
path.join(".pnpm", "example@1", "node_modules", "example"),
relativePackageLink,
);
yield* fs.symlink(packageDir, absolutePackageLink);
yield* copyDirectoryPreservingSymlinks(source, destination);
const copiedPackage = path.join(
destination,
"node_modules/.pnpm/example@1/node_modules/example",
);
const resolvedCopiedPackage = yield* fs.realPath(copiedPackage);
assert.equal(
yield* fs.readLink(path.join(destination, "node_modules/example-relative")),
copiedPackage,
);
assert.equal(
yield* fs.readLink(path.join(destination, "node_modules/example-absolute")),
copiedPackage,
);
assert.equal(
yield* fs.realPath(path.join(destination, "node_modules/example-relative")),
resolvedCopiedPackage,
);
assert.equal(
yield* fs.realPath(path.join(destination, "node_modules/example-absolute")),
resolvedCopiedPackage,
);
}).pipe(Effect.provide(NodeServices.layer)),
);
it("ignores trailing separators", () => {
assert.deepStrictEqual(
ancestorNodeModulesPaths("C:\\tmp\\probe\\app\\", "\\"),
ancestorNodeModulesPaths("C:\\tmp\\probe\\app", "\\"),
);
});