ttsc 0.4.4-dev.20260426 → 0.5.0-dev.20260429

package/src/source-build.ts

@@ -0,0 +1,383 @@
+import { spawnSync } from "node:child_process";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+
+import type { TtscNativeSource } from "./native";
+
+export interface BuildSourcePluginOptions {
+  source: TtscNativeSource;
+  pluginName: string;
+  baseDir: string;
+  ttscVersion: string;
+  tsgoVersion: string;
+}
+
+export function buildSourcePlugin(opts: BuildSourcePluginOptions): string {
+  const dir = path.isAbsolute(opts.source.dir)
+    ? opts.source.dir
+    : path.resolve(opts.baseDir, opts.source.dir);
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    throw new Error(
+      `ttsc: plugin "${opts.pluginName}" native.source.dir does not exist: ${dir}`,
+    );
+  }
+  const entry = opts.source.entry ?? ".";
+  const key = computeCacheKey({
+    dir,
+    entry,
+    ttscVersion: opts.ttscVersion,
+    tsgoVersion: opts.tsgoVersion,
+  });
+  const root = resolvePluginCacheRoot(opts.baseDir);
+  const cacheDir = path.join(root, key);
+  const binaryName = process.platform === "win32" ? "plugin.exe" : "plugin";
+  const binaryPath = path.join(cacheDir, binaryName);
+  if (fs.existsSync(binaryPath)) {
+    return binaryPath;
+  }
+  fs.mkdirSync(cacheDir, { recursive: true });
+  process.stderr.write(
+    `ttsc: building source plugin "${opts.pluginName}" from ${dir} (this runs once per cache key)\n`,
+  );
+
+  const scratchDir = path.join(
+    root,
+    `scratch-${key}-${process.pid}-${Date.now()}`,
+  );
+  try {
+    materializeScratchDir(dir, scratchDir);
+    writeGoWork(scratchDir, findTtscOverlayDirs());
+    runGoBuild(scratchDir, entry, binaryName, opts.pluginName);
+    const builtBinary = path.join(scratchDir, binaryName);
+    fs.renameSync(builtBinary, binaryPath);
+    if (process.platform !== "win32") {
+      fs.chmodSync(binaryPath, 0o755);
+    }
+    return binaryPath;
+  } finally {
+    fs.rmSync(scratchDir, { recursive: true, force: true });
+  }
+}
+
+function materializeScratchDir(source: string, scratch: string): void {
+  fs.mkdirSync(scratch, { recursive: true });
+  fs.cpSync(source, scratch, {
+    recursive: true,
+    filter: (src) => {
+      const base = path.basename(src);
+      if (SKIP_DIRS.has(base)) return false;
+      if (base === "go.work" || base === "go.work.sum") return false;
+      return true;
+    },
+  });
+}
+
+function writeGoWork(scratchDir: string, useDirs: readonly string[]): void {
+  const useLines = ["\t."];
+  for (const dir of useDirs) {
+    useLines.push(`\t${dir.replace(/\\/g, "/")}`);
+  }
+  const goWork = `go 1.26\n\nuse (\n${useLines.join("\n")}\n)\n`;
+  fs.writeFileSync(path.join(scratchDir, "go.work"), goWork, "utf8");
+}
+
+function runGoBuild(
+  cwd: string,
+  entry: string,
+  binaryName: string,
+  pluginName: string,
+): void {
+  const goBinary = resolveGoBinary();
+  ensureExecutableGoToolchain(goBinary);
+  const result = spawnSync(
+    goBinary,
+    ["build", "-o", binaryName, entry],
+    {
+      cwd,
+      encoding: "utf8",
+      env: goBuildEnv(goBinary),
+      maxBuffer: 1024 * 1024 * 64,
+      windowsHide: true,
+    },
+  );
+  if (result.error) {
+    if ((result.error as NodeJS.ErrnoException).code === "ENOENT") {
+      throw new Error(
+        `ttsc: building plugin "${pluginName}" failed because the Go toolchain was not found. ` +
+          `Reinstall ttsc with optional dependencies so the bundled Go compiler is present, ` +
+          `or set TTSC_GO_BINARY to an absolute path.`,
+      );
+    }
+    throw new Error(
+      `ttsc: building plugin "${pluginName}" failed to spawn ${goBinary}: ${result.error.message}`,
+    );
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      `ttsc: building plugin "${pluginName}" via "go build" failed:\n${result.stderr || result.stdout}`,
+    );
+  }
+}
+
+function goBuildEnv(goBinary: string): NodeJS.ProcessEnv {
+  const env = { ...process.env };
+  const goRoot = inferGoRoot(goBinary);
+  if (goRoot && !env.GOROOT) {
+    env.GOROOT = goRoot;
+  }
+  return env;
+}
+
+function inferGoRoot(goBinary: string): string | null {
+  if (!path.isAbsolute(goBinary)) return null;
+  const binDir = path.dirname(goBinary);
+  if (path.basename(binDir) !== "bin") return null;
+  const goRoot = path.dirname(binDir);
+  return fs.existsSync(path.join(goRoot, "src", "runtime")) ? goRoot : null;
+}
+
+function ensureExecutableGoToolchain(goBinary: string): void {
+  if (process.platform === "win32") return;
+  if (!path.isAbsolute(goBinary) || !fs.existsSync(goBinary)) return;
+  try {
+    fs.chmodSync(goBinary, 0o755);
+    const goRoot = inferGoRoot(goBinary);
+    if (!goRoot) return;
+    const gofmt = path.join(path.dirname(goBinary), "gofmt");
+    if (fs.existsSync(gofmt)) fs.chmodSync(gofmt, 0o755);
+    const toolDir = path.join(goRoot, "pkg", "tool");
+    if (!fs.existsSync(toolDir)) return;
+    for (const file of walkToolFiles(toolDir)) {
+      fs.chmodSync(file, 0o755);
+    }
+  } catch {
+    // Let the subsequent go build spawn fail with the real OS error.
+  }
+}
+
+function walkToolFiles(dir: string): string[] {
+  const out: string[] = [];
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const file = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...walkToolFiles(file));
+    } else if (entry.isFile()) {
+      out.push(file);
+    }
+  }
+  return out;
+}
+
+export interface ResolveGoBinaryOptions {
+  arch?: string;
+  env?: NodeJS.ProcessEnv;
+  localGoLookup?: () => string | null;
+  platform?: NodeJS.Platform;
+  resolver?: (request: string) => string;
+}
+
+export function goBinaryName(opts: ResolveGoBinaryOptions = {}): string {
+  return (opts.platform ?? process.platform) === "win32" ? "go.exe" : "go";
+}
+
+export function bundledGoPackageRequest(
+  opts: ResolveGoBinaryOptions = {},
+): string {
+  return `@ttsc/${goPlatformKey(opts)}/bin/go/bin/${goBinaryName(opts)}`;
+}
+
+let cachedOverlayDirs: readonly string[] | null = null;
+
+function findTtscOverlayDirs(): readonly string[] {
+  if (cachedOverlayDirs !== null) {
+    return cachedOverlayDirs;
+  }
+  const ttscRoot = path.resolve(__dirname, "..");
+  const dirs: string[] = [];
+  if (fs.existsSync(path.join(ttscRoot, "go.mod"))) {
+    dirs.push(ttscRoot);
+  }
+  const shimRoot = path.join(ttscRoot, "shim");
+  if (fs.existsSync(shimRoot)) {
+    walkForGoMod(shimRoot, dirs);
+  }
+  dirs.sort();
+  cachedOverlayDirs = dirs;
+  return dirs;
+}
+
+function walkForGoMod(dir: string, out: string[]): void {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  let hasGoMod = false;
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name === "go.mod") {
+      hasGoMod = true;
+    }
+  }
+  if (hasGoMod) {
+    out.push(dir);
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (SKIP_DIRS.has(entry.name)) continue;
+    walkForGoMod(path.join(dir, entry.name), out);
+  }
+}
+
+export function resolvePluginCacheRoot(projectRoot: string): string {
+  if (process.env.TTSC_CACHE_DIR) {
+    return path.resolve(process.env.TTSC_CACHE_DIR, "plugins");
+  }
+  return resolveDefaultPluginCacheRoot(projectRoot);
+}
+
+export function resolveDefaultPluginCacheRoot(projectRoot: string): string {
+  const root = path.resolve(projectRoot);
+  const nodeModules = path.join(root, "node_modules");
+  if (isDirectory(nodeModules)) {
+    return path.join(nodeModules, ".ttsc", "plugins");
+  }
+  return path.join(root, ".ttsc", "plugins");
+}
+
+export function pluginCacheCleanupTargets(projectRoot: string): string[] {
+  const root = path.resolve(projectRoot);
+  const targets = [
+    path.join(root, "node_modules", ".ttsc"),
+    path.join(root, ".ttsc"),
+  ];
+  if (process.env.TTSC_CACHE_DIR) {
+    targets.push(path.resolve(process.env.TTSC_CACHE_DIR, "plugins"));
+  }
+  return [...new Set(targets)];
+}
+
+function isDirectory(candidate: string): boolean {
+  try {
+    return fs.statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function resolveGoBinary(): string {
+  return resolveGoCompiler();
+}
+
+export function resolveGoCompiler(
+  opts: ResolveGoBinaryOptions = {},
+): string {
+  const env = opts.env ?? process.env;
+  const explicit = env.TTSC_GO_BINARY;
+  if (explicit && explicit.length > 0) return explicit;
+
+  const resolver =
+    opts.resolver ??
+    ((request: string) => createRequire(__filename).resolve(request));
+  try {
+    return resolver(bundledGoPackageRequest(opts));
+  } catch {
+    /* fall through */
+  }
+
+  if (opts.localGoLookup) {
+    const local = opts.localGoLookup();
+    if (local) return local;
+  } else {
+    const local = defaultLocalGoBinaryPath(opts);
+    if (local) return local;
+  }
+
+  return "go";
+}
+
+function defaultLocalGoBinaryPath(opts: ResolveGoBinaryOptions): string | null {
+  const candidate = path.resolve(
+    __dirname,
+    "..",
+    "native",
+    "go",
+    "bin",
+    goBinaryName(opts),
+  );
+  return fs.existsSync(candidate) ? candidate : null;
+}
+
+function goPlatformKey(opts: ResolveGoBinaryOptions = {}): string {
+  return `${opts.platform ?? process.platform}-${opts.arch ?? process.arch}`;
+}
+
+interface KeyInputs {
+  dir: string;
+  entry: string;
+  ttscVersion: string;
+  tsgoVersion: string;
+}
+
+export function computeCacheKey(inputs: KeyInputs): string {
+  const hash = crypto.createHash("sha256");
+  hash.update(`ttsc=${inputs.ttscVersion}\n`);
+  hash.update(`tsgo=${inputs.tsgoVersion}\n`);
+  hash.update(`platform=${process.platform}/${process.arch}\n`);
+  hash.update(`entry=${inputs.entry}\n`);
+  for (const file of collectSourceFiles(inputs.dir)) {
+    const rel = path.relative(inputs.dir, file).replace(/\\/g, "/");
+    hash.update(`f=${rel}\n`);
+    hash.update(fs.readFileSync(file));
+  }
+  return hash.digest("hex").slice(0, 32);
+}
+
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "vendor",
+  "lib",
+]);
+
+function collectSourceFiles(root: string): string[] {
+  const out: string[] = [];
+  walk(root, root, out);
+  out.sort();
+  return out;
+}
+
+function walk(root: string, dir: string, out: string[]): void {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walk(root, full, out);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!isHashableFile(entry.name)) continue;
+    out.push(full);
+  }
+}
+
+function isHashableFile(name: string): boolean {
+  if (name === "go.mod" || name === "go.sum" || name === "go.work") return true;
+  return /\.(?:go|s|c|h|cpp|hpp)$/i.test(name);
+}

package/test/native.test.ts

@@ -58,3 +58,46 @@ test("resolveNativeBackend rejects unsupported native contract versions", () =>
     /unsupported native contract version 2/,
   );
 });
+
+test("resolveNativeBackend accepts native.source descriptors", () => {
+  const backend = resolveNativeBackend({
+    name: "source-test",
+    native: {
+      mode: "native-test",
+      source: { dir: "/abs/path/to/plugin", entry: "./cmd/host" },
+      contractVersion: 1,
+    },
+  });
+
+  assert.deepEqual(backend, {
+    mode: "native-test",
+    source: { dir: "/abs/path/to/plugin", entry: "./cmd/host" },
+    contractVersion: 1,
+  });
+});
+
+test("resolveNativeBackend rejects native.source + native.binary together", () => {
+  assert.throws(
+    () =>
+      resolveNativeBackend({
+        name: "conflict-source-test",
+        native: {
+          mode: "native-test",
+          binary: "/tmp/binary",
+          source: { dir: "/tmp/source" },
+        },
+      }),
+    /must use either native\.binary or native\.source, not both/,
+  );
+});
+
+test("resolveNativeBackend rejects empty native.source.dir", () => {
+  assert.throws(
+    () =>
+      resolveNativeBackend({
+        name: "empty-source-test",
+        native: { mode: "native-test", source: { dir: "" } },
+      }),
+    /native\.source\.dir must be a non-empty string/,
+  );
+});

package/test/source-build.test.ts

@@ -0,0 +1,219 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+
+const {
+  bundledGoPackageRequest,
+  computeCacheKey,
+  goBinaryName,
+  pluginCacheCleanupTargets,
+  resolveDefaultPluginCacheRoot,
+  resolveGoCompiler,
+  resolvePluginCacheRoot,
+} = require("../src/source-build.ts");
+
+function withTempSourceDir(files: Record<string, string>): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-cache-key-"));
+  for (const [name, contents] of Object.entries(files)) {
+    const file = path.join(root, name);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, contents, "utf8");
+  }
+  return root;
+}
+
+test("computeCacheKey is stable across calls for identical inputs", () => {
+  const dir = withTempSourceDir({
+    "go.mod": "module example\n\ngo 1.26\n",
+    "main.go": "package main\nfunc main() {}\n",
+  });
+  const inputs = { dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "7.0.0-dev" };
+  assert.equal(computeCacheKey(inputs), computeCacheKey(inputs));
+});
+
+test("computeCacheKey changes when ttscVersion changes", () => {
+  const dir = withTempSourceDir({
+    "go.mod": "module example\n\ngo 1.26\n",
+    "main.go": "package main\nfunc main() {}\n",
+  });
+  const a = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "7.0.0-dev" });
+  const b = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.1", tsgoVersion: "7.0.0-dev" });
+  assert.notEqual(a, b);
+});
+
+test("computeCacheKey changes when tsgoVersion changes", () => {
+  const dir = withTempSourceDir({
+    "go.mod": "module example\n\ngo 1.26\n",
+    "main.go": "package main\nfunc main() {}\n",
+  });
+  const a = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "7.0.0-dev.A" });
+  const b = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "7.0.0-dev.B" });
+  assert.notEqual(a, b);
+});
+
+test("computeCacheKey changes when entry changes", () => {
+  const dir = withTempSourceDir({
+    "go.mod": "module example\n\ngo 1.26\n",
+    "main.go": "package main\nfunc main() {}\n",
+    "cmd/foo/main.go": "package main\nfunc main() {}\n",
+  });
+  const a = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "x" });
+  const b = computeCacheKey({ dir, entry: "./cmd/foo", ttscVersion: "1.0.0", tsgoVersion: "x" });
+  assert.notEqual(a, b);
+});
+
+test("computeCacheKey changes when source content changes", () => {
+  const dir = withTempSourceDir({
+    "go.mod": "module example\n\ngo 1.26\n",
+    "main.go": "package main\nfunc main() {}\n",
+  });
+  const before = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "x" });
+  fs.writeFileSync(
+    path.join(dir, "main.go"),
+    "package main\nfunc main() { _ = 1 }\n",
+  );
+  const after = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "x" });
+  assert.notEqual(before, after);
+});
+
+test("computeCacheKey ignores non-Go files (e.g. README.md)", () => {
+  const dir = withTempSourceDir({
+    "go.mod": "module example\n\ngo 1.26\n",
+    "main.go": "package main\nfunc main() {}\n",
+  });
+  const before = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "x" });
+  fs.writeFileSync(path.join(dir, "README.md"), "documentation\n");
+  const after = computeCacheKey({ dir, entry: ".", ttscVersion: "1.0.0", tsgoVersion: "x" });
+  assert.equal(before, after);
+});
+
+test("resolveGoCompiler prefers TTSC_GO_BINARY override", () => {
+  const resolved = resolveGoCompiler({
+    env: { TTSC_GO_BINARY: "/tmp/custom-go" },
+    localGoLookup: () => "/tmp/local-go",
+    resolver: () => {
+      throw new Error("resolver should not be called when TTSC_GO_BINARY is set");
+    },
+  });
+  assert.equal(resolved, "/tmp/custom-go");
+});
+
+test("resolveGoCompiler uses bundled platform package before PATH fallback", () => {
+  const resolved = resolveGoCompiler({
+    arch: "x64",
+    env: {},
+    localGoLookup: () => null,
+    platform: "linux",
+    resolver: (request) => {
+      assert.equal(request, "@ttsc/linux-x64/bin/go/bin/go");
+      return "/node_modules/@ttsc/linux-x64/bin/go/bin/go";
+    },
+  });
+  assert.equal(resolved, "/node_modules/@ttsc/linux-x64/bin/go/bin/go");
+});
+
+test("resolveGoCompiler falls back to package-local bundled Go before PATH", () => {
+  const resolved = resolveGoCompiler({
+    env: {},
+    localGoLookup: () => "/workspace/packages/ttsc/native/go/bin/go",
+    resolver: () => {
+      throw new Error("platform package missing");
+    },
+  });
+  assert.equal(resolved, "/workspace/packages/ttsc/native/go/bin/go");
+});
+
+test("resolveGoCompiler keeps go on PATH as the last development fallback", () => {
+  const resolved = resolveGoCompiler({
+    env: {},
+    localGoLookup: () => null,
+    resolver: () => {
+      throw new Error("platform package missing");
+    },
+  });
+  assert.equal(resolved, "go");
+});
+
+test("bundled Go package request follows platform package layout", () => {
+  assert.equal(goBinaryName({ platform: "win32" }), "go.exe");
+  assert.equal(goBinaryName({ platform: "linux" }), "go");
+  assert.equal(
+    bundledGoPackageRequest({ platform: "darwin", arch: "arm64" }),
+    "@ttsc/darwin-arm64/bin/go/bin/go",
+  );
+  assert.equal(
+    bundledGoPackageRequest({ platform: "win32", arch: "x64" }),
+    "@ttsc/win32-x64/bin/go/bin/go.exe",
+  );
+});
+
+test("resolvePluginCacheRoot prefers project node_modules cache", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-local-cache-"));
+  fs.mkdirSync(path.join(root, "node_modules"));
+  assert.equal(
+    resolvePluginCacheRoot(root),
+    path.join(root, "node_modules", ".ttsc", "plugins"),
+  );
+});
+
+test("resolvePluginCacheRoot falls back to project .ttsc without node_modules", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-local-cache-"));
+  assert.equal(resolvePluginCacheRoot(root), path.join(root, ".ttsc", "plugins"));
+});
+
+test("resolveDefaultPluginCacheRoot ignores TTSC_CACHE_DIR for local clean paths", () => {
+  const previous = process.env.TTSC_CACHE_DIR;
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-local-cache-"));
+  fs.mkdirSync(path.join(root, "node_modules"));
+  try {
+    process.env.TTSC_CACHE_DIR = path.join(root, "override");
+    assert.equal(
+      resolveDefaultPluginCacheRoot(root),
+      path.join(root, "node_modules", ".ttsc", "plugins"),
+    );
+  } finally {
+    if (previous === undefined) {
+      delete process.env.TTSC_CACHE_DIR;
+    } else {
+      process.env.TTSC_CACHE_DIR = previous;
+    }
+  }
+});
+
+test("resolvePluginCacheRoot honors TTSC_CACHE_DIR as an explicit test override", () => {
+  const previous = process.env.TTSC_CACHE_DIR;
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-local-cache-"));
+  const override = path.join(root, "override");
+  try {
+    process.env.TTSC_CACHE_DIR = override;
+    assert.equal(resolvePluginCacheRoot(root), path.join(override, "plugins"));
+  } finally {
+    if (previous === undefined) {
+      delete process.env.TTSC_CACHE_DIR;
+    } else {
+      process.env.TTSC_CACHE_DIR = previous;
+    }
+  }
+});
+
+test("pluginCacheCleanupTargets deletes both local roots and explicit override", () => {
+  const previous = process.env.TTSC_CACHE_DIR;
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-local-cache-"));
+  const override = path.join(root, "override");
+  try {
+    process.env.TTSC_CACHE_DIR = override;
+    assert.deepEqual(pluginCacheCleanupTargets(root), [
+      path.join(root, "node_modules", ".ttsc"),
+      path.join(root, ".ttsc"),
+      path.join(override, "plugins"),
+    ]);
+  } finally {
+    if (previous === undefined) {
+      delete process.env.TTSC_CACHE_DIR;
+    } else {
+      process.env.TTSC_CACHE_DIR = previous;
+    }
+  }
+});