@pushpalsdev/cli 1.0.17 → 1.0.18

package/dist/pushpals-cli.js

@@ -25,6 +25,41 @@ import { relative, resolve as resolve2 } from "path";
 import { existsSync, readFileSync } from "fs";
 import { join, resolve, isAbsolute } from "path";
 
+// ../shared/src/autonomy_policy.ts
+var DRIVE_RE = /^[A-Za-z]:\//;
+var SLASH_RE = /\/+/g;
+function normalizeAutonomyComponentArea(value) {
+  const normalized = normalizeRepoRelativePath(value);
+  if (!normalized)
+    return null;
+  return normalized;
+}
+function normalizeRepoRelativePath(value) {
+  if (typeof value !== "string")
+    return null;
+  let path = value.trim();
+  if (!path)
+    return null;
+  path = path.normalize("NFC").replace(/\\/g, "/");
+  if (path.startsWith("/"))
+    return null;
+  if (DRIVE_RE.test(path))
+    return null;
+  path = path.replace(SLASH_RE, "/");
+  const out = [];
+  for (const rawSegment of path.split("/")) {
+    const segment = rawSegment.trim();
+    if (!segment || segment === ".")
+      continue;
+    if (segment === "..")
+      return null;
+    out.push(segment);
+  }
+  if (out.length === 0)
+    return null;
+  return out.join("/");
+}
+
 // ../shared/src/local_network.ts
 var DEFAULT_LOCAL_LOOPBACK_HOST = "127.0.0.1";
 function isLoopbackHost(hostname) {
@@ -398,14 +433,26 @@ function loadPushPalsConfig(options = {}) {
     "tests/unit": 2
   };
   const remoteAutonomyDispatchByComponentRaw = asStringNumberRecord(remoteAutonomyNode.max_dispatch_per_hour_by_component);
-  const remoteAutonomyDispatchByComponent = {
-    ...remoteAutonomyDispatchByComponentCfg
+  const legacyAutonomyComponentAliasMap = new Map(Object.keys(remoteAutonomyDispatchByComponentCfg).flatMap((key) => {
+    const direct = normalizeAutonomyComponentArea(key);
+    const legacyUnderscore = normalizeAutonomyComponentArea(key.replace(/\//g, "_"));
+    const legacyHyphen = normalizeAutonomyComponentArea(key.replace(/\//g, "-"));
+    return [direct, legacyUnderscore, legacyHyphen].filter((value) => Boolean(value)).map((value) => [value, key]);
+  }));
+  const coerceAutonomyComponentConfigKey = (value) => {
+    const direct = normalizeAutonomyComponentArea(value);
+    const legacyAliasCandidate = normalizeAutonomyComponentArea(value.trim().toLowerCase().replace(/\\/g, "/").replace(/_+/g, "/").replace(/-+/g, "/").replace(/\/+/g, "/"));
+    if (legacyAliasCandidate && legacyAutonomyComponentAliasMap.has(legacyAliasCandidate)) {
+      return legacyAutonomyComponentAliasMap.get(legacyAliasCandidate) ?? legacyAliasCandidate;
+    }
+    return direct;
   };
-  const normalizeAutonomyComponentKey = (value) => value.trim().toLowerCase().replace(/\\/g, "/").replace(/_+/g, "/").replace(/-+/g, "/").replace(/\/+/g, "/");
-  const canonicalComponentByNormalized = new Map(Object.keys(remoteAutonomyDispatchByComponentCfg).map((key) => [normalizeAutonomyComponentKey(key), key]));
+  const remoteAutonomyDispatchByComponent = Object.fromEntries(Object.entries(remoteAutonomyDispatchByComponentCfg).map(([key, value]) => [
+    coerceAutonomyComponentConfigKey(key) ?? key,
+    value
+  ]));
   for (const [rawKey, rawValue] of Object.entries(remoteAutonomyDispatchByComponentRaw)) {
-    const normalized = normalizeAutonomyComponentKey(rawKey);
-    const canonical = canonicalComponentByNormalized.get(normalized);
+    const canonical = coerceAutonomyComponentConfigKey(rawKey);
     if (!canonical)
       continue;
     const parsed = typeof rawValue === "number" ? rawValue : typeof rawValue === "string" ? Number.parseInt(rawValue.trim(), 10) : Number.NaN;
@@ -1369,9 +1416,9 @@ function parsePositiveInt(value, fallback) {
 function jsonHtmlBootstrap(value) {
   return JSON.stringify(value).replace(/</g, "\\u003c");
 }
-async function runGitWithEnv(args, cwd, env) {
+async function runCommandWithEnv(command, cwd, env) {
   try {
-    const proc = Bun.spawn(["git", ...args], {
+    const proc = Bun.spawn(command, {
       cwd,
       env,
       stdout: "pipe",
@@ -1392,6 +1439,9 @@ async function runGitWithEnv(args, cwd, env) {
     };
   }
 }
+async function runGitWithEnv(args, cwd, env) {
+  return await runCommandWithEnv(["git", ...args], cwd, env);
+}
 async function runGit(args, cwd) {
   return await runGitWithEnv(args, cwd, {
     ...process.env,
@@ -1744,7 +1794,9 @@ function buildEmbeddedRuntimeEnv(baseEnv, opts) {
     PUSHPALS_PROTOCOL_SCHEMAS_DIR: join2(opts.runtimeRoot, "protocol", "schemas"),
     ...typeof opts.sessionId === "string" && opts.sessionId.trim() ? { PUSHPALS_SESSION_ID: opts.sessionId.trim() } : {},
     ...typeof env.PUSHPALS_GIT_BIN === "string" && env.PUSHPALS_GIT_BIN.trim() ? { PUSHPALS_GIT_BIN: env.PUSHPALS_GIT_BIN.trim() } : {},
-    ...typeof env.PUSHPALS_GIT_BIN_ABSOLUTE === "string" && env.PUSHPALS_GIT_BIN_ABSOLUTE.trim() ? { PUSHPALS_GIT_BIN_ABSOLUTE: env.PUSHPALS_GIT_BIN_ABSOLUTE.trim() } : {}
+    ...typeof env.PUSHPALS_GIT_BIN_ABSOLUTE === "string" && env.PUSHPALS_GIT_BIN_ABSOLUTE.trim() ? { PUSHPALS_GIT_BIN_ABSOLUTE: env.PUSHPALS_GIT_BIN_ABSOLUTE.trim() } : {},
+    ...typeof env.PUSHPALS_DOCKER_BIN === "string" && env.PUSHPALS_DOCKER_BIN.trim() ? { PUSHPALS_DOCKER_BIN: env.PUSHPALS_DOCKER_BIN.trim() } : {},
+    ...typeof env.PUSHPALS_DOCKER_BIN_ABSOLUTE === "string" && env.PUSHPALS_DOCKER_BIN_ABSOLUTE.trim() ? { PUSHPALS_DOCKER_BIN_ABSOLUTE: env.PUSHPALS_DOCKER_BIN_ABSOLUTE.trim() } : {}
   };
 }
 function normalizeChildProcessEnv(baseEnv, platform = process.platform) {
@@ -2020,6 +2072,19 @@ function applyResolvedGitBinaryToRuntimeEnv(env, resolvedGitBinary, platform = p
   }
   return env;
 }
+function applyResolvedDockerBinaryToRuntimeEnv(env, resolvedDockerBinary, platform = process.platform) {
+  const resolvedPath = String(resolvedDockerBinary ?? "").trim();
+  if (!resolvedPath)
+    return env;
+  prependExecutableDirToPath(env, resolvedPath, platform);
+  env.PUSHPALS_DOCKER_BIN = basename(resolvedPath);
+  if (resolvedPath.includes("/") || resolvedPath.includes("\\")) {
+    env.PUSHPALS_DOCKER_BIN_ABSOLUTE = resolvedPath;
+  } else {
+    delete env.PUSHPALS_DOCKER_BIN_ABSOLUTE;
+  }
+  return env;
+}
 function resolveRuntimeGitExecutableCandidates(env, platform = process.platform) {
   const candidates = [];
   const seen = new Set;
@@ -2039,6 +2104,25 @@ function resolveRuntimeGitExecutableCandidates(env, platform = process.platform)
   pushCandidate("git");
   return candidates;
 }
+function resolveRuntimeDockerExecutableCandidates(env, platform = process.platform) {
+  const candidates = [];
+  const seen = new Set;
+  const pushCandidate = (value) => {
+    const trimmed = String(value ?? "").trim();
+    if (!trimmed)
+      return;
+    const key = platform === "win32" ? trimmed.toLowerCase() : trimmed;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    candidates.push(trimmed);
+  };
+  pushCandidate(env.PUSHPALS_DOCKER_BIN ?? "");
+  pushCandidate(env.PUSHPALS_DOCKER_BIN_ABSOLUTE ?? "");
+  pushCandidate(platform === "win32" ? "docker.exe" : "docker");
+  pushCandidate("docker");
+  return candidates;
+}
 function resolveWindowsShellExecutableCandidatesForEnv(env, platform = process.platform) {
   if (platform !== "win32")
     return [];
@@ -2153,6 +2237,32 @@ async function resolveSourceControlManagerGitProbe(cwd, env, platform = process.
     detail: candidates.join(", ") || "git"
   };
 }
+async function resolveWorkerpalDockerProbe(cwd, env, platform = process.platform) {
+  const resolvedDockerBinary = await resolveCommandPath(platform === "win32" ? "docker.exe" : "docker", cwd, env);
+  if (resolvedDockerBinary) {
+    prependExecutableDirToPath(env, resolvedDockerBinary, platform);
+    env.PUSHPALS_DOCKER_BIN = basename(resolvedDockerBinary);
+    env.PUSHPALS_DOCKER_BIN_ABSOLUTE = resolvedDockerBinary;
+  }
+  const candidates = resolveRuntimeDockerExecutableCandidates(env, platform);
+  const failures = [];
+  for (const candidate of candidates) {
+    const result = await runCommandWithEnv([candidate, "version", "--format", "{{.Server.Version}}"], cwd, env);
+    if (result.ok) {
+      const version = result.stdout.trim();
+      return {
+        ok: true,
+        detail: version ? `${candidate} (${version})` : candidate
+      };
+    }
+    const detail = result.stderr || result.stdout || `exit ${result.exitCode}`;
+    failures.push(`${candidate}: ${detail}`);
+  }
+  return {
+    ok: false,
+    detail: failures.join(" | ") || "docker"
+  };
+}
 async function precheckSourceControlManagerGitAvailability(opts) {
   const platform = opts.platform ?? process.platform;
   const env = buildEmbeddedRuntimeEnv(opts.baseEnv ?? process.env, {
@@ -2161,8 +2271,9 @@ async function precheckSourceControlManagerGitAvailability(opts) {
     useRuntimeConfig: opts.preflightUsesEmbeddedRuntime,
     sessionId: opts.sessionId
   });
-  if (env.PUSHPALS_GIT_BIN) {
-    applyResolvedGitBinaryToRuntimeEnv(env, env.PUSHPALS_GIT_BIN, platform);
+  const preconfiguredGitBinary = env.PUSHPALS_GIT_BIN_ABSOLUTE ?? env.PUSHPALS_GIT_BIN;
+  if (preconfiguredGitBinary) {
+    applyResolvedGitBinaryToRuntimeEnv(env, preconfiguredGitBinary, platform);
   }
   const remoteStatus = opts.gitRemoteCheckFn ? await opts.gitRemoteCheckFn(opts.repoRoot, opts.remote, env) : opts.repoHasRemoteFn ? await opts.repoHasRemoteFn(opts.repoRoot, opts.remote) ? { status: "ok", remote: opts.remote } : { status: "missing_remote", remote: opts.remote } : await checkGitRemoteConfigured(opts.repoRoot, opts.remote, env);
   if (remoteStatus.status === "missing_remote") {
@@ -2198,6 +2309,55 @@ async function precheckSourceControlManagerGitAvailability(opts) {
     env
   };
 }
+async function precheckWorkerpalDockerAvailability(opts) {
+  const env = buildEmbeddedRuntimeEnv(opts.baseEnv ?? process.env, {
+    repoRoot: opts.repoRoot,
+    runtimeRoot: opts.runtimeRoot,
+    useRuntimeConfig: opts.preflightUsesEmbeddedRuntime,
+    sessionId: opts.sessionId
+  });
+  const preconfiguredDockerBinary = env.PUSHPALS_DOCKER_BIN_ABSOLUTE ?? env.PUSHPALS_DOCKER_BIN;
+  if (preconfiguredDockerBinary) {
+    applyResolvedDockerBinaryToRuntimeEnv(env, preconfiguredDockerBinary, opts.platform ?? process.platform);
+  }
+  if (!opts.autoSpawnWorkerpals) {
+    return {
+      status: "skipped",
+      detail: "WorkerPal auto-spawn is disabled",
+      env
+    };
+  }
+  if (!opts.dockerEnabled) {
+    return {
+      status: "skipped",
+      detail: "WorkerPal docker mode is disabled",
+      env
+    };
+  }
+  if (!opts.requireDocker) {
+    return {
+      status: "skipped",
+      detail: "WorkerPal docker mode is optional",
+      env
+    };
+  }
+  const dockerProbe = await (opts.dockerProbeFn ?? resolveWorkerpalDockerProbe)(opts.repoRoot, env, opts.platform ?? process.platform);
+  if (!dockerProbe.ok) {
+    return {
+      status: "failed",
+      detail: dockerProbe.detail,
+      env
+    };
+  }
+  return {
+    status: "ok",
+    detail: dockerProbe.detail,
+    env
+  };
+}
+function resolveWorkerpalCapacityTimeoutMs(config) {
+  return Math.max(config.remotebuddy.waitForWorkerpalMs, config.remotebuddy.workerpalStartupTimeoutMs, config.remotebuddy.workerpalDocker ? config.workerpals.dockerAgentStartupTimeoutMs + 15000 : 0, 1e4);
+}
 async function checkGitRemoteConfigured(repoRoot, remote, env) {
   const normalizedRemote = String(remote ?? "").trim();
   if (!normalizedRemote) {
@@ -2539,6 +2699,42 @@ async function probeSourceControlManager(port) {
     return false;
   }
 }
+async function fetchWorkerStatusRows(serverUrl, ttlMs) {
+  const payload = await fetchJsonWithTimeout(`${serverUrl}/workers?ttlMs=${Math.max(1000, Math.floor(ttlMs))}`, {}, 1e4);
+  if (!payload?.ok || !Array.isArray(payload.workers)) {
+    return [];
+  }
+  return payload.workers;
+}
+async function waitForWorkerpalCapacity(opts) {
+  const deadline = Date.now() + Math.max(1000, opts.timeoutMs);
+  let lastObservedOnline = 0;
+  while (Date.now() < deadline) {
+    const workers = await (opts.fetchWorkersFn ?? fetchWorkerStatusRows)(opts.serverUrl, opts.ttlMs);
+    const onlineWorkers = workers.filter((worker) => Boolean(worker?.isOnline) && String(worker?.status ?? "").trim().toLowerCase() !== "offline");
+    const idleWorkers = onlineWorkers.filter((worker) => Number(worker?.activeJobCount ?? 0) <= 0);
+    if (onlineWorkers.length > 0) {
+      lastObservedOnline = Math.max(lastObservedOnline, onlineWorkers.length);
+    }
+    if (idleWorkers.length > 0) {
+      return {
+        ok: true,
+        detail: `${idleWorkers.length} idle / ${onlineWorkers.length} online`
+      };
+    }
+    await (opts.sleepFn ?? Bun.sleep)(DEFAULT_RUNTIME_BOOT_POLL_MS);
+  }
+  if (lastObservedOnline > 0) {
+    return {
+      ok: false,
+      detail: `${lastObservedOnline} online WorkerPal(s) reported but none became idle within ${Math.max(1000, opts.timeoutMs)}ms`
+    };
+  }
+  return {
+    ok: false,
+    detail: `no online WorkerPal reported within ${Math.max(1000, opts.timeoutMs)}ms`
+  };
+}
 async function fetchWithTimeout(url, init = {}, timeoutMs = HTTP_TIMEOUT_MS) {
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -2624,15 +2820,20 @@ async function autoStartRuntimeServices(opts) {
   }
   await ensureRuntimeAssets(runtimeRoot, runtimeTag);
   const runtimeBinaries = await ensureRuntimeBinaries(runtimeRoot, runtimeTag);
-  const runtimeEnv = buildEmbeddedRuntimeEnv(process.env, {
+  const runtimeEnv = buildEmbeddedRuntimeEnv(opts.baseEnv ?? process.env, {
     repoRoot: opts.repoRoot,
     runtimeRoot,
     useRuntimeConfig: opts.preparedRuntime.preflightUsesEmbeddedRuntime,
     sessionId: opts.sessionId
   });
   runtimeEnv.PUSHPALS_WORKERPALS_BIN = runtimeBinaries.workerpals;
-  if (runtimeEnv.PUSHPALS_GIT_BIN) {
-    applyResolvedGitBinaryToRuntimeEnv(runtimeEnv, runtimeEnv.PUSHPALS_GIT_BIN);
+  const preconfiguredRuntimeGitBinary = runtimeEnv.PUSHPALS_GIT_BIN_ABSOLUTE ?? runtimeEnv.PUSHPALS_GIT_BIN;
+  if (preconfiguredRuntimeGitBinary) {
+    applyResolvedGitBinaryToRuntimeEnv(runtimeEnv, preconfiguredRuntimeGitBinary);
+  }
+  const preconfiguredRuntimeDockerBinary = runtimeEnv.PUSHPALS_DOCKER_BIN_ABSOLUTE ?? runtimeEnv.PUSHPALS_DOCKER_BIN;
+  if (preconfiguredRuntimeDockerBinary) {
+    applyResolvedDockerBinaryToRuntimeEnv(runtimeEnv, preconfiguredRuntimeDockerBinary);
   }
   const gitLookupCommand = typeof runtimeEnv.PUSHPALS_GIT_BIN === "string" && runtimeEnv.PUSHPALS_GIT_BIN.trim() ? runtimeEnv.PUSHPALS_GIT_BIN.trim() : "git";
   const resolvedGitBinary = await resolveCommandPath(gitLookupCommand, opts.repoRoot, runtimeEnv);
@@ -2720,6 +2921,24 @@ ${tail}` : ""}`);
     appendRuntimeServicesLogLine(runtimeServicesLogPath, "[pushpals] embedded remotebuddy autonomous engine is disabled (remotebuddy.autonomy.enabled=false).");
   };
   reportRemoteBuddyAutonomousEngineState();
+  if (runtimePreflight.config.remotebuddy.autoSpawnWorkerpals) {
+    const workerpalReadyTimeoutMs = resolveWorkerpalCapacityTimeoutMs(runtimePreflight.config);
+    const workerpalCapacity = await waitForWorkerpalCapacity({
+      serverUrl: opts.serverUrl,
+      timeoutMs: workerpalReadyTimeoutMs,
+      ttlMs: runtimePreflight.config.remotebuddy.workerpalOnlineTtlMs
+    });
+    if (!workerpalCapacity.ok) {
+      const tail = readLogTail(remotebuddyService.logPath);
+      appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded workerpal capacity did not become available within ${workerpalReadyTimeoutMs}ms.`);
+      stopRuntimeServices(services);
+      throw new Error(`Embedded WorkerPal capacity did not become available within ${workerpalReadyTimeoutMs}ms (${workerpalCapacity.detail}). ` + `See ${remotebuddyService.logPath}${tail ? `
+--- remotebuddy log tail ---
+${tail}` : ""}`);
+    }
+    console.log(`[pushpals] Embedded WorkerPal capacity is ready (${workerpalCapacity.detail}).`);
+    appendRuntimeServicesLogLine(runtimeServicesLogPath, `[pushpals] embedded workerpal capacity ready (${workerpalCapacity.detail}).`);
+  }
   const scmHealthy = await probeSourceControlManager(opts.sourceControlManagerPort);
   const scmGitProbe = await resolveSourceControlManagerGitProbe(opts.repoRoot, runtimeEnv, process.platform);
   const scmRemoteStatus = await checkGitRemoteConfigured(opts.repoRoot, opts.sourceControlManagerRemote, runtimeEnv);
@@ -3396,6 +3615,15 @@ async function main() {
     console.error(`[pushpals] Precheck failed: embedded SourceControlManager git command is unavailable (${scmGitPrecheck.detail}).`);
     process.exit(1);
   }
+  const workerpalDockerPrecheck = await precheckWorkerpalDockerAvailability({
+    repoRoot,
+    runtimeRoot: preparedRuntime.runtimeRoot,
+    preflightUsesEmbeddedRuntime: preparedRuntime.preflightUsesEmbeddedRuntime,
+    autoSpawnWorkerpals: Boolean(config.remotebuddy.autoSpawnWorkerpals),
+    dockerEnabled: Boolean(config.remotebuddy.workerpalDocker),
+    requireDocker: Boolean(config.remotebuddy.workerpalRequireDocker),
+    baseEnv: scmGitPrecheck.env
+  });
   const precheckPassed = await enforcePushpalsRemoteBranchPrecheck(repoRoot, config.sourceControlManager.remote, config.sourceControlManager.mainBranch);
   if (!precheckPassed) {
     process.exit(1);
@@ -3428,6 +3656,11 @@ async function main() {
   };
   if (!serverHealthy) {
     if (!parsed.noAutoStart) {
+      if (workerpalDockerPrecheck.status === "failed") {
+        console.error(`[pushpals] Precheck failed: Docker-backed WorkerPal auto-spawn is required but Docker is unavailable (${workerpalDockerPrecheck.detail}).`);
+        console.error("[pushpals] Precheck failed: start Docker Desktop or the Docker daemon, then retry pushpals.");
+        process.exit(1);
+      }
       try {
         const startedRuntime = await autoStartRuntimeServices({
           repoRoot,
@@ -3438,7 +3671,8 @@ async function main() {
           sourceControlManagerRemote: config.sourceControlManager.remote,
           preparedRuntime,
           requestedRuntimeTag: parsed.runtimeTag,
-          startLocalBuddy: resolveCliLocalBuddyAutostart(parsed.runtimeOnly, Boolean(config.localbuddy.enabled))
+          startLocalBuddy: resolveCliLocalBuddyAutostart(parsed.runtimeOnly, Boolean(config.localbuddy.enabled)),
+          baseEnv: workerpalDockerPrecheck.env
         });
         autoStartedServices = startedRuntime.services;
         pushpalsLogPath = startedRuntime.pushpalsLogPath;
@@ -3493,6 +3727,22 @@ async function main() {
     }
     process.exit(1);
   }
+  const workerpalCapacity = await waitForWorkerpalCapacity({
+    serverUrl,
+    timeoutMs: resolveWorkerpalCapacityTimeoutMs(config),
+    ttlMs: config.remotebuddy.workerpalOnlineTtlMs
+  });
+  if (!workerpalCapacity.ok) {
+    stopAutoStartedServices();
+    console.error(`[pushpals] WorkerPal capacity is not ready for repo ${repoRoot}: ${workerpalCapacity.detail}.`);
+    if (workerpalDockerPrecheck.status === "failed") {
+      console.error(`[pushpals] Docker precheck detail: ${workerpalDockerPrecheck.detail}`);
+    } else if (serverWasAlreadyHealthy) {
+      console.error("[pushpals] A PushPals runtime is already serving this repo, but it does not currently have an idle WorkerPal available.");
+      console.error("[pushpals] Wait for a worker to become idle or restart the runtime after fixing WorkerPal startup.");
+    }
+    process.exit(1);
+  }
   const saved = statePath ? readCliState(statePath) : {};
   pushpalsLogPath = pushpalsLogPath || (typeof saved.pushpalsLogPath === "string" ? saved.pushpalsLogPath : undefined);
   const preferredHubUrl = normalizeUrl(parsed.monitoringHubUrl ?? process.env.PUSHPALS_MONITOR_URL ?? saved.monitoringHubUrl ?? "");
@@ -3667,10 +3917,12 @@ if (import.meta.main) {
   });
 }
 export {
+  waitForWorkerpalCapacity,
   startEmbeddedMonitoringHub,
   resolveWindowsWhereExecutableCandidatesForEnv,
   resolveWindowsShellExecutableCandidatesForEnv,
   resolveRuntimeGitExecutableCandidates,
+  resolveRuntimeDockerExecutableCandidates,
   resolvePreferredRuntimeReleaseTag,
   resolveCommandPath,
   resolveCliStatePath,
@@ -3678,6 +3930,7 @@ export {
   resolveBundledRuntimeAssetSource,
   resolveBundledMonitoringHubRoot,
   prepareCliRuntime,
+  precheckWorkerpalDockerAvailability,
   precheckSourceControlManagerGitAvailability,
   normalizeRepoPathForComparison,
   normalizeCliInteractiveMessage,
@@ -3695,5 +3948,6 @@ export {
   buildEmbeddedRuntimeEnv,
   buildEmbeddedMonitoringHubHtml,
   buildCliClearTargets,
-  applyResolvedGitBinaryToRuntimeEnv
+  applyResolvedGitBinaryToRuntimeEnv,
+  applyResolvedDockerBinaryToRuntimeEnv
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushpalsdev/cli",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "description": "PushPals terminal CLI for LocalBuddy -> RemoteBuddy orchestration",
   "license": "MIT",
   "repository": {