@git.zone/tsrust 1.4.1 → 1.6.0

package/ts/mod_cargo/classes.targetcache.ts

@@ -0,0 +1,304 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+export const toolCacheMarkerFile = '.gitzone-tool-cache.json';
+export const tsrustCacheOwner = '@git.zone/tsrust';
+export const targetCacheKind = 'rust-target-cache';
+
+export interface IToolCacheMarker {
+  owner: string;
+  kind: string;
+  safeToPrune: boolean;
+  createdAt: string;
+  schemaVersion: 1;
+}
+
+export interface ITsrustPruneCandidate {
+  path: string;
+  workspace: string;
+  bytes: number;
+  marked: boolean;
+  shouldPrune: boolean;
+  reason: string;
+  truncated?: boolean;
+}
+
+export interface ITsrustPruneOptions {
+  workspace: string;
+  targetDir?: string;
+  days?: number;
+  maxSizeBytes?: number;
+}
+
+export function createTargetCacheMarker(): IToolCacheMarker {
+  return {
+    owner: tsrustCacheOwner,
+    kind: targetCacheKind,
+    safeToPrune: true,
+    createdAt: new Date().toISOString(),
+    schemaVersion: 1,
+  };
+}
+
+export function isValidTargetCacheMarker(markerArg: unknown): markerArg is IToolCacheMarker {
+  const marker = markerArg as Partial<IToolCacheMarker>;
+  return marker.owner === tsrustCacheOwner
+    && marker.kind === targetCacheKind
+    && marker.safeToPrune === true
+    && marker.schemaVersion === 1;
+}
+
+export function getDefaultManagedTargetDir(workspaceArg: string): string {
+  return path.resolve(workspaceArg, '.nogit', 'tsrust-target');
+}
+
+export function isSafeManagedTargetDir(workspaceArg: string, targetDirArg: string): boolean {
+  const workspace = path.resolve(workspaceArg);
+  const targetDir = path.resolve(targetDirArg);
+  const relative = path.relative(workspace, targetDir);
+  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+    return false;
+  }
+  return relative === path.join('.nogit', 'tsrust-target')
+    || relative.startsWith(`${path.join('.nogit', 'tsrust-')}`)
+    || relative.startsWith(`${path.join('.nogit', 'tsrust')}${path.sep}`);
+}
+
+export function resolveManagedTargetDir(workspaceArg: string, configTargetDirArg?: string): string {
+  const configured = process.env.TSRUST_TARGET_DIR || configTargetDirArg;
+  const targetDir = configured
+    ? path.isAbsolute(configured) ? configured : path.resolve(workspaceArg, configured)
+    : getDefaultManagedTargetDir(workspaceArg);
+  if (!isSafeManagedTargetDir(workspaceArg, targetDir)) {
+    throw new Error(`Refusing unsafe tsrust target dir outside workspace .nogit/: ${targetDir}`);
+  }
+  return targetDir;
+}
+
+export function getCargoArtifactDir(targetDirArg: string, profileArg: string, targetTripleArg?: string): string {
+  return targetTripleArg
+    ? path.join(targetDirArg, targetTripleArg, profileArg)
+    : path.join(targetDirArg, profileArg);
+}
+
+export function parseSizeToBytes(valueArg: string | undefined): number | undefined {
+  if (!valueArg) {
+    return undefined;
+  }
+  const match = valueArg.trim().match(/^(\d+(?:\.\d+)?)(b|kb|kib|mb|mib|gb|gib)?$/i);
+  if (!match) {
+    return undefined;
+  }
+  const value = Number(match[1]);
+  const unit = (match[2] || 'b').toLowerCase();
+  const multiplier = unit === 'gb' || unit === 'gib'
+    ? 1024 ** 3
+    : unit === 'mb' || unit === 'mib'
+      ? 1024 ** 2
+      : unit === 'kb' || unit === 'kib'
+        ? 1024
+        : 1;
+  return Math.round(value * multiplier);
+}
+
+export async function writeTargetCacheMarker(targetDirArg: string): Promise<void> {
+  await fs.mkdir(targetDirArg, { recursive: true });
+  const existingMarker = await readTargetCacheMarker(targetDirArg);
+  if (existingMarker) {
+    return;
+  }
+  const entries = await fs.readdir(targetDirArg);
+  if (entries.length > 0) {
+    throw new Error(`Refusing to mark pre-existing non-empty tsrust target cache: ${targetDirArg}`);
+  }
+  await fs.writeFile(
+    path.join(targetDirArg, toolCacheMarkerFile),
+    `${JSON.stringify(createTargetCacheMarker(), null, 2)}\n`,
+  );
+}
+
+export async function readTargetCacheMarker(targetDirArg: string): Promise<IToolCacheMarker | undefined> {
+  try {
+    const markerRaw = await fs.readFile(path.join(targetDirArg, toolCacheMarkerFile), 'utf8');
+    const marker = JSON.parse(markerRaw);
+    return isValidTargetCacheMarker(marker) ? marker : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function pathExists(pathArg: string): Promise<boolean> {
+  try {
+    await fs.stat(pathArg);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function getDirectorySize(pathArg: string): Promise<number> {
+  let total = 0;
+  let entries;
+  try {
+    entries = await fs.readdir(pathArg, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+
+  for (const entry of entries) {
+    const entryPath = path.join(pathArg, entry.name);
+    if (entry.isDirectory()) {
+      total += await getDirectorySize(entryPath);
+    } else if (entry.isFile()) {
+      try {
+        total += (await fs.stat(entryPath)).size;
+      } catch {
+        // Ignore files that disappear while planning a prune.
+      }
+    }
+  }
+
+  return total;
+}
+
+async function getDirectoryUsage(pathArg: string, maxEntriesArg = 100_000): Promise<{ bytes: number; newestMtimeMs: number; truncated: boolean }> {
+  let bytes = 0;
+  let newestMtimeMs = 0;
+  let visitedEntries = 0;
+  let truncated = false;
+
+  const visit = async (entryPathArg: string): Promise<void> => {
+    if (visitedEntries >= maxEntriesArg) {
+      truncated = true;
+      return;
+    }
+    visitedEntries++;
+
+    let stat;
+    try {
+      stat = await fs.stat(entryPathArg);
+    } catch {
+      return;
+    }
+    newestMtimeMs = Math.max(newestMtimeMs, stat.mtimeMs);
+    if (stat.isFile()) {
+      bytes += stat.size;
+      return;
+    }
+    if (!stat.isDirectory()) {
+      return;
+    }
+
+    let entries;
+    try {
+      entries = await fs.readdir(entryPathArg, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (visitedEntries >= maxEntriesArg) {
+        truncated = true;
+        return;
+      }
+      await visit(path.join(entryPathArg, entry.name));
+    }
+  };
+
+  await visit(pathArg);
+  return { bytes, newestMtimeMs, truncated };
+}
+
+async function getNewestMtimeMs(pathArg: string): Promise<number> {
+  let newest = 0;
+  try {
+    const stat = await fs.stat(pathArg);
+    newest = stat.mtimeMs;
+  } catch {
+    return 0;
+  }
+
+  let entries;
+  try {
+    entries = await fs.readdir(pathArg, { withFileTypes: true });
+  } catch {
+    return newest;
+  }
+
+  for (const entry of entries) {
+    const entryPath = path.join(pathArg, entry.name);
+    if (entry.isDirectory()) {
+      newest = Math.max(newest, await getNewestMtimeMs(entryPath));
+    } else if (entry.isFile()) {
+      try {
+        newest = Math.max(newest, (await fs.stat(entryPath)).mtimeMs);
+      } catch {
+        // Ignore files that disappear while planning a prune.
+      }
+    }
+  }
+
+  return newest;
+}
+
+export async function createTsrustPrunePlan(optionsArg: ITsrustPruneOptions): Promise<ITsrustPruneCandidate[]> {
+  const workspace = path.resolve(optionsArg.workspace);
+  const managedTargetDir = optionsArg.targetDir
+    ? resolveManagedTargetDir(workspace, optionsArg.targetDir)
+    : resolveManagedTargetDir(workspace);
+  const candidates = [
+    managedTargetDir,
+    path.join(workspace, 'rust', 'target'),
+    path.join(workspace, 'ts_rust', 'target'),
+  ];
+  const uniqueCandidates = [...new Set(candidates.map((candidate) => path.resolve(candidate)))];
+  const pruneCandidates: ITsrustPruneCandidate[] = [];
+  const maxAgeMs = typeof optionsArg.days === 'number' ? optionsArg.days * 24 * 60 * 60 * 1000 : undefined;
+
+  for (const candidate of uniqueCandidates) {
+    if (!(await pathExists(candidate))) {
+      continue;
+    }
+    const marker = await readTargetCacheMarker(candidate);
+    const usage = await getDirectoryUsage(candidate);
+    const isManagedTarget = isSafeManagedTargetDir(workspace, candidate);
+    const ageMatches = typeof maxAgeMs === 'number' ? Date.now() - usage.newestMtimeMs >= maxAgeMs : false;
+    const bytes = usage.bytes;
+    const sizeMatches = typeof optionsArg.maxSizeBytes === 'number' ? bytes >= optionsArg.maxSizeBytes : false;
+    const shouldPrune = !!marker && isManagedTarget && (ageMatches || sizeMatches);
+    const reason = marker
+      ? !isManagedTarget
+        ? 'marked Rust target outside managed tsrust target allowlist; report-only'
+        : shouldPrune
+        ? [ageMatches ? `older than ${optionsArg.days} day(s)` : '', sizeMatches ? `at least ${optionsArg.maxSizeBytes} bytes` : ''].filter(Boolean).join(', ')
+        : 'marked tsrust target cache; below prune thresholds'
+      : 'unmarked conventional Rust target; report-only';
+
+    pruneCandidates.push({
+      path: candidate,
+      workspace,
+      bytes,
+      marked: !!marker,
+      shouldPrune,
+      reason,
+      truncated: usage.truncated,
+    });
+  }
+
+  return pruneCandidates;
+}
+
+export async function applyTsrustPrunePlan(planArg: ITsrustPruneCandidate[]): Promise<void> {
+  for (const candidate of planArg) {
+    if (!candidate.shouldPrune) {
+      continue;
+    }
+    if (!isSafeManagedTargetDir(candidate.workspace, candidate.path)) {
+      throw new Error(`Refusing unsafe Rust target cache path: ${candidate.path}`);
+    }
+    const marker = await readTargetCacheMarker(candidate.path);
+    if (!marker) {
+      throw new Error(`Refusing to remove unmarked Rust target cache: ${candidate.path}`);
+    }
+    await fs.rm(candidate.path, { recursive: true, force: true });
+  }
+}

package/ts/mod_cargo/index.ts

@@ -1,2 +1,3 @@
 export { CargoConfig } from './classes.cargoconfig.js';
 export { CargoRunner } from './classes.cargorunner.js';
+export * from './classes.targetcache.js';

package/ts/mod_cli/classes.tsrustcli.ts

@@ -1,7 +1,16 @@
 import * as path from 'path';
+import * as os from 'os';
 import * as plugins from '../plugins.js';
 import { CargoConfig } from '../mod_cargo/index.js';
 import { CargoRunner } from '../mod_cargo/index.js';
+import {
+  applyTsrustPrunePlan,
+  createTsrustPrunePlan,
+  getCargoArtifactDir,
+  parseSizeToBytes,
+  resolveManagedTargetDir,
+  writeTargetCacheMarker,
+} from '../mod_cargo/index.js';
 import { ElfInspector } from '../mod_elf/index.js';
 import { FsHelpers } from '../mod_fs/index.js';
 import { ToolchainManager } from '../mod_toolchain/index.js';
@@ -45,6 +54,10 @@ function friendlyName(triple: string): string {
 interface ITsrustConfig {
   targets?: string[];
   static?: boolean;
+  rustflags?: string[];
+  remapLocalPaths?: boolean;
+  targetDir?: string;
+  pruneAfterBuild?: boolean;
 }
 
 /** crt-static injection only applies to glibc targets; musl is static by default. */
@@ -72,6 +85,7 @@ export class TsRustCli {
   private registerCommands(): void {
     this.registerStandardCommand();
     this.registerCleanCommand();
+    this.registerPruneCommand();
   }
 
   /**
@@ -132,6 +146,8 @@ export class TsRustCli {
       const shouldClean = !!(argvArg as any).clean;
       const distDir = path.join(this.cwd, 'dist_rust');
       const profile = isDebug ? 'debug' : 'release';
+      const managedTargetDir = resolveManagedTargetDir(this.cwd, this.config.targetDir);
+      await writeTargetCacheMarker(managedTargetDir);
 
       // Parse --target flag (can appear multiple times), fall back to smartconfig.json config
       const cliTargets = (argvArg as any).target;
@@ -144,6 +160,11 @@ export class TsRustCli {
         console.log('Static linking enabled (crt-static for linux-gnu targets)');
       }
 
+      const rustflags = this.buildRustflags(rustDir);
+      if (rustflags.length > 0) {
+        console.log(`Using additional Rust flags: ${rustflags.join(' ')}`);
+      }
+
       if (targets.length > 0) {
         // Cross-compilation mode
         const resolvedTargets = targets.map((t: string) => ({
@@ -166,6 +187,8 @@ export class TsRustCli {
             clean: shouldClean,
             target: triple,
             crtStatic: useStatic && wantsCrtStatic(triple),
+            rustflags,
+            targetDir: managedTargetDir,
           });
 
           if (!buildResult.success) {
@@ -173,8 +196,7 @@ export class TsRustCli {
             process.exit(1);
           }
 
-          // Cross-compiled binaries go to target/<triple>/<profile>/
-          const targetDir = path.join(rustDir, 'target', triple, profile);
+          const targetDir = getCargoArtifactDir(managedTargetDir, profile, triple);
 
           for (const binName of workspaceInfo.binTargets) {
             const srcBinary = path.join(targetDir, binName);
@@ -224,6 +246,8 @@ export class TsRustCli {
           clean: shouldClean,
           target: nativeTriple,
           crtStatic: !!nativeTriple && wantsCrtStatic(nativeTriple),
+          rustflags,
+          targetDir: managedTargetDir,
         });
 
         if (!buildResult.success) {
@@ -231,9 +255,7 @@ export class TsRustCli {
           process.exit(1);
         }
 
-        const targetDir = nativeTriple
-          ? path.join(rustDir, 'target', nativeTriple, profile)
-          : path.join(rustDir, 'target', profile);
+        const targetDir = getCargoArtifactDir(managedTargetDir, profile, nativeTriple);
 
         await FsHelpers.ensureEmptyDir(distDir);
 
@@ -262,11 +284,44 @@ export class TsRustCli {
         }
       }
 
+      if (this.shouldPruneAfterBuild()) {
+        const plan = await createTsrustPrunePlan({
+          workspace: this.cwd,
+          targetDir: managedTargetDir,
+          days: 0,
+        });
+        await applyTsrustPrunePlan(plan);
+        console.log('Pruned marked tsrust target cache after successful build.');
+      }
+
       const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
       console.log(`\nDone in ${elapsed}s`);
     });
   }
 
+  private shouldPruneAfterBuild(): boolean {
+    const normalized = process.env.TSRUST_PRUNE_AFTER_BUILD?.toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'y' || this.config.pruneAfterBuild === true;
+  }
+
+  private buildRustflags(rustDir: string): string[] {
+    const rustflags = [...(this.config.rustflags || [])];
+    if (this.config.remapLocalPaths) {
+      const remaps = new Map<string, string>();
+      remaps.set(this.cwd, '/workspace');
+      remaps.set(rustDir, '/workspace/rust');
+      remaps.set(process.env.CARGO_HOME || path.join(os.homedir(), '.cargo'), '/cargo');
+      remaps.set(ToolchainManager.CARGO_HOME, '/cargo');
+      remaps.set(process.env.RUSTUP_HOME || path.join(os.homedir(), '.rustup'), '/rustup');
+      remaps.set(ToolchainManager.RUSTUP_HOME, '/rustup');
+
+      for (const [from, to] of remaps.entries()) {
+        rustflags.push(`--remap-path-prefix=${from}=${to}`);
+      }
+    }
+    return rustflags;
+  }
+
   private registerCleanCommand(): void {
     this.cli.addCommand('clean').subscribe(async (_argvArg) => {
       // Clean cargo build
@@ -275,7 +330,7 @@ export class TsRustCli {
         const envPrefix = await this.resolveToolchain();
         console.log('Running cargo clean...');
         const runner = new CargoRunner(rustDir, envPrefix);
-        await runner.clean();
+        await runner.clean({ targetDir: resolveManagedTargetDir(this.cwd, this.config.targetDir) });
         console.log('Cargo clean complete.');
       }
 
@@ -290,6 +345,36 @@ export class TsRustCli {
     });
   }
 
+  private registerPruneCommand(): void {
+    this.cli.addCommand('prune').subscribe(async (argvArg) => {
+      const workspace = ((argvArg as any).workspace as string | undefined) || this.cwd;
+      const daysArg = (argvArg as any).days;
+      const days = daysArg === undefined ? 14 : Number(daysArg);
+      const maxSizeBytes = parseSizeToBytes((argvArg as any).maxSize as string | undefined);
+      const apply = !!(argvArg as any).apply;
+      const plan = await createTsrustPrunePlan({
+        workspace,
+        targetDir: resolveManagedTargetDir(workspace, this.config.targetDir),
+        days: Number.isFinite(days) ? days : 14,
+        maxSizeBytes,
+      });
+
+      console.log(apply ? 'tsrust prune apply plan:' : 'tsrust prune dry-run plan:');
+      if (plan.length === 0) {
+        console.log('No Rust target caches found.');
+      }
+      for (const candidate of plan) {
+        const action = candidate.shouldPrune ? (apply ? 'remove' : 'would remove') : 'report';
+        console.log(`${action}: ${candidate.path} (${FsHelpers.formatFileSize(candidate.bytes)}) - ${candidate.reason}`);
+      }
+      if (apply) {
+        await applyTsrustPrunePlan(plan);
+      } else {
+        console.log('Dry-run only. Re-run with --apply to remove marked tsrust target caches.');
+      }
+    });
+  }
+
   private async detectRustDir(): Promise<string | null> {
     // Check rust/ first
     const rustDir = path.join(this.cwd, 'rust');