const test = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const os = require("node:os");
const path = require("node:path");
const {
createLauncher,
whichAllSymforge,
isOwnShim,
classifyShadow,
} = require("../bin/launcher.js");
function tmpDir(t, prefix) {
const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
return root;
}
function writeFakeBinary(dir, name = "symforge", contents = "fake") {
fs.mkdirSync(dir, { recursive: true });
const file = path.join(dir, name);
fs.writeFileSync(file, contents);
return file;
}
test("whichAllSymforge returns existing PATH entries in PATH order", (t) => {
const root = tmpDir(t, "symforge-which-");
const dirA = path.join(root, "a");
const dirB = path.join(root, "b");
const dirEmpty = path.join(root, "empty");
fs.mkdirSync(dirEmpty, { recursive: true });
const binA = writeFakeBinary(dirA);
const binB = writeFakeBinary(dirB);
const env = { PATH: [dirA, dirEmpty, dirB].join(path.delimiter) };
const found = whichAllSymforge(env, "linux");
assert.deepEqual(found, [binA, binB]);
});
test("whichAllSymforge skips directories with no symforge", (t) => {
const root = tmpDir(t, "symforge-which-skip-");
const dirA = path.join(root, "a");
const dirB = path.join(root, "b");
fs.mkdirSync(dirA, { recursive: true });
const binB = writeFakeBinary(dirB);
const env = { PATH: [dirA, dirB].join(path.delimiter) };
const found = whichAllSymforge(env, "linux");
assert.deepEqual(found, [binB]);
});
test("whichAllSymforge ignores a directory that shares the symforge name", (t) => {
const root = tmpDir(t, "symforge-which-dir-");
const dir = path.join(root, "a");
fs.mkdirSync(path.join(dir, "symforge"), { recursive: true });
const env = { PATH: dir };
const found = whichAllSymforge(env, "linux");
assert.deepEqual(found, []);
});
test("whichAllSymforge returns [] when PATH is unset", () => {
assert.deepEqual(whichAllSymforge({}, "linux"), []);
assert.deepEqual(whichAllSymforge({ PATH: "" }, "linux"), []);
});
test("whichAllSymforge resolves Windows extensions via PATHEXT", (t) => {
const root = tmpDir(t, "symforge-which-win-");
const dir = path.join(root, "bin");
const cmd = writeFakeBinary(dir, "symforge.cmd");
const env = {
Path: dir,
PATHEXT: ".COM;.EXE;.BAT;.CMD",
};
const found = whichAllSymforge(env, "win32");
assert.deepEqual(found, [cmd]);
});
test("whichAllSymforge prefers the bare name before the extensioned shim within a dir", (t) => {
const root = tmpDir(t, "symforge-which-order-");
const dir = path.join(root, "bin");
const bare = writeFakeBinary(dir, "symforge");
const exe = writeFakeBinary(dir, "symforge.exe");
const env = { Path: dir, PATHEXT: ".EXE" };
const found = whichAllSymforge(env, "win32");
assert.deepEqual(found, [bare, exe]);
});
test("classifyShadow flags /usr/local as root/system", () => {
assert.equal(classifyShadow("/usr/local/bin/symforge", {}, "linux"), "root/system");
assert.equal(classifyShadow("/usr/bin/symforge", {}, "linux"), "root/system");
assert.equal(classifyShadow("/opt/symforge/bin/symforge", {}, "linux"), "root/system");
});
test("classifyShadow flags a foreign user prefix", () => {
assert.equal(
classifyShadow("/home/other/.npm-global/bin/symforge", {}, "linux"),
"foreign-prefix"
);
});
test("classifyShadow never returns root/system on Windows", () => {
assert.equal(classifyShadow("C:\\tools\\symforge\\symforge.exe", {}, "win32"), "foreign-prefix");
});
test("isOwnShim recognizes a shim in the npm prefix bin dir as ours", (t) => {
const root = tmpDir(t, "symforge-shim-prefix-");
const selfDir = path.join(root, "lib", "node_modules", "symforge", "bin");
fs.mkdirSync(selfDir, { recursive: true });
const prefix = path.join(root, "lib");
const shim = writeFakeBinary(path.join(prefix, "bin"), "symforge", "#!/bin/sh\nnode launcher\n");
assert.equal(isOwnShim(shim, selfDir), true);
});
test("isOwnShim recognizes a shim by its launcher reference even from a foreign dir", (t) => {
const root = tmpDir(t, "symforge-shim-content-");
const selfDir = path.join(root, "lib", "node_modules", "symforge", "bin");
fs.mkdirSync(selfDir, { recursive: true });
const shimDir = path.join(root, "somewhere", "else");
const shim = writeFakeBinary(
shimDir,
"symforge",
'require("../lib/node_modules/symforge/bin/launcher.js")'
);
assert.equal(isOwnShim(shim, selfDir), true);
});
test("isOwnShim treats a genuinely foreign install as not ours", (t) => {
const root = tmpDir(t, "symforge-shim-foreign-");
const selfDir = path.join(root, "lib", "node_modules", "symforge", "bin");
fs.mkdirSync(selfDir, { recursive: true });
const foreign = writeFakeBinary(path.join(root, "usr", "local", "bin"), "symforge", "totally different binary");
assert.equal(isOwnShim(foreign, selfDir), false);
});
test("launcher warns when a different symforge dir is first on PATH", (t) => {
const root = tmpDir(t, "symforge-warn-");
const shadowDir = path.join(root, "usr", "local", "bin");
const shadow = writeFakeBinary(shadowDir, "symforge");
const selfDir = path.join(root, "home", "lib", "node_modules", "symforge", "bin");
fs.mkdirSync(selfDir, { recursive: true });
const resolvedBinary = path.join(root, "home", "lib", "node_modules", "symforge-linux-x64", "bin", "symforge");
const errors = [];
const launcher = createLauncher({
process: {
platform: "linux",
arch: "x64",
env: { PATH: shadowDir },
},
console: { error: (message) => errors.push(message) },
selfDir,
resolveBinary() {
return { reason: "ok", binaryPath: resolvedBinary };
},
spawnSync() {
return { status: 0 };
},
});
assert.equal(launcher.main([]), 0);
const joined = errors.join("\n");
assert.match(joined, /different 'symforge'/);
assert.match(joined, new RegExp(shadow.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
assert.match(joined, /symforge init/);
});
test("launcher does NOT warn when its own npm shim is first on PATH", (t) => {
const root = tmpDir(t, "symforge-noshim-warn-");
const prefix = path.join(root, "prefix");
const selfDir = path.join(prefix, "lib", "node_modules", "symforge", "bin");
fs.mkdirSync(selfDir, { recursive: true });
const shimDir = path.join(prefix, "lib", "bin");
const shim = writeFakeBinary(shimDir, "symforge", "#!/bin/sh\nnode launcher\n");
const resolvedBinary = path.join(
prefix,
"lib",
"node_modules",
"symforge-linux-x64",
"bin",
"symforge"
);
const errors = [];
const launcher = createLauncher({
process: {
platform: "linux",
arch: "x64",
env: { PATH: shimDir },
},
console: { error: (message) => errors.push(message) },
selfDir,
resolveBinary() {
return { reason: "ok", binaryPath: resolvedBinary };
},
spawnSync() {
return { status: 0 };
},
});
assert.equal(launcher.main([]), 0);
assert.deepEqual(errors, []);
assert.notEqual(path.resolve(shim), path.resolve(resolvedBinary));
});
test("launcher does NOT warn when the resolved native binary is itself first on PATH", (t) => {
const root = tmpDir(t, "symforge-self-warn-");
const binDir = path.join(root, "bin");
const resolvedBinary = writeFakeBinary(binDir, "symforge");
const selfDir = path.join(root, "lib", "node_modules", "symforge", "bin");
fs.mkdirSync(selfDir, { recursive: true });
const errors = [];
const launcher = createLauncher({
process: {
platform: "linux",
arch: "x64",
env: { PATH: binDir },
},
console: { error: (message) => errors.push(message) },
selfDir,
resolveBinary() {
return { reason: "ok", binaryPath: resolvedBinary };
},
spawnSync() {
return { status: 0 };
},
});
assert.equal(launcher.main([]), 0);
assert.deepEqual(errors, []);
});
function linkedInstall(t, prefix) {
const selfDir = path.join(prefix, "lib", "node_modules", "symforge", "bin");
fs.mkdirSync(selfDir, { recursive: true });
fs.writeFileSync(path.join(selfDir, "symforge.js"), "// launcher\n");
const binDir = path.join(prefix, "bin");
fs.mkdirSync(binDir, { recursive: true });
const link = path.join(binDir, "symforge");
try {
fs.symlinkSync(path.join(selfDir, "symforge.js"), link);
} catch (err) {
t.skip(`symlinks unavailable: ${err.code}`);
return null;
}
return { selfDir, binDir, link };
}
function runLauncher(selfDir, pathDirs, resolvedBinary) {
const errors = [];
const launcher = createLauncher({
process: { platform: "linux", arch: "x64", env: { PATH: pathDirs.join(path.delimiter) } },
console: { error: (message) => errors.push(message) },
selfDir,
resolveBinary() {
return { reason: "ok", binaryPath: resolvedBinary };
},
spawnSync() {
return { status: 0 };
},
});
assert.equal(launcher.main([]), 0);
return errors;
}
test("launcher does NOT flag itself when first on PATH through a symlinked bin", (t) => {
const root = tmpDir(t, "symforge-selflink-");
const install = linkedInstall(t, path.join(root, ".npm-global"));
if (!install) return;
const resolvedBinary = path.join(root, ".npm-global", "lib", "node_modules", "symforge-linux-x64", "bin", "symforge");
assert.deepEqual(runLauncher(install.selfDir, [install.binDir], resolvedBinary), []);
});
test("launcher reached through a symlinked prefix does not flag itself", (t) => {
const root = tmpDir(t, "symforge-prefixlink-");
const install = linkedInstall(t, path.join(root, "real-prefix"));
if (!install) return;
const aliasPrefix = path.join(root, "alias-prefix");
try {
fs.symlinkSync(path.join(root, "real-prefix"), aliasPrefix, "dir");
} catch (err) {
t.skip(`symlinks unavailable: ${err.code}`);
return;
}
const resolvedBinary = path.join(root, "real-prefix", "lib", "node_modules", "symforge-linux-x64", "bin", "symforge");
assert.deepEqual(runLauncher(install.selfDir, [path.join(aliasPrefix, "bin")], resolvedBinary), []);
});
test("a genuinely different first copy still warns even when this launcher is also on PATH", (t) => {
const root = tmpDir(t, "symforge-twocopies-");
const mine = linkedInstall(t, path.join(root, "mine"));
if (!mine) return;
const other = linkedInstall(t, path.join(root, "other"));
if (!other) return;
const resolvedBinary = path.join(root, "mine", "lib", "node_modules", "symforge-linux-x64", "bin", "symforge");
const errors = runLauncher(mine.selfDir, [other.binDir, mine.binDir], resolvedBinary);
const joined = errors.join("\n");
assert.match(joined, /different 'symforge'/);
assert.ok(joined.includes(other.link), joined);
});
test("SYMFORGE_NO_SHADOW_WARN suppresses the warning entirely", (t) => {
const root = tmpDir(t, "symforge-suppress-");
const shadowDir = path.join(root, "usr", "local", "bin");
writeFakeBinary(shadowDir, "symforge");
const selfDir = path.join(root, "home", "lib", "node_modules", "symforge", "bin");
fs.mkdirSync(selfDir, { recursive: true });
const resolvedBinary = path.join(root, "home", "lib", "node_modules", "symforge-linux-x64", "bin", "symforge");
const errors = [];
const launcher = createLauncher({
process: {
platform: "linux",
arch: "x64",
env: { PATH: shadowDir, SYMFORGE_NO_SHADOW_WARN: "1" },
},
console: { error: (message) => errors.push(message) },
selfDir,
resolveBinary() {
return { reason: "ok", binaryPath: resolvedBinary };
},
spawnSync() {
return { status: 0 };
},
});
assert.equal(launcher.main([]), 0);
assert.deepEqual(errors, []);
});
test("the shadow warning never writes to stdout", (t) => {
const root = tmpDir(t, "symforge-stdout-");
const shadowDir = path.join(root, "usr", "local", "bin");
writeFakeBinary(shadowDir, "symforge");
const selfDir = path.join(root, "home", "lib", "node_modules", "symforge", "bin");
fs.mkdirSync(selfDir, { recursive: true });
const resolvedBinary = path.join(root, "home", "lib", "node_modules", "symforge-linux-x64", "bin", "symforge");
const stdoutChunks = [];
const originalWrite = process.stdout.write;
process.stdout.write = (chunk, ...rest) => {
stdoutChunks.push(String(chunk));
return originalWrite.call(process.stdout, chunk, ...rest);
};
t.after(() => {
process.stdout.write = originalWrite;
});
const launcher = createLauncher({
process: {
platform: "linux",
arch: "x64",
env: { PATH: shadowDir },
},
selfDir,
resolveBinary() {
return { reason: "ok", binaryPath: resolvedBinary };
},
spawnSync() {
return { status: 0 };
},
});
assert.equal(launcher.main([]), 0);
assert.equal(stdoutChunks.join(""), "");
});
test("a thrown error inside the shadow check does not prevent spawn", (t) => {
const selfDir = path.join(os.tmpdir(), "symforge-throw-self");
const spawnCalls = [];
const explodingEnv = {};
Object.defineProperty(explodingEnv, "PATH", {
enumerable: true,
get() {
throw new Error("boom: PATH access exploded");
},
});
const errors = [];
const launcher = createLauncher({
process: {
platform: "linux",
arch: "x64",
env: explodingEnv,
},
console: { error: (message) => errors.push(message) },
selfDir,
resolveBinary() {
return { reason: "ok", binaryPath: "/some/native/symforge" };
},
spawnSync(command, args, options) {
spawnCalls.push({ command, args, options });
return { status: 0 };
},
});
assert.equal(launcher.main(["--version"]), 0);
assert.equal(spawnCalls.length, 1);
assert.equal(spawnCalls[0].command, "/some/native/symforge");
});