v1.9.0

changelog.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 2026-02-06 - 1.9.0 - feat(build)
+add verbose build output, progress logging, and timing for builds/tests
+
+- Add 'verbose' option to build/test flows (interfaces, CLI, and method signatures) to allow streaming raw docker build output or run silently
+- Log per-item progress for build and test phases (e.g. (1/N) Building/Testing <tag>) and report individual durations
+- Return elapsed time from Dockerfile.build() and Dockerfile.test() and aggregate total build/test times in manager
+- Introduce formatDuration(ms) helper in logging module to format timings
+- Switch from console.log to structured logger calls across cache, manager, dockerfile and push paths
+- Use silent exec variants when verbose is false and stream exec when verbose is true
+
+## 2026-02-06 - 1.8.0 - feat(build)
+add optional content-hash based build cache to skip rebuilding unchanged Dockerfiles
+
+- Introduce TsDockerCache to compute SHA-256 of Dockerfile content and persist cache to .nogit/tsdocker_support.json
+- Add ICacheEntry and ICacheData interfaces and a cached flag to IBuildCommandOptions
+- Integrate cached mode in TsDockerManager: skip builds on cache hits, verify image presence, record builds on misses, and still perform dependency tagging
+- Expose --cached option in CLI to enable the cached build flow
+- Cache records store contentHash, imageId, buildTag and timestamp
+
 ## 2026-02-06 - 1.7.0 - feat(cli)
 add CLI version display using commitinfo
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsdocker",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "private": false,
   "description": "develop npm modules cross platform with docker",
   "main": "dist_ts/index.js",

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tsdocker',
-  version: '1.7.0',
+  version: '1.9.0',
   description: 'develop npm modules cross platform with docker'
 }

ts/classes.dockerfile.ts

@@ -1,6 +1,6 @@
 import * as plugins from './tsdocker.plugins.js';
 import * as paths from './tsdocker.paths.js';
-import { logger } from './tsdocker.logging.js';
+import { logger, formatDuration } from './tsdocker.logging.js';
 import { DockerRegistry } from './classes.dockerregistry.js';
 import type { IDockerfileOptions, ITsDockerConfig, IBuildCommandOptions } from './interfaces/index.js';
 import type { TsDockerManager } from './classes.tsdockermanager.js';
@@ -26,8 +26,10 @@ export class Dockerfile {
       .map(entry => plugins.path.join(paths.cwd, entry.name));
 
     const readDockerfilesArray: Dockerfile[] = [];
-    logger.log('info', `found ${fileTree.length} Dockerfiles:`);
+    logger.log('info', `found ${fileTree.length} Dockerfile(s):`);
-    console.log(fileTree);
+    for (const filePath of fileTree) {
+      logger.log('info', `  ${plugins.path.basename(filePath)}`);
+    }
 
     for (const dockerfilePath of fileTree) {
       const myDockerfile = new Dockerfile(managerRef, {
@@ -138,10 +140,18 @@ export class Dockerfile {
    */
   public static async buildDockerfiles(
     sortedArrayArg: Dockerfile[],
-    options?: { platform?: string; timeout?: number; noCache?: boolean },
+    options?: { platform?: string; timeout?: number; noCache?: boolean; verbose?: boolean },
   ): Promise<Dockerfile[]> {
-    for (const dockerfileArg of sortedArrayArg) {
+    const total = sortedArrayArg.length;
-      await dockerfileArg.build(options);
+    const overallStart = Date.now();
+
+    for (let i = 0; i < total; i++) {
+      const dockerfileArg = sortedArrayArg[i];
+      const progress = `(${i + 1}/${total})`;
+      logger.log('info', `${progress} Building ${dockerfileArg.cleanTag}...`);
+
+      const elapsed = await dockerfileArg.build(options);
+      logger.log('ok', `${progress} Built ${dockerfileArg.cleanTag} in ${formatDuration(elapsed)}`);
 
       // Tag the built image with the full base image references used by dependent Dockerfiles,
       // so their FROM lines resolve to the locally-built image instead of pulling from a registry.
@@ -156,6 +166,8 @@ export class Dockerfile {
         await smartshellInstance.exec(`docker tag ${dockerfileArg.buildTag} ${fullTag}`);
       }
     }
+
+    logger.log('info', `Total build time: ${formatDuration(Date.now() - overallStart)}`);
     return sortedArrayArg;
   }
 
@@ -163,9 +175,19 @@ export class Dockerfile {
    * Tests all Dockerfiles by calling Dockerfile.test()
    */
   public static async testDockerfiles(sortedArrayArg: Dockerfile[]): Promise<Dockerfile[]> {
-    for (const dockerfileArg of sortedArrayArg) {
+    const total = sortedArrayArg.length;
-      await dockerfileArg.test();
+    const overallStart = Date.now();
+
+    for (let i = 0; i < total; i++) {
+      const dockerfileArg = sortedArrayArg[i];
+      const progress = `(${i + 1}/${total})`;
+      logger.log('info', `${progress} Testing ${dockerfileArg.cleanTag}...`);
+
+      const elapsed = await dockerfileArg.test();
+      logger.log('ok', `${progress} Tested ${dockerfileArg.cleanTag} in ${formatDuration(elapsed)}`);
     }
+
+    logger.log('info', `Total test time: ${formatDuration(Date.now() - overallStart)}`);
     return sortedArrayArg;
   }
 
@@ -378,13 +400,14 @@ export class Dockerfile {
   /**
    * Builds the Dockerfile
    */
-  public async build(options?: { platform?: string; timeout?: number; noCache?: boolean }): Promise<void> {
+  public async build(options?: { platform?: string; timeout?: number; noCache?: boolean; verbose?: boolean }): Promise<number> {
-    logger.log('info', 'now building Dockerfile for ' + this.cleanTag);
+    const startTime = Date.now();
     const buildArgsString = await Dockerfile.getDockerBuildArgs(this.managerRef);
     const config = this.managerRef.config;
     const platformOverride = options?.platform;
     const timeout = options?.timeout;
     const noCacheFlag = options?.noCache ? ' --no-cache' : '';
+    const verbose = options?.verbose ?? false;
 
     let buildCommand: string;
 
@@ -409,7 +432,9 @@ export class Dockerfile {
 
     if (timeout) {
       // Use streaming execution with timeout
-      const streaming = await smartshellInstance.execStreaming(buildCommand);
+      const streaming = verbose
+        ? await smartshellInstance.execStreaming(buildCommand)
+        : await smartshellInstance.execStreamingSilent(buildCommand);
       const timeoutPromise = new Promise<never>((_, reject) => {
         setTimeout(() => {
           streaming.childProcess.kill();
@@ -422,15 +447,19 @@ export class Dockerfile {
         throw new Error(`Build failed for ${this.cleanTag}`);
       }
     } else {
-      const result = await smartshellInstance.exec(buildCommand);
+      const result = verbose
+        ? await smartshellInstance.exec(buildCommand)
+        : await smartshellInstance.execSilent(buildCommand);
       if (result.exitCode !== 0) {
         logger.log('error', `Build failed for ${this.cleanTag}`);
-        console.log(result.stdout);
+        if (!verbose && result.stdout) {
+          logger.log('error', `Build output:\n${result.stdout}`);
+        }
         throw new Error(`Build failed for ${this.cleanTag}`);
       }
     }
 
-    logger.log('ok', `Built ${this.cleanTag}`);
+    return Date.now() - startTime;
   }
 
   /**
@@ -460,7 +489,7 @@ export class Dockerfile {
 
     if (inspectResult.exitCode === 0 && inspectResult.stdout.includes('@')) {
       const imageDigest = inspectResult.stdout.split('@')[1]?.trim();
-      console.log(`The image ${this.pushTag} has digest ${imageDigest}`);
+      logger.log('info', `The image ${this.pushTag} has digest ${imageDigest}`);
     }
 
     logger.log('ok', `Pushed ${this.pushTag}`);
@@ -487,15 +516,14 @@ export class Dockerfile {
   /**
    * Tests the Dockerfile by running a test script if it exists
    */
-  public async test(): Promise<void> {
+  public async test(): Promise<number> {
+    const startTime = Date.now();
     const testDir = this.managerRef.config.testDir || plugins.path.join(paths.cwd, 'test');
     const testFile = plugins.path.join(testDir, 'test_' + this.version + '.sh');
 
     const testFileExists = fs.existsSync(testFile);
 
     if (testFileExists) {
-      logger.log('info', `Running tests for ${this.cleanTag}`);
-
       // Run tests in container
       await smartshellInstance.exec(
         `docker run --name tsdocker_test_container --entrypoint="bash" ${this.buildTag} -c "mkdir /tsdocker_test"`
@@ -514,11 +542,11 @@ export class Dockerfile {
       if (testResult.exitCode !== 0) {
         throw new Error(`Tests failed for ${this.cleanTag}`);
       }
-
-      logger.log('ok', `Tests passed for ${this.cleanTag}`);
     } else {
-      logger.log('warn', `Skipping tests for ${this.cleanTag} because no test file was found at ${testFile}`);
+      logger.log('warn', `Skipping tests for ${this.cleanTag} — no test file at ${testFile}`);
     }
+
+    return Date.now() - startTime;
   }
 
   /**

ts/classes.tsdockercache.ts

@@ -0,0 +1,108 @@
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as plugins from './tsdocker.plugins.js';
+import * as paths from './tsdocker.paths.js';
+import { logger } from './tsdocker.logging.js';
+import type { ICacheData, ICacheEntry } from './interfaces/index.js';
+
+const smartshellInstance = new plugins.smartshell.Smartshell({
+  executor: 'bash',
+});
+
+/**
+ * Manages content-hash-based build caching for Dockerfiles.
+ * Cache is stored in .nogit/tsdocker_support.json.
+ */
+export class TsDockerCache {
+  private cacheFilePath: string;
+  private data: ICacheData;
+
+  constructor() {
+    this.cacheFilePath = path.join(paths.cwd, '.nogit', 'tsdocker_support.json');
+    this.data = { version: 1, entries: {} };
+  }
+
+  /**
+   * Loads cache data from disk. Falls back to empty cache on missing/corrupt file.
+   */
+  public load(): void {
+    try {
+      const raw = fs.readFileSync(this.cacheFilePath, 'utf-8');
+      const parsed = JSON.parse(raw);
+      if (parsed && parsed.version === 1 && parsed.entries) {
+        this.data = parsed;
+      } else {
+        logger.log('warn', '[cache] Cache file has unexpected format, starting fresh');
+        this.data = { version: 1, entries: {} };
+      }
+    } catch {
+      // Missing or corrupt file — start fresh
+      this.data = { version: 1, entries: {} };
+    }
+  }
+
+  /**
+   * Saves cache data to disk. Creates .nogit directory if needed.
+   */
+  public save(): void {
+    const dir = path.dirname(this.cacheFilePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(this.cacheFilePath, JSON.stringify(this.data, null, 2), 'utf-8');
+  }
+
+  /**
+   * Computes SHA-256 hash of Dockerfile content.
+   */
+  public computeContentHash(content: string): string {
+    return crypto.createHash('sha256').update(content).digest('hex');
+  }
+
+  /**
+   * Checks whether a build can be skipped for the given Dockerfile.
+   * Logs detailed diagnostics and returns true if the build should be skipped.
+   */
+  public async shouldSkipBuild(cleanTag: string, content: string): Promise<boolean> {
+    const contentHash = this.computeContentHash(content);
+    const entry = this.data.entries[cleanTag];
+
+    if (!entry) {
+      logger.log('info', `[cache] ${cleanTag}: no cached entry, will build`);
+      return false;
+    }
+
+    const hashMatch = entry.contentHash === contentHash;
+    logger.log('info', `[cache] ${cleanTag}: hash ${hashMatch ? 'matches' : 'changed'}`);
+
+    if (!hashMatch) {
+      logger.log('info', `[cache] ${cleanTag}: content changed, will build`);
+      return false;
+    }
+
+    // Hash matches — verify the image still exists locally
+    const inspectResult = await smartshellInstance.exec(
+      `docker image inspect ${entry.imageId} > /dev/null 2>&1`
+    );
+    const available = inspectResult.exitCode === 0;
+
+    if (available) {
+      logger.log('info', `[cache] ${cleanTag}: cache hit, skipping build`);
+      return true;
+    }
+
+    logger.log('info', `[cache] ${cleanTag}: image no longer available, will build`);
+    return false;
+  }
+
+  /**
+   * Records a successful build in the cache.
+   */
+  public recordBuild(cleanTag: string, content: string, imageId: string, buildTag: string): void {
+    this.data.entries[cleanTag] = {
+      contentHash: this.computeContentHash(content),
+      imageId,
+      buildTag,
+      timestamp: Date.now(),
+    };
+  }
+}

ts/classes.tsdockermanager.ts

@@ -1,9 +1,10 @@
 import * as plugins from './tsdocker.plugins.js';
 import * as paths from './tsdocker.paths.js';
-import { logger } from './tsdocker.logging.js';
+import { logger, formatDuration } from './tsdocker.logging.js';
 import { Dockerfile } from './classes.dockerfile.js';
 import { DockerRegistry } from './classes.dockerregistry.js';
 import { RegistryStorage } from './classes.registrystorage.js';
+import { TsDockerCache } from './classes.tsdockercache.js';
 import type { ITsDockerConfig, IBuildCommandOptions } from './interfaces/index.js';
 
 const smartshellInstance = new plugins.smartshell.Smartshell({
@@ -135,12 +136,69 @@ export class TsDockerManager {
       await this.ensureBuildx();
     }
 
-    logger.log('info', `Building ${toBuild.length} Dockerfiles...`);
+    logger.log('info', '');
-    await Dockerfile.buildDockerfiles(toBuild, {
+    logger.log('info', '=== BUILD PHASE ===');
-      platform: options?.platform,
+    logger.log('info', `Building ${toBuild.length} Dockerfile(s)...`);
-      timeout: options?.timeout,
+
-      noCache: options?.noCache,
+    if (options?.cached) {
-    });
+      // === CACHED MODE: skip builds for unchanged Dockerfiles ===
+      logger.log('info', '(cached mode active)');
+      const cache = new TsDockerCache();
+      cache.load();
+
+      const total = toBuild.length;
+      const overallStart = Date.now();
+
+      for (let i = 0; i < total; i++) {
+        const dockerfileArg = toBuild[i];
+        const progress = `(${i + 1}/${total})`;
+        const skip = await cache.shouldSkipBuild(dockerfileArg.cleanTag, dockerfileArg.content);
+        if (skip) {
+          logger.log('ok', `${progress} Skipped ${dockerfileArg.cleanTag} (cached)`);
+          continue;
+        }
+
+        // Cache miss — build this Dockerfile
+        logger.log('info', `${progress} Building ${dockerfileArg.cleanTag}...`);
+        const elapsed = await dockerfileArg.build({
+          platform: options?.platform,
+          timeout: options?.timeout,
+          noCache: options?.noCache,
+          verbose: options?.verbose,
+        });
+        logger.log('ok', `${progress} Built ${dockerfileArg.cleanTag} in ${formatDuration(elapsed)}`);
+
+        const imageId = await dockerfileArg.getId();
+        cache.recordBuild(dockerfileArg.cleanTag, dockerfileArg.content, imageId, dockerfileArg.buildTag);
+      }
+
+      logger.log('info', `Total build time: ${formatDuration(Date.now() - overallStart)}`);
+
+      // Perform dependency tagging for all Dockerfiles (even cache hits, since tags may be stale)
+      for (const dockerfileArg of toBuild) {
+        const dependentBaseImages = new Set<string>();
+        for (const other of toBuild) {
+          if (other.localBaseDockerfile === dockerfileArg && other.baseImage !== dockerfileArg.buildTag) {
+            dependentBaseImages.add(other.baseImage);
+          }
+        }
+        for (const fullTag of dependentBaseImages) {
+          logger.log('info', `Tagging ${dockerfileArg.buildTag} as ${fullTag} for local dependency resolution`);
+          await smartshellInstance.exec(`docker tag ${dockerfileArg.buildTag} ${fullTag}`);
+        }
+      }
+
+      cache.save();
+    } else {
+      // === STANDARD MODE: build all via static helper ===
+      await Dockerfile.buildDockerfiles(toBuild, {
+        platform: options?.platform,
+        timeout: options?.timeout,
+        noCache: options?.noCache,
+        verbose: options?.verbose,
+      });
+    }
+
     logger.log('success', 'All Dockerfiles built successfully');
 
     return toBuild;
@@ -264,6 +322,8 @@ export class TsDockerManager {
       return;
     }
 
+    logger.log('info', '');
+    logger.log('info', '=== TEST PHASE ===');
     await Dockerfile.testDockerfiles(this.dockerfiles);
     logger.log('success', 'All tests completed');
   }
@@ -276,19 +336,21 @@ export class TsDockerManager {
       await this.discoverDockerfiles();
     }
 
-    console.log('\nDiscovered Dockerfiles:');
+    logger.log('info', '');
-    console.log('========================\n');
+    logger.log('info', 'Discovered Dockerfiles:');
+    logger.log('info', '========================');
+    logger.log('info', '');
 
     for (let i = 0; i < this.dockerfiles.length; i++) {
       const df = this.dockerfiles[i];
-      console.log(`${i + 1}. ${df.filePath}`);
+      logger.log('info', `${i + 1}. ${df.filePath}`);
-      console.log(`   Tag: ${df.cleanTag}`);
+      logger.log('info', `   Tag: ${df.cleanTag}`);
-      console.log(`   Base Image: ${df.baseImage}`);
+      logger.log('info', `   Base Image: ${df.baseImage}`);
-      console.log(`   Version: ${df.version}`);
+      logger.log('info', `   Version: ${df.version}`);
       if (df.localBaseImageDependent) {
-        console.log(`   Depends on: ${df.localBaseDockerfile?.cleanTag}`);
+        logger.log('info', `   Depends on: ${df.localBaseDockerfile?.cleanTag}`);
       }
-      console.log('');
+      logger.log('info', '');
     }
 
     return this.dockerfiles;

ts/interfaces/index.ts

@@ -77,4 +77,18 @@ export interface IBuildCommandOptions {
   platform?: string;    // Single platform override (e.g., 'linux/arm64')
   timeout?: number;     // Build timeout in seconds
   noCache?: boolean;    // Force rebuild without Docker layer cache (--no-cache)
+  cached?: boolean;     // Skip builds when Dockerfile content hasn't changed
+  verbose?: boolean;    // Stream raw docker build output (default: silent)
+}
+
+export interface ICacheEntry {
+  contentHash: string;   // SHA-256 hex of Dockerfile content
+  imageId: string;       // Docker image ID (sha256:...)
+  buildTag: string;
+  timestamp: number;     // Unix ms
+}
+
+export interface ICacheData {
+  version: 1;
+  entries: { [cleanTag: string]: ICacheEntry };
 }

ts/tsdocker.cli.ts

@@ -49,6 +49,12 @@ export let run = () => {
       if (argvArg.cache === false) {
         buildOptions.noCache = true;
       }
+      if (argvArg.cached) {
+        buildOptions.cached = true;
+      }
+      if (argvArg.verbose) {
+        buildOptions.verbose = true;
+      }
 
       await manager.build(buildOptions);
       logger.log('success', 'Build completed successfully');
@@ -86,6 +92,9 @@ export let run = () => {
       if (argvArg.cache === false) {
         buildOptions.noCache = true;
       }
+      if (argvArg.verbose) {
+        buildOptions.verbose = true;
+      }
 
       // Build images first (if not already built)
       await manager.build(buildOptions);
@@ -142,6 +151,12 @@ export let run = () => {
       if (argvArg.cache === false) {
         buildOptions.noCache = true;
       }
+      if (argvArg.cached) {
+        buildOptions.cached = true;
+      }
+      if (argvArg.verbose) {
+        buildOptions.verbose = true;
+      }
       await manager.build(buildOptions);
 
       // Run tests

ts/tsdocker.logging.ts

@@ -15,3 +15,12 @@ export const logger = new plugins.smartlog.Smartlog({
 logger.addLogDestination(new plugins.smartlogDestinationLocal.DestinationLocal());
 
 export const ora = new plugins.smartlogSouceOra.SmartlogSourceOra();
+
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  const totalSeconds = ms / 1000;
+  if (totalSeconds < 60) return `${totalSeconds.toFixed(1)}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = Math.round(totalSeconds % 60);
+  return `${minutes}m ${seconds}s`;
+}