ttsc 0.3.1 → 0.4.0-dev.20260425

package/src/project.ts

@@ -0,0 +1,330 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+
+export interface ProjectLocatorOptions {
+  cwd?: string;
+  file?: string;
+  tsconfig?: string;
+}
+
+export interface ProjectPluginConfig {
+  enabled?: boolean;
+  transform?: string;
+  [key: string]: unknown;
+}
+
+export interface ParsedProjectConfig {
+  compilerOptions: {
+    outDir?: string;
+    plugins: ProjectPluginConfig[];
+  };
+  path: string;
+  root: string;
+}
+
+export function resolveWorkingDirectory(cwd?: string): string {
+  return path.resolve(cwd ?? process.cwd());
+}
+
+export function resolveAbsolutePath(cwd: string, target: string): string {
+  return path.isAbsolute(target) ? target : path.resolve(cwd, target);
+}
+
+export function resolveProjectConfig(opts: ProjectLocatorOptions = {}): string {
+  const cwd = resolveWorkingDirectory(opts.cwd);
+  if (opts.tsconfig) {
+    const resolved = resolveAbsolutePath(cwd, opts.tsconfig);
+    if (!fs.existsSync(resolved)) {
+      throw new Error(`ttsc: tsconfig not found: ${resolved}`);
+    }
+    return resolveRealPath(resolved);
+  }
+
+  const start = opts.file
+    ? resolveRealPath(resolveAbsolutePath(cwd, opts.file))
+    : cwd;
+  const from = isDirectory(start) ? start : path.dirname(start);
+  const found = findUp(from, ["tsconfig.json", "jsconfig.json"]);
+  if (!found) {
+    throw new Error(
+      `ttsc: could not find tsconfig.json or jsconfig.json starting from ${from}`,
+    );
+  }
+  return resolveRealPath(found);
+}
+
+export function resolveProjectRoot(opts: ProjectLocatorOptions = {}): string {
+  return path.dirname(resolveProjectConfig(opts));
+}
+
+export function defaultCacheDirectory(projectRoot: string, tool: string): string {
+  return path.join(projectRoot, "node_modules", ".cache", "ttsc", tool);
+}
+
+export function readProjectConfig(opts: ProjectLocatorOptions = {}): ParsedProjectConfig {
+  const tsconfig = resolveProjectConfig(opts);
+  const root = path.dirname(tsconfig);
+  const compilerOptions = readResolvedCompilerOptions(tsconfig);
+  return {
+    compilerOptions: {
+      outDir: compilerOptions.outDir,
+      plugins: compilerOptions.plugins,
+    },
+    path: tsconfig,
+    root,
+  };
+}
+
+export interface CacheKeyInput {
+  file: string;
+  tsconfig: string;
+  version: string;
+  mode?: string;
+  extra?: readonly string[];
+}
+
+export function createTransformCacheKey(input: CacheKeyInput): string {
+  const hash = crypto.createHash("sha256");
+  hash.update("file\0");
+  hash.update(fs.readFileSync(input.file));
+  hash.update("\0tsconfig\0");
+  hash.update(fs.readFileSync(input.tsconfig));
+  hash.update(`\0version\0${input.version}`);
+  hash.update(`\0mode\0${input.mode ?? ""}`);
+  for (const item of input.extra ?? []) {
+    hash.update(`\0extra\0${item}`);
+  }
+  return hash.digest("hex");
+}
+
+function findUp(from: string, names: readonly string[]): string | null {
+  let current = path.resolve(from);
+  while (true) {
+    for (const name of names) {
+      const candidate = path.join(current, name);
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+function isDirectory(location: string): boolean {
+  try {
+    return fs.statSync(location).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function isProjectPluginConfig(value: unknown): value is ProjectPluginConfig {
+  return typeof value === "object" && value !== null;
+}
+
+interface RawTsconfig {
+  extends?: unknown;
+  compilerOptions?: {
+    outDir?: unknown;
+    plugins?: unknown;
+  };
+}
+
+interface ResolvedCompilerOptions {
+  outDir?: string;
+  plugins: ProjectPluginConfig[];
+}
+
+function resolveRealPath(location: string): string {
+  try {
+    return fs.realpathSync(location);
+  } catch {
+    return location;
+  }
+}
+
+function readResolvedCompilerOptions(
+  tsconfig: string,
+  seen: Set<string> = new Set(),
+): ResolvedCompilerOptions {
+  const canonical = resolveRealPath(tsconfig);
+  if (seen.has(canonical)) {
+    throw new Error(`ttsc: circular tsconfig extends detected: ${canonical}`);
+  }
+  seen.add(canonical);
+
+  const parsed = parseJsonc(fs.readFileSync(canonical, "utf8")) as RawTsconfig;
+  const own = parsed.compilerOptions;
+  const base =
+    typeof parsed.extends === "string"
+      ? readResolvedCompilerOptions(resolveExtendsConfig(canonical, parsed.extends), seen)
+      : { plugins: [] };
+  return {
+    outDir:
+      typeof own?.outDir === "string"
+        ? resolveAbsolutePath(path.dirname(canonical), own.outDir)
+        : base.outDir,
+    plugins: Array.isArray(own?.plugins)
+      ? own.plugins.filter(isProjectPluginConfig)
+      : base.plugins,
+  };
+}
+
+function resolveExtendsConfig(tsconfig: string, specifier: string): string {
+  const baseDir = path.dirname(tsconfig);
+  if (path.isAbsolute(specifier)) {
+    return resolveExistingExtendsPath(specifier);
+  }
+  if (isRelativePluginSpecifier(specifier)) {
+    return resolveExistingExtendsPath(path.resolve(baseDir, specifier));
+  }
+  const resolver = createRequire(tsconfig);
+  try {
+    return resolveRealPath(resolver.resolve(specifier));
+  } catch {
+    return resolveRealPath(resolver.resolve(`${specifier}.json`));
+  }
+}
+
+function resolveExistingExtendsPath(location: string): string {
+  const candidates = new Set<string>([
+    location,
+    `${location}.json`,
+    path.join(location, "tsconfig.json"),
+  ]);
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return resolveRealPath(candidate);
+    }
+  }
+  throw new Error(`ttsc: extended tsconfig not found: ${location}`);
+}
+
+function isRelativePluginSpecifier(specifier: string): boolean {
+  return (
+    specifier === "." ||
+    specifier === ".." ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../") ||
+    specifier.startsWith(".\\") ||
+    specifier.startsWith("..\\")
+  );
+}
+
+function parseJsonc(input: string): unknown {
+  return JSON.parse(stripTrailingCommas(stripComments(input)));
+}
+
+function stripComments(input: string): string {
+  let output = "";
+  let inBlockComment = false;
+  let inLineComment = false;
+  let inString = false;
+  let quote = "";
+  let escape = false;
+
+  for (let i = 0; i < input.length; i += 1) {
+    const current = input[i]!;
+    const next = input[i + 1];
+
+    if (inBlockComment) {
+      if (current === "*" && next === "/") {
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (inLineComment) {
+      if (current === "\n") {
+        inLineComment = false;
+        output += current;
+      }
+      continue;
+    }
+    if (inString) {
+      output += current;
+      if (escape) {
+        escape = false;
+      } else if (current === "\\") {
+        escape = true;
+      } else if (current === quote) {
+        inString = false;
+        quote = "";
+      }
+      continue;
+    }
+
+    if ((current === '"' || current === "'") && !inString) {
+      inString = true;
+      quote = current;
+      output += current;
+      continue;
+    }
+    if (current == "/" && next === "/") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (current == "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    output += current;
+  }
+  return output;
+}
+
+function stripTrailingCommas(input: string): string {
+  let output = "";
+  let inString = false;
+  let quote = "";
+  let escape = false;
+
+  for (let i = 0; i < input.length; i += 1) {
+    const current = input[i]!;
+    if (inString) {
+      output += current;
+      if (escape) {
+        escape = false;
+      } else if (current === "\\") {
+        escape = true;
+      } else if (current === quote) {
+        inString = false;
+        quote = "";
+      }
+      continue;
+    }
+
+    if (current === '"' || current === "'") {
+      inString = true;
+      quote = current;
+      output += current;
+      continue;
+    }
+    if (current === ",") {
+      const next = nextNonWhitespace(input, i + 1);
+      if (next === "}" || next === "]") {
+        continue;
+      }
+    }
+    output += current;
+  }
+  return output;
+}
+
+function nextNonWhitespace(input: string, from: number): string | undefined {
+  for (let i = from; i < input.length; i += 1) {
+    const current = input[i]!;
+    if (/\s/.test(current) === false) {
+      return current;
+    }
+  }
+  return undefined;
+}

package/src/runner/cli.ts

@@ -0,0 +1,286 @@
+import * as fs from "node:fs";
+import Module = require("node:module");
+import { spawnSync } from "node:child_process";
+import * as path from "node:path";
+
+import { version } from "../api";
+import {
+  prepareExecution,
+  register,
+  type PreparedExecution,
+  type RegisterOptions,
+} from "./register";
+
+interface ParsedCLI extends RegisterOptions {
+  entry: string;
+  passthrough: string[];
+  preload: string[];
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+  try {
+    return run(argv);
+  } catch (error) {
+    process.stderr.write(`${formatError(error)}\n`);
+    return 2;
+  }
+}
+
+function run(argv: readonly string[]): number {
+  const parsed = parseCLI(argv);
+  if (parsed === "help") {
+    printHelp();
+    return 0;
+  }
+  if (parsed === "version") {
+    process.stdout.write(`${version().replace(/^ttsc\b/, "ttsx")}\n`);
+    return 0;
+  }
+
+  const cwd = path.resolve(parsed.cwd ?? process.cwd());
+  const entry = path.resolve(cwd, parsed.entry);
+  if (!fs.existsSync(entry)) {
+    process.stderr.write(`ttsx: entry not found: ${entry}\n`);
+    return 2;
+  }
+
+  const prepared = prepareExecution(entry, {
+    binary: parsed.binary,
+    cacheDir: parsed.cacheDir,
+    cwd,
+    env: parsed.env,
+    extensions: parsed.extensions,
+    project: parsed.project,
+  });
+  if (prepared.moduleKind === "esm") {
+    return runEsmEntry(parsed, prepared, cwd);
+  }
+
+  const unregister = register({
+    binary: parsed.binary,
+    cacheDir: parsed.cacheDir,
+    cwd,
+    env: parsed.env,
+    extensions: parsed.extensions,
+    project: parsed.project,
+  });
+  process.once("exit", unregister);
+  for (const preload of parsed.preload) {
+    require(resolvePreload(cwd, preload));
+  }
+  process.argv = [process.execPath, entry, ...parsed.passthrough];
+  Module.runMain();
+  return 0;
+}
+
+function formatError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+function parseCLI(argv: readonly string[]): ParsedCLI | "help" | "version" {
+  const preload: string[] = [];
+  const passthroughIndex = argv.indexOf("--");
+  const head = passthroughIndex === -1 ? [...argv] : [...argv.slice(0, passthroughIndex)];
+  const passthrough = passthroughIndex === -1 ? [] : [...argv.slice(passthroughIndex + 1)];
+
+  let binary: string | undefined;
+  let cacheDir: string | undefined;
+  let cwd: string | undefined;
+  let entry: string | undefined;
+  let project: string | undefined;
+
+  while (head.length !== 0) {
+    const current = head.shift()!;
+    if (entry) {
+      passthrough.push(current, ...head);
+      break;
+    }
+    switch (current) {
+      case "-h":
+      case "--help":
+        return "help";
+      case "-v":
+      case "--version":
+        return "version";
+      case "-P":
+      case "--project":
+        project = takeValue(current, head);
+        break;
+      case "--cwd":
+        cwd = takeValue(current, head);
+        break;
+      case "--cache-dir":
+        cacheDir = takeValue(current, head);
+        break;
+      case "-r":
+      case "--require":
+        preload.push(takeValue(current, head));
+        break;
+      case "--binary":
+        binary = takeValue(current, head);
+        break;
+      default:
+        if (current.startsWith("--project=")) {
+          project = current.slice("--project=".length);
+        } else if (current.startsWith("--cwd=")) {
+          cwd = current.slice("--cwd=".length);
+        } else if (current.startsWith("--cache-dir=")) {
+          cacheDir = current.slice("--cache-dir=".length);
+        } else if (current.startsWith("--binary=")) {
+          binary = current.slice("--binary=".length);
+        } else if (current.startsWith("-")) {
+          throw new Error(`ttsx: unknown option ${current}`);
+                } else {
+          entry = current;
+        }
+        break;
+    }
+  }
+
+  if (!entry) {
+    throw new Error("ttsx: entry file is required");
+  }
+
+  return {
+    binary,
+    cacheDir,
+    cwd,
+    entry,
+    passthrough,
+    preload,
+    project,
+  };
+}
+
+function printHelp(): void {
+  process.stdout.write(
+    [
+      "ttsx — TypeScript runner provided by ttsc.",
+      "",
+      "Usage:",
+      "  ttsx [options] <entry.ts> [-- <argv...>]",
+      "",
+      "Options:",
+      "  -P, --project <file>   Use an explicit tsconfig.json",
+      "  --cwd <dir>            Resolve entry/project relative to this directory",
+      "  --cache-dir <dir>      Override the compiled JS cache directory",
+      "  --binary <path>        Use an explicit ttsc native binary",
+      "  -r, --require <file>   Preload a module before the entrypoint",
+      "  -h, --help             Show this help",
+      "  -v, --version          Print the runner version",
+      "",
+      "Runtime:",
+      "  CommonJS projects execute in-process via the require hook.",
+      "  ESM projects execute the cached emitted entry in a child Node process.",
+      "",
+      "Examples:",
+      "  ttsx src/index.ts",
+      "  ttsx --project tsconfig.json src/index.ts -- --port 3000",
+    ].join("\n"),
+  );
+  process.stdout.write("\n");
+}
+
+function resolvePreload(cwd: string, preload: string): string {
+  if (preload.startsWith(".") || preload.startsWith("/") || preload.includes(path.sep)) {
+    return path.resolve(cwd, preload);
+  }
+  return preload;
+}
+
+function takeValue(flag: string, rest: string[]): string {
+  const value = rest.shift();
+  if (!value) {
+    throw new Error(`ttsx: ${flag} requires a value`);
+  }
+  return value;
+}
+
+function runEsmEntry(parsed: ParsedCLI, execution: PreparedExecution, cwd: string): number {
+  fs.mkdirSync(execution.emitDir, { recursive: true });
+  rewriteEsmSpecifiers(execution.emitDir);
+  fs.writeFileSync(
+    path.join(execution.emitDir, "package.json"),
+    JSON.stringify({ type: "module" }),
+    "utf8",
+  );
+  const args = [
+    ...parsed.preload.flatMap((preload) => ["-r", resolvePreload(cwd, preload)]),
+    execution.entryFile,
+    ...parsed.passthrough,
+  ];
+  const result = spawnSync(process.execPath, args, {
+    stdio: "inherit",
+    env: process.env,
+    windowsHide: true,
+  });
+  if (result.error) {
+    process.stderr.write(`${result.error.message}\n`);
+    return 1;
+  }
+  return result.status ?? 1;
+}
+
+function rewriteEsmSpecifiers(root: string): void {
+  const stack = [root];
+  while (stack.length !== 0) {
+    const current = stack.pop()!;
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const next = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(next);
+        continue;
+      }
+      if (!entry.isFile() || !isJavaScriptOutput(next)) {
+        continue;
+      }
+      const before = fs.readFileSync(next, "utf8");
+      const after = before
+        .replace(
+          /\bfrom\s+(['"])(\.[^'"]+)\1/g,
+          (_, quote: string, specifier: string) =>
+            `from ${quote}${withResolvableExtension(next, specifier)}${quote}`,
+        )
+        .replace(
+          /\bimport\(\s*(['"])(\.[^'"]+)\1\s*\)/g,
+          (_, quote: string, specifier: string) =>
+            `import(${quote}${withResolvableExtension(next, specifier)}${quote})`,
+        );
+      if (after !== before) {
+        fs.writeFileSync(next, after, "utf8");
+      }
+    }
+  }
+}
+
+function withResolvableExtension(fromFile: string, specifier: string): string {
+  if (!specifier.startsWith(".")) {
+    return specifier;
+  }
+  if (/\.(?:[cm]?js|json|node)$/i.test(specifier)) {
+    return specifier;
+  }
+  const [pathname, suffix = ""] = splitSpecifierSuffix(specifier);
+  const fromDir = path.dirname(fromFile);
+  for (const extension of [".js", ".mjs", ".cjs"]) {
+    if (fs.existsSync(path.resolve(fromDir, pathname + extension))) {
+      return pathname + extension + suffix;
+    }
+  }
+  return `${specifier}.js`;
+}
+
+function splitSpecifierSuffix(specifier: string): [string, string?] {
+  const index = specifier.search(/[?#]/);
+  if (index === -1) {
+    return [specifier];
+  }
+  return [specifier.slice(0, index), specifier.slice(index)];
+}
+
+function isJavaScriptOutput(filename: string): boolean {
+  return /\.(?:[cm]?js)$/i.test(filename);
+}