ttsc 0.11.0 → 0.12.0

package/lib/plugin/internal/buildSourcePlugin.js

@@ -4,6 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSourcePlugin = buildSourcePlugin;
+exports.resolvePluginCacheRoot = resolvePluginCacheRoot;
+exports.resolveGlobalPluginCacheRoot = resolveGlobalPluginCacheRoot;
+exports.defaultPluginCacheCleanTargets = defaultPluginCacheCleanTargets;
 exports.computeCacheKey = computeCacheKey;
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = __importDefault(require("node:crypto"));
@@ -16,14 +19,15 @@ const TTSC_GO_MODULE_PATH = "github.com/samchon/ttsc/packages/ttsc";
 const TSGO_GO_MODULE_PATH = "github.com/microsoft/typescript-go";
 const PRUNE_DIRS = new Set(["node_modules", ".git", ".ttsc"]);
 const GENERATED_WORKSPACE_FILES = new Set(["go.work", "go.work.sum"]);
-// Go env vars that change the produced binary. Hashed into the plugin
-// build cache key so cross-compile target / build tags / cgo toggle
-// don't collide with the native-platform key.
+// Go build environment values that can change the produced binary or decide
+// whether `go build` succeeds. Hashed into the plugin cache key so target,
+// build-tag, cgo, FIPS, and external-link variants never collide.
 const GO_BUILD_ENV_KEYS = [
     "GOOS",
     "GOARCH",
     "GOAMD64",
     "GOARM",
+    "GOARM64",
     "GO386",
     "GOMIPS",
     "GOMIPS64",
@@ -32,15 +36,77 @@ const GO_BUILD_ENV_KEYS = [
     "GOWASM",
     "GOFLAGS",
     "GOEXPERIMENT",
+    "GOFIPS140",
+    "GO_EXTLINK_ENABLED",
+    "GCCGO",
+    "GCCGOTOOLDIR",
     "CGO_ENABLED",
+    "AR",
+    "CC",
+    "CXX",
+    "FC",
+    "PKG_CONFIG",
+    "CGO_CFLAGS",
+    "CGO_CFLAGS_ALLOW",
+    "CGO_CFLAGS_DISALLOW",
+    "CGO_CPPFLAGS",
+    "CGO_CPPFLAGS_ALLOW",
+    "CGO_CPPFLAGS_DISALLOW",
+    "CGO_CXXFLAGS",
+    "CGO_CXXFLAGS_ALLOW",
+    "CGO_CXXFLAGS_DISALLOW",
+    "CGO_FFLAGS",
+    "CGO_FFLAGS_ALLOW",
+    "CGO_FFLAGS_DISALLOW",
+    "CGO_LDFLAGS",
+    "CGO_LDFLAGS_ALLOW",
+    "CGO_LDFLAGS_DISALLOW",
     "GOTOOLCHAIN",
+    "GOROOT",
+];
+const GO_BUILD_COMMAND_ENV_KEYS = new Set([
+    "AR",
+    "CC",
+    "CXX",
+    "FC",
+    "GCCGO",
+    "PKG_CONFIG",
+]);
+const EXTERNAL_GO_BUILD_ENV_KEYS = [
+    "CPATH",
+    "C_INCLUDE_PATH",
+    "CPLUS_INCLUDE_PATH",
+    "DYLD_LIBRARY_PATH",
+    "INCLUDE",
+    "LD_LIBRARY_PATH",
+    "LIB",
+    "LIBRARY_PATH",
+    "LIBPATH",
+    "MACOSX_DEPLOYMENT_TARGET",
+    "OBJC_INCLUDE_PATH",
+    "PKG_CONFIG_ALLOW_SYSTEM_CFLAGS",
+    "PKG_CONFIG_ALLOW_SYSTEM_LIBS",
+    "PKG_CONFIG_LIBDIR",
+    "PKG_CONFIG_PATH",
+    "PKG_CONFIG_SYSROOT_DIR",
+    "PKG_CONFIG_TOP_BUILD_DIR",
+    "SDKROOT",
 ];
 const CONTRIBUTIONS_FILE_NAME = "ttsc_contributions.go";
 const CONTRIB_DIRNAME = "contrib";
+const GLOBAL_CACHE_DIRNAME = "ttsc";
+const PLUGIN_CACHE_DIRNAME = "plugins";
+const CACHE_LAST_USED_FILE = ".last-used";
+const CACHE_GC_MARKER_FILE = ".gc-last-run";
+const GLOBAL_CACHE_GC_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const GLOBAL_CACHE_ENTRY_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+const GLOBAL_CACHE_MAX_BYTES = 2 * 1024 * 1024 * 1024;
+const GLOBAL_CACHE_TARGET_BYTES = Math.floor(GLOBAL_CACHE_MAX_BYTES * 0.8);
+const GLOBAL_CACHE_PROTECTED_AGE_MS = 60 * 60 * 1000;
 /** Build one Go source plugin into a cached executable. */
 function buildSourcePlugin(opts) {
     const { dir, entry, source } = resolveSourceBuildTarget(opts);
-    const overlayDirs = opts.overlayDirs ?? findTtscOverlayDirs();
+    const overlayDirs = [...(opts.overlayDirs ?? findTtscOverlayDirs())].sort();
     const contributors = opts.contributors ?? [];
     const goBinary = resolveGoCompiler();
     ensureExecutableGoToolchain(goBinary);
@@ -58,6 +124,7 @@ function buildSourcePlugin(opts) {
     const binaryName = process.platform === "win32" ? "plugin.exe" : "plugin";
     const binaryPath = node_path_1.default.join(cacheDir, binaryName);
     if (node_fs_1.default.existsSync(binaryPath)) {
+        touchCacheEntry(cacheDir);
         return binaryPath;
     }
     node_fs_1.default.mkdirSync(cacheDir, { recursive: true });
@@ -88,6 +155,7 @@ function buildSourcePlugin(opts) {
         runGoBuild(scratchDir, entry, scratchBinaryName, opts.pluginName, goBinary);
         const builtBinary = node_path_1.default.join(scratchDir, scratchBinaryName);
         publishBuiltBinary(builtBinary, binaryPath);
+        touchCacheEntry(cacheDir);
         return binaryPath;
     }
     finally {
@@ -305,11 +373,18 @@ function materializeScratchDir(source, scratch) {
 function writeGoWork(scratchDir, useDirs, goBinary, pluginName) {
     const goModReader = createGoModReader(goBinary, pluginName);
     validateSourceReplacements(scratchDir, useDirs, goModReader, pluginName);
+    const sourceInfo = goModReader.read(scratchDir);
+    const effectiveUseDirs = sourceInfo.modulePath === TTSC_GO_MODULE_PATH
+        ? useDirs.filter((dir) => {
+            const modulePath = goModReader.read(dir).modulePath;
+            return modulePath !== null && !isTtscManagedModulePath(modulePath);
+        })
+        : useDirs;
     const useLines = ["\t."];
-    for (const dir of useDirs) {
+    for (const dir of effectiveUseDirs) {
         useLines.push(`\t${dir.replace(/\\/g, "/")}`);
     }
-    const replaceLines = sourceBuildWorkspaceReplacements(useDirs, goModReader);
+    const replaceLines = sourceBuildWorkspaceReplacements(effectiveUseDirs, goModReader);
     const replaceBlock = replaceLines.length === 0 ? "" : `\n\n${replaceLines.join("\n")}\n`;
     const goWork = `go 1.26\n\nuse (\n${useLines.join("\n")}\n)${replaceBlock}`;
     node_fs_1.default.writeFileSync(node_path_1.default.join(scratchDir, "go.work"), goWork, "utf8");
@@ -447,6 +522,7 @@ function goToolchainNotFoundMessage(pluginName) {
 }
 function goBuildEnv(goBinary) {
     const env = { ...process.env };
+    env.GOWORK = "auto";
     const goRoot = inferGoRoot(goBinary);
     if (goRoot && !env.GOROOT) {
         env.GOROOT = goRoot;
@@ -546,25 +622,51 @@ function walkForGoMod(dir, out) {
 }
 function resolvePluginCacheRoot(projectRoot, cacheDir) {
     if (cacheDir) {
-        return node_path_1.default.resolve(projectRoot, cacheDir, "plugins");
+        return node_path_1.default.resolve(projectRoot, cacheDir, PLUGIN_CACHE_DIRNAME);
     }
     if (process.env.TTSC_CACHE_DIR) {
-        return node_path_1.default.resolve(process.env.TTSC_CACHE_DIR, "plugins");
-    }
-    const root = node_path_1.default.resolve(projectRoot);
-    const nodeModules = node_path_1.default.join(root, "node_modules");
-    if (isDirectory(nodeModules)) {
-        return node_path_1.default.join(nodeModules, ".ttsc", "plugins");
+        return node_path_1.default.resolve(process.env.TTSC_CACHE_DIR, PLUGIN_CACHE_DIRNAME);
     }
-    return node_path_1.default.join(root, ".ttsc", "plugins");
+    const root = resolveGlobalPluginCacheRoot();
+    maybePruneGlobalPluginCache(root);
+    return root;
 }
-function isDirectory(candidate) {
-    try {
-        return node_fs_1.default.statSync(candidate).isDirectory();
+function resolveGlobalPluginCacheRoot() {
+    return node_path_1.default.join(resolveUserCacheRoot(), GLOBAL_CACHE_DIRNAME, PLUGIN_CACHE_DIRNAME);
+}
+function defaultPluginCacheCleanTargets(projectRoot) {
+    return [
+        resolveGlobalPluginCacheRoot(),
+        node_path_1.default.join(projectRoot, "node_modules", ".ttsc"),
+        node_path_1.default.join(projectRoot, ".ttsc"),
+    ];
+}
+function resolveUserCacheRoot() {
+    const xdg = process.env.XDG_CACHE_HOME;
+    if (xdg && node_path_1.default.isAbsolute(xdg)) {
+        return xdg;
+    }
+    if (process.platform === "win32") {
+        const local = process.env.LOCALAPPDATA;
+        if (local && node_path_1.default.isAbsolute(local)) {
+            return local;
+        }
+        const home = node_os_1.default.homedir();
+        if (home) {
+            return node_path_1.default.join(home, "AppData", "Local");
+        }
     }
-    catch {
-        return false;
+    if (process.platform === "darwin") {
+        const home = node_os_1.default.homedir();
+        if (home) {
+            return node_path_1.default.join(home, "Library", "Caches");
+        }
+    }
+    const home = node_os_1.default.homedir();
+    if (home) {
+        return node_path_1.default.join(home, ".cache");
     }
+    return node_path_1.default.join(node_os_1.default.tmpdir(), "ttsc-cache");
 }
 function resolveGoCompiler() {
     const explicit = process.env.TTSC_GO_BINARY;
@@ -596,17 +698,8 @@ function computeCacheKey(inputs) {
     if (inputs.goBinary !== undefined) {
         hash.update(`go=${resolveGoCompilerIdentity(inputs.goBinary)}\n`);
     }
-    // Hash the Go env vars that change `go build`'s output (cross-compile
-    // target, build tags, cgo toggle, etc.). Without this, a user setting
-    // `GOOS=linux GOARCH=arm64` on a darwin host would write a Linux-arm64
-    // binary into the same cache slot as the native build, and the next
-    // native invocation would spawn an unrunnable artifact.
-    for (const key of GO_BUILD_ENV_KEYS) {
-        const value = process.env[key];
-        if (value !== undefined && value !== "") {
-            hash.update(`${key}=${value}\n`);
-        }
-    }
+    hashGoBuildEnvironment(hash, inputs.goBinary, inputs.dir);
+    hashExternalGoBuildEnvironment(hash);
     hashSourceDirectory(hash, "plugin", inputs.dir);
     for (const [index, dir] of [...(inputs.overlayDirs ?? [])].sort().entries()) {
         hashSourceDirectory(hash, `overlay:${index}`, dir);
@@ -681,22 +774,18 @@ function isHashableFile(name) {
 }
 function resolveGoCompilerIdentity(goBinary) {
     const resolved = resolveExecutableIdentityPath(goBinary);
+    if (!node_fs_1.default.existsSync(resolved)) {
+        return "missing";
+    }
     const version = (0, node_child_process_1.spawnSync)(goBinary, ["version"], {
         encoding: "utf8",
         windowsHide: true,
     });
     const versionText = version.error !== undefined
-        ? version.error.message
+        ? (version.error.code ?? version.error.message)
         : `${version.status ?? 0}:${version.stdout}${version.stderr}`;
-    let statText = "";
-    try {
-        const stat = node_fs_1.default.statSync(resolved);
-        statText = `${stat.size}:${stat.mtimeMs}`;
-    }
-    catch {
-        statText = "missing";
-    }
-    return `${goBinary}:${resolved}:${statText}:${versionText}`;
+    const binaryHash = hashFile(resolved);
+    return `sha256:${binaryHash}:${versionText}`;
 }
 function resolveExecutableIdentityPath(binary) {
     if (node_path_1.default.isAbsolute(binary)) {
@@ -705,7 +794,7 @@ function resolveExecutableIdentityPath(binary) {
     if (binary.includes(node_path_1.default.sep)) {
         return resolveRealPath(node_path_1.default.resolve(binary));
     }
-    for (const dir of (process.env.PATH ?? "").split(node_path_1.default.delimiter)) {
+    for (const dir of readPathEnvironment().split(node_path_1.default.delimiter)) {
         if (dir.length === 0)
             continue;
         const candidate = node_path_1.default.join(dir, binary);
@@ -721,6 +810,9 @@ function resolveExecutableIdentityPath(binary) {
     }
     return binary;
 }
+function readPathEnvironment() {
+    return process.env.PATH ?? process.env.Path ?? "";
+}
 function resolveRealPath(location) {
     try {
         return node_fs_1.default.realpathSync(location);
@@ -729,4 +821,315 @@ function resolveRealPath(location) {
         return location;
     }
 }
+function hashFile(file) {
+    const hash = node_crypto_1.default.createHash("sha256");
+    hash.update(node_fs_1.default.readFileSync(file));
+    return hash.digest("hex");
+}
+function hashGoBuildEnvironment(hash, goBinary, cwd) {
+    const values = resolveGoBuildEnvironment(goBinary, cwd);
+    for (const key of GO_BUILD_ENV_KEYS) {
+        const value = values.get(key);
+        if (value !== undefined && value !== "") {
+            hash.update(`${key}=${value}\n`);
+        }
+    }
+}
+function resolveGoBuildEnvironment(goBinary, cwd) {
+    const values = new Map();
+    if (goBinary !== undefined) {
+        const result = (0, node_child_process_1.spawnSync)(goBinary, ["env", "-json", ...GO_BUILD_ENV_KEYS], {
+            cwd,
+            encoding: "utf8",
+            env: goBuildEnv(goBinary),
+            maxBuffer: 1024 * 1024,
+            windowsHide: true,
+        });
+        if (result.error === undefined && result.status === 0) {
+            try {
+                const parsed = JSON.parse(result.stdout);
+                for (const key of GO_BUILD_ENV_KEYS) {
+                    const raw = parsed[key];
+                    if (typeof raw === "string" && raw !== "") {
+                        values.set(key, normalizeGoBuildEnvValue(key, raw));
+                    }
+                }
+            }
+            catch {
+                // Fall back to process.env below; a cache key is still better than
+                // failing before `go build` can produce the actionable error.
+            }
+        }
+    }
+    for (const key of GO_BUILD_ENV_KEYS) {
+        if (values.has(key))
+            continue;
+        const value = process.env[key];
+        if (value !== undefined && value !== "") {
+            values.set(key, normalizeGoBuildEnvValue(key, value));
+        }
+    }
+    return values;
+}
+function normalizeGoBuildEnvValue(key, value) {
+    if (key === "GOROOT") {
+        return resolveGoRootCacheIdentity(value);
+    }
+    if (GO_BUILD_COMMAND_ENV_KEYS.has(key)) {
+        return `${value}\0${resolveCommandCacheIdentity(value)}`;
+    }
+    return value;
+}
+function resolveCommandCacheIdentity(command) {
+    const executable = firstCommandToken(command);
+    if (executable === null) {
+        return "command:empty";
+    }
+    const resolved = resolveExecutableIdentityPath(executable);
+    if (!node_fs_1.default.existsSync(resolved)) {
+        return `command:missing:${executable}`;
+    }
+    try {
+        return `command:sha256:${hashFile(resolved)}`;
+    }
+    catch {
+        return `command:unreadable:${resolved}`;
+    }
+}
+function firstCommandToken(command) {
+    const trimmed = command.trim();
+    if (trimmed === "") {
+        return null;
+    }
+    const quote = trimmed[0];
+    if (quote === "'" || quote === '"') {
+        const end = trimmed.indexOf(quote, 1);
+        return end === -1 ? trimmed.slice(1) : trimmed.slice(1, end);
+    }
+    return trimmed.split(/\s+/)[0] ?? null;
+}
+function hashExternalGoBuildEnvironment(hash) {
+    for (const key of EXTERNAL_GO_BUILD_ENV_KEYS) {
+        const value = process.env[key];
+        if (value !== undefined && value !== "") {
+            hash.update(`${key}=${value}\n`);
+        }
+    }
+}
+function resolveGoRootCacheIdentity(goRoot) {
+    const resolved = resolveRealPath(goRoot);
+    if (!node_fs_1.default.existsSync(resolved)) {
+        return `missing:${goRoot}`;
+    }
+    const hash = node_crypto_1.default.createHash("sha256");
+    for (const file of collectGoRootIdentityFiles(resolved)) {
+        const relative = node_path_1.default.relative(resolved, file).replace(/\\/g, "/");
+        hash.update(`f=${relative}\n`);
+        hash.update(node_fs_1.default.readFileSync(file));
+        hash.update("\n");
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
+function collectGoRootIdentityFiles(root) {
+    const out = [];
+    walkGoRootIdentity(root, root, out);
+    out.sort();
+    return out;
+}
+function walkGoRootIdentity(root, dir, out) {
+    let entries;
+    try {
+        entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const file = node_path_1.default.join(dir, entry.name);
+        const rel = node_path_1.default.relative(root, file).replace(/\\/g, "/");
+        if (entry.isDirectory()) {
+            if (shouldHashGoRootPath(rel, true)) {
+                walkGoRootIdentity(root, file, out);
+            }
+        }
+        else if (entry.isFile() && shouldHashGoRootPath(rel, false)) {
+            out.push(file);
+        }
+    }
+}
+function shouldHashGoRootPath(rel, isDir) {
+    if (rel === "")
+        return true;
+    const parts = rel.split("/");
+    if (parts.includes(".git") || parts.includes("testdata"))
+        return false;
+    if (!isDir && rel.endsWith("_test.go"))
+        return false;
+    const first = parts[0];
+    if (parts.length === 1) {
+        if (isDir)
+            return ["bin", "pkg", "src", "lib"].includes(first);
+        return ["VERSION", "go.env"].includes(first);
+    }
+    if (first === "bin") {
+        if (isDir)
+            return true;
+        const base = node_path_1.default.basename(rel);
+        return (base === "go" ||
+            base === "go.exe" ||
+            base === "gofmt" ||
+            base === "gofmt.exe");
+    }
+    if (first === "pkg") {
+        const second = parts[1];
+        return second === "tool" || second === "include";
+    }
+    if (first === "src") {
+        if (!isDir && parts.length === 2) {
+            return ["go.mod", "go.sum"].includes(parts[1]);
+        }
+        return parts[1] !== "cmd";
+    }
+    if (first === "lib") {
+        return parts[1] === "time";
+    }
+    return false;
+}
+function touchCacheEntry(cacheDir) {
+    try {
+        node_fs_1.default.mkdirSync(cacheDir, { recursive: true });
+        node_fs_1.default.writeFileSync(node_path_1.default.join(cacheDir, CACHE_LAST_USED_FILE), `${Date.now()}\n`);
+    }
+    catch {
+        // Cache hits must not fail because metadata touch failed.
+    }
+}
+function maybePruneGlobalPluginCache(root) {
+    try {
+        node_fs_1.default.mkdirSync(root, { recursive: true });
+        const marker = node_path_1.default.join(root, CACHE_GC_MARKER_FILE);
+        const now = Date.now();
+        const lastRun = readTimestamp(marker);
+        if (lastRun !== null && now - lastRun < GLOBAL_CACHE_GC_INTERVAL_MS) {
+            return;
+        }
+        node_fs_1.default.writeFileSync(marker, `${now}\n`);
+        pruneGlobalPluginCache(root, now);
+    }
+    catch {
+        // Global cache GC is opportunistic; builds still proceed when it fails.
+    }
+}
+function pruneGlobalPluginCache(root, now) {
+    const entries = collectGlobalCacheEntries(root, now);
+    for (const entry of entries) {
+        if (now - entry.lastUsedAt <= GLOBAL_CACHE_ENTRY_MAX_AGE_MS) {
+            continue;
+        }
+        removeCacheEntry(entry);
+    }
+    const remaining = collectGlobalCacheEntries(root, now);
+    let total = remaining.reduce((sum, entry) => sum + entry.size, 0);
+    if (total <= GLOBAL_CACHE_MAX_BYTES) {
+        return;
+    }
+    for (const entry of remaining.sort((a, b) => a.lastUsedAt - b.lastUsedAt)) {
+        if (total <= GLOBAL_CACHE_TARGET_BYTES) {
+            return;
+        }
+        if (now - entry.lastUsedAt <= GLOBAL_CACHE_PROTECTED_AGE_MS) {
+            continue;
+        }
+        removeCacheEntry(entry);
+        total -= entry.size;
+    }
+}
+function collectGlobalCacheEntries(root, now) {
+    const entries = [];
+    let dirents;
+    try {
+        dirents = node_fs_1.default.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return entries;
+    }
+    for (const dirent of dirents) {
+        if (!dirent.isDirectory()) {
+            continue;
+        }
+        const dir = node_path_1.default.join(root, dirent.name);
+        const lastUsedAt = readCacheEntryLastUsedAt(dir, now);
+        entries.push({
+            dir,
+            lastUsedAt,
+            size: directorySize(dir),
+        });
+    }
+    return entries;
+}
+function readCacheEntryLastUsedAt(dir, now) {
+    const touched = readTimestamp(node_path_1.default.join(dir, CACHE_LAST_USED_FILE));
+    if (touched !== null) {
+        return touched;
+    }
+    for (const name of ["plugin", "plugin.exe"]) {
+        try {
+            return node_fs_1.default.statSync(node_path_1.default.join(dir, name)).mtimeMs;
+        }
+        catch { }
+    }
+    try {
+        return node_fs_1.default.statSync(dir).mtimeMs;
+    }
+    catch {
+        return now;
+    }
+}
+function readTimestamp(file) {
+    try {
+        const text = node_fs_1.default.readFileSync(file, "utf8").trim();
+        const value = Number(text);
+        if (Number.isFinite(value)) {
+            return value;
+        }
+    }
+    catch { }
+    try {
+        return node_fs_1.default.statSync(file).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+function directorySize(dir) {
+    let total = 0;
+    let entries;
+    try {
+        entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return total;
+    }
+    for (const entry of entries) {
+        const file = node_path_1.default.join(dir, entry.name);
+        try {
+            if (entry.isDirectory()) {
+                total += directorySize(file);
+            }
+            else if (entry.isFile()) {
+                total += node_fs_1.default.statSync(file).size;
+            }
+        }
+        catch { }
+    }
+    return total;
+}
+function removeCacheEntry(entry) {
+    try {
+        node_fs_1.default.rmSync(entry.dir, { recursive: true, force: true });
+    }
+    catch {
+        // Windows may reject removal while a plugin binary is still running.
+    }
+}
 //# sourceMappingURL=buildSourcePlugin.js.map