@pushpalsdev/cli 1.0.51 → 1.0.52

package/dist/pushpals-cli.js

@@ -3048,6 +3048,44 @@ async function cleanupLingeringWorkerpalWarmContainers(opts) {
     removed: containerIds.length
   };
 }
+async function cleanupLocalWorkerpalSandboxImage(opts) {
+  const imageName = String(opts.dockerImage ?? "").trim();
+  if (!imageName) {
+    return {
+      ok: true,
+      detail: "no local WorkerPal sandbox image configured",
+      removed: false,
+      imageName: ""
+    };
+  }
+  const runCommandWithEnvFn = opts.runCommandWithEnvFn ?? runCommandWithEnv;
+  const commandTimeoutMs = typeof opts.commandTimeoutMs === "number" && Number.isFinite(opts.commandTimeoutMs) ? Math.max(1, Math.floor(opts.commandTimeoutMs)) : WORKERPAL_IMAGE_INSPECT_TIMEOUT_MS;
+  const dockerExecutable = resolveConfiguredDockerExecutable(opts.env, opts.platform ?? process.platform);
+  const remove = await runCommandWithEnvFn([dockerExecutable, "image", "rm", "-f", imageName], opts.repoRoot, opts.env, commandTimeoutMs);
+  if (!remove.ok) {
+    const detail = remove.stderr || remove.stdout || `exit ${remove.exitCode}`;
+    if (isMissingDockerImageDetail(detail)) {
+      return {
+        ok: true,
+        detail: `no local WorkerPal sandbox image found for ${imageName}`,
+        removed: false,
+        imageName
+      };
+    }
+    return {
+      ok: false,
+      detail: `failed to remove local WorkerPal sandbox image ${imageName}: ${detail}`,
+      removed: false,
+      imageName
+    };
+  }
+  return {
+    ok: true,
+    detail: `removed local WorkerPal sandbox image ${imageName}`,
+    removed: true,
+    imageName
+  };
+}
 async function cleanupLingeringPushPalsGitWorktrees(opts) {
   const runCommandWithEnvFn = opts.runCommandWithEnvFn ?? runCommandWithEnv;
   const forceDeleteWorktreePathFn = opts.forceDeleteWorktreePathFn ?? forceDeleteWorktreePath;
@@ -3564,6 +3602,36 @@ async function clearPushpalsState(opts) {
   for (const target of missing) {
     console.log(`[pushpals] Nothing to clear for ${target.label}: ${target.path}`);
   }
+  if (opts.config.remotebuddy.workerpalDocker || opts.config.remotebuddy.workerpalRequireDocker) {
+    const dockerEnv = normalizeChildProcessEnv(process.env);
+    const warmCleanup = await cleanupLingeringWorkerpalWarmContainers({
+      repoRoot: opts.repoRoot,
+      env: dockerEnv
+    });
+    if (warmCleanup.ok) {
+      console.log(warmCleanup.removed > 0 ? `[pushpals] Cleared WorkerPal warm containers: ${warmCleanup.detail}` : `[pushpals] Nothing to clear for WorkerPal warm containers: ${warmCleanup.detail}`);
+    } else {
+      failed.push({
+        label: "WorkerPal warm containers",
+        path: opts.repoRoot,
+        detail: warmCleanup.detail
+      });
+    }
+    const imageCleanup = await cleanupLocalWorkerpalSandboxImage({
+      repoRoot: opts.repoRoot,
+      env: dockerEnv,
+      dockerImage: opts.config.remotebuddy.workerpalImage ?? opts.config.workerpals.dockerImage
+    });
+    if (imageCleanup.ok) {
+      console.log(imageCleanup.removed ? `[pushpals] Cleared WorkerPal sandbox image: ${imageCleanup.imageName}` : `[pushpals] Nothing to clear for WorkerPal sandbox image: ${imageCleanup.detail}`);
+    } else {
+      failed.push({
+        label: "WorkerPal sandbox image",
+        path: imageCleanup.imageName || opts.repoRoot,
+        detail: imageCleanup.detail
+      });
+    }
+  }
   for (const failure of failed) {
     console.error(`[pushpals] Failed to clear ${failure.label}: ${failure.path} (${failure.detail})`);
   }
@@ -5276,6 +5344,7 @@ export {
   createSessionEventReplayFilter,
   copyTrackedRepoPath,
   computeEmbeddedServiceRestartBackoffMs,
+  cleanupLocalWorkerpalSandboxImage,
   cleanupLingeringWorkerpalWarmContainers,
   cleanupLingeringPushPalsGitWorktrees,
   bundledMonitoringHubNeedsRefresh,

package/package.json

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

package/runtime/sandbox/apps/workerpals/src/backends/openai_codex/test_openai_codex_runtime_config.py

@@ -1,4 +1,5 @@
 import os
+import re
 import sys
 import unittest
 import tempfile
@@ -10,7 +11,13 @@ for path in (_HERE, _SHARED):
     if str(path) not in sys.path:
         sys.path.insert(0, str(path))
 
-from executor_base import SettingsResolver, config_dir_for_runtime_config, runtime_config
+from executor_base import (
+    LOGGER_STANDARD_METHODS,
+    Logger,
+    SettingsResolver,
+    config_dir_for_runtime_config,
+    runtime_config,
+)
 from openai_codex_executor import (
     OpenAICodexRuntimeConfig,
     _augment_supplemental_guidance,
@@ -225,6 +232,37 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
             "Get-ChildItem src",
         )
 
+    def test_logger_supports_warning_alias_used_by_recovery_paths(self) -> None:
+        logger = Logger("[test]")
+        self.assertTrue(callable(getattr(logger, "warn", None)))
+        self.assertTrue(callable(getattr(logger, "warning", None)))
+
+    def test_logger_supports_standard_backend_method_surface(self) -> None:
+        logger = Logger("[test]")
+        for method_name in LOGGER_STANDARD_METHODS:
+            self.assertTrue(
+                callable(getattr(logger, method_name, None)),
+                f"Logger is missing required method: {method_name}",
+            )
+
+    def test_backend_log_method_usage_matches_shared_logger_contract(self) -> None:
+        backend_root = _HERE.parent
+        method_pattern = re.compile(r"\blog\.(\w+)\(")
+        used_methods = set()
+        for path in backend_root.rglob("*.py"):
+            if path.name.startswith("test_"):
+                continue
+            text = path.read_text(encoding="utf-8")
+            used_methods.update(method_pattern.findall(text))
+
+        self.assertTrue(used_methods, "Expected to discover backend logger usage")
+        unsupported = sorted(method for method in used_methods if method not in LOGGER_STANDARD_METHODS)
+        self.assertEqual(
+            unsupported,
+            [],
+            f"Backend code uses logger method(s) not covered by executor_base.Logger: {unsupported}",
+        )
+
     def test_augments_guidance_with_direct_command_policy_once(self) -> None:
         guidance = _augment_supplemental_guidance(["Run bun test tests/example.test.ts"])
         self.assertGreaterEqual(len(guidance), 2)

package/runtime/sandbox/apps/workerpals/src/backends/shared/executor_base.py

@@ -14,6 +14,7 @@ import os
 import re
 import subprocess
 import sys
+import traceback
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Set, Tuple
@@ -50,6 +51,15 @@ KNOWN_LITELLM_PROVIDER_PREFIXES: Set[str] = {
 }
 
 DEFAULT_TOOLCALL_RETRY_MAX = 1
+LOGGER_STANDARD_METHODS: Tuple[str, ...] = (
+    "debug",
+    "info",
+    "warn",
+    "warning",
+    "error",
+    "exception",
+    "critical",
+)
 
 # Superset of signals from both executors indicating the model failed to
 # emit tool calls / tool actions.
@@ -100,12 +110,43 @@ class Logger:
     def __init__(self, prefix: str) -> None:
         self.prefix = prefix
 
-    def info(self, message: str) -> None:
-        executor_log(f"{self.prefix} {message}")
+    def _coerce_message(self, message: Any, args: Tuple[Any, ...]) -> str:
+        text = str(message)
+        if not args:
+            return text
+        try:
+            return text % args
+        except Exception:
+            pieces = [text, *(str(arg) for arg in args)]
+            return " ".join(piece for piece in pieces if piece)
+
+    def _emit(self, _level: str, message: Any, *args: Any) -> None:
+        executor_log(f"{self.prefix} {self._coerce_message(message, args)}")
 
-    def debug(self, message: str) -> None:
+    def info(self, message: Any, *args: Any) -> None:
+        self._emit("info", message, *args)
+
+    def debug(self, message: Any, *args: Any) -> None:
         if _debug_enabled():
-            executor_log(f"{self.prefix} {message}")
+            self._emit("debug", message, *args)
+
+    def warn(self, message: Any, *args: Any) -> None:
+        self._emit("warn", message, *args)
+
+    def warning(self, message: Any, *args: Any) -> None:
+        self.warn(message, *args)
+
+    def error(self, message: Any, *args: Any) -> None:
+        self._emit("error", message, *args)
+
+    def critical(self, message: Any, *args: Any) -> None:
+        self._emit("critical", message, *args)
+
+    def exception(self, message: Any, *args: Any, exc_info: Any = True) -> None:
+        detail = self._coerce_message(message, args)
+        if exc_info:
+            detail = f"{detail}\n{traceback.format_exc().strip()}"
+        self._emit("exception", detail)
 
 
 def fail(summary: str, stderr: Optional[str] = None, exit_code: int = 1) -> int:

package/runtime/sandbox/apps/workerpals/src/execute_job.ts

@@ -2042,6 +2042,126 @@ async function activeGitOperation(repo: string): Promise<"rebase" | "merge" | "c
   return null;
 }
 
+export async function resumePreparedMergeConflictRebase(
+  repo: string,
+  kind: string,
+  params?: Record<string, unknown>,
+  onLog?: (stream: "stdout" | "stderr", line: string) => void,
+): Promise<
+  | { ok: true; resumed: boolean; sequencer: "rebase" | "merge" | "cherry-pick" | null; detail?: string }
+  | { ok: false; error: string }
+> {
+  const sequencer = await activeGitOperation(repo);
+  if (sequencer !== "rebase") {
+    return { ok: true, resumed: false, sequencer };
+  }
+
+  const unresolved = await git(repo, ["diff", "--name-only", "--diff-filter=U"]);
+  if (!unresolved.ok) {
+    return {
+      ok: false,
+      error: `Failed to inspect unresolved merge-conflict paths: ${combinedGitOutput(unresolved)}`,
+    };
+  }
+  const unresolvedPaths = parseChangedPathsFromNameOnlyOutput(unresolved.stdout);
+  if (unresolvedPaths.length > 0) {
+    const stillMarked = unresolvedPaths.filter((relativePath) => {
+      try {
+        const contents = readFileSync(resolve(repo, relativePath), "utf8");
+        return /^(<{7}|={7}|>{7})( .*)?$/m.test(contents);
+      } catch {
+        return true;
+      }
+    });
+    if (stillMarked.length > 0) {
+      return {
+        ok: true,
+        resumed: false,
+        sequencer,
+        detail: `rebase still has ${stillMarked.length} unresolved conflict marker file(s)`,
+      };
+    }
+    onLog?.(
+      "stdout",
+      `[MergeConflict] Found ${unresolvedPaths.length} resolved-but-unstaged conflict file(s); staging them before continuing the rebase.`,
+    );
+  }
+
+  let stageResult: { ok: boolean; stdout: string; stderr: string };
+  const stageArgs = buildStageCommand(kind, params);
+  if (stageArgs) {
+    stageResult = await git(repo, stageArgs);
+    if (!stageResult.ok) {
+      const stageErr = stageResult.stderr || stageResult.stdout;
+      if (
+        /pathspec .* did not match any files/i.test(stageErr) ||
+        /invalid path/i.test(stageErr) ||
+        /outside repository/i.test(stageErr)
+      ) {
+        onLog?.(
+          "stdout",
+          `[MergeConflict] Stage target invalid/missing for ${kind}; retrying with fallback "git add -A".`,
+        );
+        stageResult = await git(repo, [
+          "add",
+          "-A",
+          "--",
+          ".",
+          ":(exclude)workspace/**",
+          ":(exclude)outputs/**",
+        ]);
+      }
+    }
+  } else {
+    stageResult = await git(repo, [
+      "add",
+      "-A",
+      "--",
+      ".",
+      ":(exclude)workspace/**",
+      ":(exclude)outputs/**",
+    ]);
+  }
+  if (!stageResult.ok) {
+    return {
+      ok: false,
+      error:
+        "Failed to stage resolved merge-conflict changes before continuing rebase: " +
+        combinedGitOutput(stageResult),
+    };
+  }
+
+  let rebaseContinue = await git(repo, ["-c", "core.editor=true", "rebase", "--continue"]);
+  let continueOutput = combinedGitOutput(rebaseContinue);
+  if (!rebaseContinue.ok && isRebaseEditorPromptOutput(continueOutput)) {
+    rebaseContinue = await git(repo, ["-c", "core.editor=true", "rebase", "--continue"]);
+    continueOutput = combinedGitOutput(rebaseContinue);
+  }
+  if (!rebaseContinue.ok) {
+    return {
+      ok: false,
+      error: `Failed to continue prepared merge-conflict rebase: ${continueOutput}`,
+    };
+  }
+
+  const remainingSequencer = await activeGitOperation(repo);
+  if (!remainingSequencer) {
+    onLog?.(
+      "stdout",
+      "[MergeConflict] Auto-continued the prepared rebase after the executor returned with no unresolved conflicts.",
+    );
+  }
+  return {
+    ok: true,
+    resumed: true,
+    sequencer: remainingSequencer,
+    detail:
+      remainingSequencer === "rebase"
+        ? "rebase advanced but another continuation step is still required"
+        : undefined,
+  };
+}
+
 async function isAncestorRef(repo: string, ancestor: string, descendant: string): Promise<boolean> {
   const result = await git(repo, ["merge-base", "--is-ancestor", ancestor, descendant]);
   return result.ok;
@@ -3409,7 +3529,18 @@ export async function executeJob(
     );
     if (!result.ok) return result;
     if (mergeConflictContext) {
-      const sequencer = await activeGitOperation(repo);
+      const resume = await resumePreparedMergeConflictRebase(repo, kind, attemptParams, onLog);
+      if (!resume.ok) {
+        onLog?.("stderr", `[MergeConflict] ${resume.error}`);
+        return {
+          ok: false,
+          summary: "Merge-conflict rebase continuation failed",
+          stdout: result.stdout,
+          stderr: [result.stderr ?? "", resume.error].filter(Boolean).join("\n"),
+          exitCode: 4,
+        };
+      }
+      const sequencer = resume.sequencer;
       if (sequencer) {
         const detail =
           `Merge-conflict job returned with git ${sequencer} still in progress. ` +