v1.6.0

changelog.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 2026-02-06 - 1.6.0 - feat(docker)
+add support for no-cache builds and tag built images for local dependency resolution
+
+- Introduce IBuildCommandOptions.noCache to control --no-cache behavior
+- Propagate noCache from CLI (via cache flag) through TsDockerManager to Dockerfile.build
+- Append --no-cache to docker build/buildx commands when noCache is true
+- After building an image, tag it with full base image references used by dependent Dockerfiles so their FROM lines resolve to the locally-built image
+- Log tagging actions and execute docker tag via smartshellInstance
+
+## 2026-02-06 - 1.5.0 - feat(build)
+add support for selective builds, platform override and build timeout
+
+- Introduce IBuildCommandOptions with patterns, platform and timeout to control build behavior
+- Allow manager.build() to accept options and build only matching Dockerfiles (including dependencies) preserving topological order
+- Add CLI parsing for build/push to accept positional Dockerfile patterns and --platform/--timeout flags
+- Support single-platform override via docker buildx and multi-platform buildx detection
+- Implement streaming exec with timeout to kill long-running builds and surface timeout errors
+
+## 2026-02-04 - 1.4.3 - fix(dockerfile)
+fix matching of base images to local Dockerfiles by stripping registry prefixes when comparing image references
+
+- Added Dockerfile.extractRepoVersion(imageRef) to normalize image references by removing registry prefixes (detects registries containing '.' or ':' or 'localhost').
+- Use extractRepoVersion when checking tagToDockerfile and when mapping local base dockerfiles to ensure comparisons use repo:tag keys rather than full registry-prefixed references.
+- Prevents mismatches when baseImage includes a registry (e.g. "host.today/repo:version") so it correctly matches a local cleanTag like "repo:version".
+
 ## 2026-01-21 - 1.4.2 - fix(classes.dockerfile)
 use a single top-level fs import instead of requiring fs inside methods
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsdocker",
-  "version": "1.4.2",
+  "version": "1.6.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.4.2',
+  version: '1.6.0',
   description: 'develop npm modules cross platform with docker'
 }

ts/classes.dockerfile.ts

@@ -2,7 +2,7 @@ import * as plugins from './tsdocker.plugins.js';
 import * as paths from './tsdocker.paths.js';
 import { logger } from './tsdocker.logging.js';
 import { DockerRegistry } from './classes.dockerregistry.js';
-import type { IDockerfileOptions, ITsDockerConfig } from './interfaces/index.js';
+import type { IDockerfileOptions, ITsDockerConfig, IBuildCommandOptions } from './interfaces/index.js';
 import type { TsDockerManager } from './classes.tsdockermanager.js';
 import * as fs from 'fs';
 
@@ -58,9 +58,14 @@ export class Dockerfile {
       const dependencies: Dockerfile[] = [];
       const baseImage = dockerfile.baseImage;
 
+      // Extract repo:version from baseImage for comparison with cleanTag
+      // baseImage may include a registry prefix (e.g., "host.today/repo:version")
+      // but cleanTag is just "repo:version", so we strip the registry prefix
+      const baseImageKey = Dockerfile.extractRepoVersion(baseImage);
+
       // Check if the baseImage is among the local Dockerfiles
-      if (tagToDockerfile.has(baseImage)) {
-        const baseDockerfile = tagToDockerfile.get(baseImage)!;
+      if (tagToDockerfile.has(baseImageKey)) {
+        const baseDockerfile = tagToDockerfile.get(baseImageKey)!;
         dependencies.push(baseDockerfile);
         dockerfile.localBaseImageDependent = true;
         dockerfile.localBaseDockerfile = baseDockerfile;
@@ -116,8 +121,10 @@ export class Dockerfile {
   public static async mapDockerfiles(sortedDockerfileArray: Dockerfile[]): Promise<Dockerfile[]> {
     sortedDockerfileArray.forEach((dockerfileArg) => {
       if (dockerfileArg.localBaseImageDependent) {
+        // Extract repo:version from baseImage for comparison with cleanTag
+        const baseImageKey = Dockerfile.extractRepoVersion(dockerfileArg.baseImage);
         sortedDockerfileArray.forEach((dockfile2: Dockerfile) => {
-          if (dockfile2.cleanTag === dockerfileArg.baseImage) {
+          if (dockfile2.cleanTag === baseImageKey) {
             dockerfileArg.localBaseDockerfile = dockfile2;
           }
         });
@@ -129,9 +136,25 @@ export class Dockerfile {
   /**
    * Builds the corresponding real docker image for each Dockerfile class instance
    */
-  public static async buildDockerfiles(sortedArrayArg: Dockerfile[]): Promise<Dockerfile[]> {
+  public static async buildDockerfiles(
+    sortedArrayArg: Dockerfile[],
+    options?: { platform?: string; timeout?: number; noCache?: boolean },
+  ): Promise<Dockerfile[]> {
     for (const dockerfileArg of sortedArrayArg) {
-      await dockerfileArg.build();
+      await dockerfileArg.build(options);
+
+      // 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.
+      const dependentBaseImages = new Set<string>();
+      for (const other of sortedArrayArg) {
+        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}`);
+      }
     }
     return sortedArrayArg;
   }
@@ -231,6 +254,34 @@ export class Dockerfile {
     });
   }
 
+  /**
+   * Extracts the repo:version part from a full image reference, stripping any registry prefix.
+   * Examples:
+   *   "registry.example.com/repo:version" -> "repo:version"
+   *   "repo:version" -> "repo:version"
+   *   "host.today/ht-docker-node:npmci" -> "ht-docker-node:npmci"
+   */
+  private static extractRepoVersion(imageRef: string): string {
+    const parts = imageRef.split('/');
+    if (parts.length === 1) {
+      // No registry prefix: "repo:version"
+      return imageRef;
+    }
+
+    // Check if first part looks like a registry (contains '.' or ':' or is 'localhost')
+    const firstPart = parts[0];
+    const looksLikeRegistry =
+      firstPart.includes('.') || firstPart.includes(':') || firstPart === 'localhost';
+
+    if (looksLikeRegistry) {
+      // Strip registry: "registry.example.com/repo:version" -> "repo:version"
+      return parts.slice(1).join('/');
+    }
+
+    // No registry prefix, could be "org/repo:version"
+    return imageRef;
+  }
+
   /**
    * Returns the docker tag string for a given registry and repo
    */
@@ -327,18 +378,23 @@ export class Dockerfile {
   /**
    * Builds the Dockerfile
    */
-  public async build(): Promise<void> {
+  public async build(options?: { platform?: string; timeout?: number; noCache?: boolean }): Promise<void> {
     logger.log('info', 'now building Dockerfile for ' + this.cleanTag);
     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' : '';
 
     let buildCommand: string;
 
-    // Check if multi-platform build is needed
-    if (config.platforms && config.platforms.length > 1) {
+    if (platformOverride) {
+      // Single platform override via buildx
+      buildCommand = `docker buildx build --platform ${platformOverride}${noCacheFlag} --load -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
+    } else if (config.platforms && config.platforms.length > 1) {
       // Multi-platform build using buildx
       const platformString = config.platforms.join(',');
-      buildCommand = `docker buildx build --platform ${platformString} -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
+      buildCommand = `docker buildx build --platform ${platformString}${noCacheFlag} -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
 
       if (config.push) {
         buildCommand += ' --push';
@@ -348,14 +404,30 @@ export class Dockerfile {
     } else {
       // Standard build
       const versionLabel = this.managerRef.projectInfo?.npm?.version || 'unknown';
-      buildCommand = `docker build --label="version=${versionLabel}" -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
+      buildCommand = `docker build --label="version=${versionLabel}"${noCacheFlag} -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
     }
 
-    const result = await smartshellInstance.exec(buildCommand);
-    if (result.exitCode !== 0) {
-      logger.log('error', `Build failed for ${this.cleanTag}`);
-      console.log(result.stdout);
-      throw new Error(`Build failed for ${this.cleanTag}`);
+    if (timeout) {
+      // Use streaming execution with timeout
+      const streaming = await smartshellInstance.execStreaming(buildCommand);
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          streaming.childProcess.kill();
+          reject(new Error(`Build timed out after ${timeout}s for ${this.cleanTag}`));
+        }, timeout * 1000);
+      });
+      const result = await Promise.race([streaming.finalPromise, timeoutPromise]);
+      if (result.exitCode !== 0) {
+        logger.log('error', `Build failed for ${this.cleanTag}`);
+        throw new Error(`Build failed for ${this.cleanTag}`);
+      }
+    } else {
+      const result = await smartshellInstance.exec(buildCommand);
+      if (result.exitCode !== 0) {
+        logger.log('error', `Build failed for ${this.cleanTag}`);
+        console.log(result.stdout);
+        throw new Error(`Build failed for ${this.cleanTag}`);
+      }
     }
 
     logger.log('ok', `Built ${this.cleanTag}`);

ts/classes.tsdockermanager.ts

@@ -4,7 +4,7 @@ import { logger } from './tsdocker.logging.js';
 import { Dockerfile } from './classes.dockerfile.js';
 import { DockerRegistry } from './classes.dockerregistry.js';
 import { RegistryStorage } from './classes.registrystorage.js';
-import type { ITsDockerConfig } from './interfaces/index.js';
+import type { ITsDockerConfig, IBuildCommandOptions } from './interfaces/index.js';
 
 const smartshellInstance = new plugins.smartshell.Smartshell({
   executor: 'bash',
@@ -90,9 +90,10 @@ export class TsDockerManager {
   }
 
   /**
-   * Builds all discovered Dockerfiles in dependency order
+   * Builds discovered Dockerfiles in dependency order.
+   * When options.patterns is provided, only matching Dockerfiles (and their dependencies) are built.
    */
-  public async build(): Promise<Dockerfile[]> {
+  public async build(options?: IBuildCommandOptions): Promise<Dockerfile[]> {
     if (this.dockerfiles.length === 0) {
       await this.discoverDockerfiles();
     }
@@ -102,16 +103,64 @@ export class TsDockerManager {
       return [];
     }
 
+    // Determine which Dockerfiles to build
+    let toBuild = this.dockerfiles;
+
+    if (options?.patterns && options.patterns.length > 0) {
+      // Filter to matching Dockerfiles
+      const matched = this.dockerfiles.filter((df) => {
+        const basename = plugins.path.basename(df.filePath);
+        return options.patterns!.some((pattern) => {
+          if (pattern.includes('*') || pattern.includes('?')) {
+            // Convert glob pattern to regex
+            const regexStr = '^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$';
+            return new RegExp(regexStr).test(basename);
+          }
+          return basename === pattern;
+        });
+      });
+
+      if (matched.length === 0) {
+        logger.log('warn', `No Dockerfiles matched patterns: ${options.patterns.join(', ')}`);
+        return [];
+      }
+
+      // Resolve dependency chain and preserve topological order
+      toBuild = this.resolveWithDependencies(matched, this.dockerfiles);
+      logger.log('info', `Matched ${matched.length} Dockerfile(s), building ${toBuild.length} (including dependencies)`);
+    }
+
     // Check if buildx is needed
-    if (this.config.platforms && this.config.platforms.length > 1) {
+    if (options?.platform || (this.config.platforms && this.config.platforms.length > 1)) {
       await this.ensureBuildx();
     }
 
-    logger.log('info', `Building ${this.dockerfiles.length} Dockerfiles...`);
-    await Dockerfile.buildDockerfiles(this.dockerfiles);
+    logger.log('info', `Building ${toBuild.length} Dockerfiles...`);
+    await Dockerfile.buildDockerfiles(toBuild, {
+      platform: options?.platform,
+      timeout: options?.timeout,
+      noCache: options?.noCache,
+    });
     logger.log('success', 'All Dockerfiles built successfully');
 
-    return this.dockerfiles;
+    return toBuild;
+  }
+
+  /**
+   * Resolves a set of target Dockerfiles to include all their local base image dependencies,
+   * preserving the original topological build order.
+   */
+  private resolveWithDependencies(targets: Dockerfile[], allSorted: Dockerfile[]): Dockerfile[] {
+    const needed = new Set<Dockerfile>();
+    const addWithDeps = (df: Dockerfile) => {
+      if (needed.has(df)) return;
+      needed.add(df);
+      if (df.localBaseImageDependent && df.localBaseDockerfile) {
+        addWithDeps(df.localBaseDockerfile);
+      }
+    };
+    for (const df of targets) addWithDeps(df);
+    return allSorted.filter((df) => needed.has(df));
   }
 
   /**

ts/interfaces/index.ts

@@ -68,3 +68,13 @@ export interface IPushResult {
   digest?: string;
   error?: string;
 }
+
+/**
+ * Options for the build command
+ */
+export interface IBuildCommandOptions {
+  patterns?: string[];  // Dockerfile name patterns (e.g., ['Dockerfile_base', 'Dockerfile_*'])
+  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)
+}

ts/tsdocker.cli.ts

@@ -7,6 +7,7 @@ import * as DockerModule from './tsdocker.docker.js';
 
 import { logger, ora } from './tsdocker.logging.js';
 import { TsDockerManager } from './classes.tsdockermanager.js';
+import type { IBuildCommandOptions } from './interfaces/index.js';
 
 const tsdockerCli = new plugins.smartcli.Smartcli();
 
@@ -23,14 +24,31 @@ export let run = () => {
   });
 
   /**
-   * Build all Dockerfiles in dependency order
+   * Build Dockerfiles in dependency order
+   * Usage: tsdocker build [Dockerfile_patterns...] [--platform=linux/arm64] [--timeout=600]
    */
   tsdockerCli.addCommand('build').subscribe(async argvArg => {
     try {
       const config = await ConfigModule.run();
       const manager = new TsDockerManager(config);
       await manager.prepare();
-      await manager.build();
+
+      const buildOptions: IBuildCommandOptions = {};
+      const patterns = argvArg._.slice(1) as string[];
+      if (patterns.length > 0) {
+        buildOptions.patterns = patterns;
+      }
+      if (argvArg.platform) {
+        buildOptions.platform = argvArg.platform as string;
+      }
+      if (argvArg.timeout) {
+        buildOptions.timeout = Number(argvArg.timeout);
+      }
+      if (argvArg.cache === false) {
+        buildOptions.noCache = true;
+      }
+
+      await manager.build(buildOptions);
       logger.log('success', 'Build completed successfully');
     } catch (err) {
       logger.log('error', `Build failed: ${(err as Error).message}`);
@@ -40,6 +58,7 @@ export let run = () => {
 
   /**
    * Push built images to configured registries
+   * Usage: tsdocker push [Dockerfile_patterns...] [--platform=linux/arm64] [--timeout=600] [--registry=url]
    */
   tsdockerCli.addCommand('push').subscribe(async argvArg => {
     try {
@@ -50,11 +69,27 @@ export let run = () => {
       // Login first
       await manager.login();
 
-      // Build images first (if not already built)
-      await manager.build();
+      // Parse build options from positional args and flags
+      const buildOptions: IBuildCommandOptions = {};
+      const patterns = argvArg._.slice(1) as string[];
+      if (patterns.length > 0) {
+        buildOptions.patterns = patterns;
+      }
+      if (argvArg.platform) {
+        buildOptions.platform = argvArg.platform as string;
+      }
+      if (argvArg.timeout) {
+        buildOptions.timeout = Number(argvArg.timeout);
+      }
+      if (argvArg.cache === false) {
+        buildOptions.noCache = true;
+      }
 
-      // Get registry from arguments if specified
-      const registryArg = argvArg._[1]; // e.g., tsdocker push registry.gitlab.com
+      // Build images first (if not already built)
+      await manager.build(buildOptions);
+
+      // Get registry from --registry flag
+      const registryArg = argvArg.registry as string | undefined;
       const registries = registryArg ? [registryArg] : undefined;
 
       await manager.push(registries);
@@ -101,7 +136,11 @@ export let run = () => {
       await manager.prepare();
 
       // Build images first
-      await manager.build();
+      const buildOptions: IBuildCommandOptions = {};
+      if (argvArg.cache === false) {
+        buildOptions.noCache = true;
+      }
+      await manager.build(buildOptions);
 
       // Run tests
       await manager.test();