@git.zone/tsrust 1.5.0 → 1.7.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,11 +1,21 @@
+import * as fs from 'fs';
 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 { ElfInspector } from '../mod_elf/index.js';
+import {
+  applyTsrustPrunePlan,
+  createTsrustPrunePlan,
+  getCargoArtifactDir,
+  parseSizeToBytes,
+  resolveManagedTargetDir,
+  writeTargetCacheMarker,
+} from '../mod_cargo/index.js';
+import { ElfInspector, ProvenanceStamper, type ITsrustBuildInfo } from '../mod_elf/index.js';
 import { FsHelpers } from '../mod_fs/index.js';
 import { ToolchainManager } from '../mod_toolchain/index.js';
+import { commitinfo } from '../00_commitinfo_data.js';
 
 /** Maps friendly target names to Rust target triples */
 const targetAliasMap: Record<string, string> = {
@@ -48,6 +58,8 @@ interface ITsrustConfig {
   static?: boolean;
   rustflags?: string[];
   remapLocalPaths?: boolean;
+  targetDir?: string;
+  pruneAfterBuild?: boolean;
 }
 
 /** crt-static injection only applies to glibc targets; musl is static by default. */
@@ -75,6 +87,44 @@ export class TsRustCli {
   private registerCommands(): void {
     this.registerStandardCommand();
     this.registerCleanCommand();
+    this.registerPruneCommand();
+    this.registerInspectCommand();
+  }
+
+  /**
+   * Collects build provenance once per run: consuming project identity,
+   * git commit, and the tsrust version doing the build. Tolerant of
+   * non-git checkouts and missing package metadata.
+   */
+  private async collectBuildProvenance(): Promise<Omit<ITsrustBuildInfo, 'binary' | 'target'>> {
+    let projectName = 'unknown';
+    let projectVersion = 'unknown';
+    try {
+      const packageJson = JSON.parse(
+        fs.readFileSync(path.join(this.cwd, 'package.json'), 'utf8'),
+      );
+      projectName = packageJson.name || projectName;
+      projectVersion = packageJson.version || projectVersion;
+    } catch {
+      // package.json optional for pure Rust workspaces
+    }
+    let gitCommit = 'unknown';
+    try {
+      const shell = new plugins.smartshell.Smartshell({ executor: 'bash' });
+      const result = await shell.execSilent(`git -C ${JSON.stringify(this.cwd)} rev-parse HEAD`);
+      if (result.exitCode === 0) {
+        gitCommit = result.stdout.trim();
+      }
+    } catch {
+      // not a git checkout
+    }
+    return {
+      projectName,
+      projectVersion,
+      gitCommit,
+      builtAt: new Date().toISOString(),
+      tsrustVersion: commitinfo.version,
+    };
   }
 
   /**
@@ -135,6 +185,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;
@@ -152,6 +204,8 @@ export class TsRustCli {
         console.log(`Using additional Rust flags: ${rustflags.join(' ')}`);
       }
 
+      const buildProvenance = await this.collectBuildProvenance();
+
       if (targets.length > 0) {
         // Cross-compilation mode
         const resolvedTargets = targets.map((t: string) => ({
@@ -175,6 +229,7 @@ export class TsRustCli {
             target: triple,
             crtStatic: useStatic && wantsCrtStatic(triple),
             rustflags,
+            targetDir: managedTargetDir,
           });
 
           if (!buildResult.success) {
@@ -182,8 +237,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);
@@ -208,6 +262,13 @@ export class TsRustCli {
               }
               console.log(`Verified statically linked: dist_rust/${destName}`);
             }
+
+            await ProvenanceStamper.stamp(destBinary, {
+              ...buildProvenance,
+              binary: binName,
+              target: friendly,
+            });
+            console.log(`Stamped provenance: ${buildProvenance.projectName}@${buildProvenance.projectVersion} ${buildProvenance.gitCommit.slice(0, 12)} (${friendly})`);
           }
 
           // Only clean on first iteration
@@ -234,6 +295,7 @@ export class TsRustCli {
           target: nativeTriple,
           crtStatic: !!nativeTriple && wantsCrtStatic(nativeTriple),
           rustflags,
+          targetDir: managedTargetDir,
         });
 
         if (!buildResult.success) {
@@ -241,9 +303,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);
 
@@ -269,14 +329,36 @@ export class TsRustCli {
             }
             console.log(`Verified statically linked: dist_rust/${binName}`);
           }
+
+          await ProvenanceStamper.stamp(destBinary, {
+            ...buildProvenance,
+            binary: binName,
+            target: nativeTriple || 'native',
+          });
+          console.log(`Stamped provenance: ${buildProvenance.projectName}@${buildProvenance.projectVersion} ${buildProvenance.gitCommit.slice(0, 12)} (${nativeTriple || 'native'})`);
         }
       }
 
+      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) {
@@ -295,6 +377,29 @@ export class TsRustCli {
     return rustflags;
   }
 
+  /**
+   * `tsrust inspect <binary>` — prints the embedded build provenance so any
+   * environment can answer "what is this binary built from" definitively.
+   */
+  private registerInspectCommand(): void {
+    this.cli.addCommand('inspect').subscribe(async (argvArg) => {
+      const binaryPath = (argvArg as any)._?.[1];
+      if (!binaryPath) {
+        console.error('Usage: tsrust inspect <path-to-binary>');
+        process.exit(1);
+      }
+      const resolvedPath = path.isAbsolute(binaryPath)
+        ? binaryPath
+        : path.join(this.cwd, binaryPath);
+      const info = await ProvenanceStamper.read(resolvedPath);
+      if (!info) {
+        console.error(`No tsrust build provenance found in ${resolvedPath} (built before tsrust 1.7.0?).`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(info, null, 2));
+    });
+  }
+
   private registerCleanCommand(): void {
     this.cli.addCommand('clean').subscribe(async (_argvArg) => {
       // Clean cargo build
@@ -303,7 +408,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.');
       }
 
@@ -318,6 +423,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');

package/ts/mod_elf/index.ts

@@ -1 +1,2 @@
 export { ElfInspector } from './classes.elfinspector.js';
+export { ProvenanceStamper, type ITsrustBuildInfo } from './classes.provenance.js';