fix: move blacksmith testbox sync guard into crabbox

Author: steipete

CHANGELOG.md

@@ -13,6 +13,7 @@
 ### Changed
 
 - Aligned direct GCP provisioning with Google's official Compute Go SDK (`cloud.google.com/go/compute/apiv1`) and project-wide aggregated instance discovery.
+- Moved OpenClaw Blacksmith Testbox run safeguards into Crabbox, including one-shot slug reporting and stalled sync termination.
 - Improved `crabbox media preview` and `artifacts collect --gif` defaults to generate higher-quality 1000px/24fps GIFs with Floyd-Steinberg palette dithering and optional gifsicle optimization. Thanks @obviyus.
 
 ### Fixed

docs/providers/blacksmith-testbox.md

@@ -19,6 +19,19 @@ when Crabbox must own SSH sync and interactive access.
 
 ## Commands
 
+One-shot run:
+
+```sh
+crabbox run \
+  --provider blacksmith-testbox \
+  --blacksmith-org openclaw \
+  --blacksmith-workflow .github/workflows/ci-check-testbox.yml \
+  --blacksmith-job test \
+  --blacksmith-ref main \
+  --timing-json \
+  -- pnpm test
+```
+
 Reuse an existing Testbox:
 
 ```sh
@@ -84,6 +97,13 @@ Daytona until Blacksmith service, billing, or org limits are healthy again.
 
 Crabbox stores a per-Testbox SSH key locally, claims the Testbox for the current
 repo, maps IDs to friendly slugs, and prints a normal Crabbox timing summary.
+One-shot runs clean up the local claim/key and stop the Testbox after command
+completion unless `--keep` is set.
+
+Crabbox terminates a local Blacksmith CLI invocation that remains in the sync
+phase for five minutes without post-sync output. Set
+`CRABBOX_BLACKSMITH_SYNC_TIMEOUT_MS=0` to disable the guard, or set a larger
+millisecond value for intentionally huge local diffs.
 
 When coordinator auth is configured, `crabbox list --provider blacksmith-testbox`
 also syncs visibility-only Testbox rows into the portal lease table. If Crabbox

internal/providers/blacksmith/backend.go

@@ -5,7 +5,9 @@ import (
 	"flag"
 	"fmt"
 	"io"
+	"os"
 	"strings"
+	"sync"
 	"time"
 
 	core "github.com/openclaw/crabbox/internal/cli"
@@ -94,10 +96,11 @@ func (b *blacksmithBackend) Run(ctx context.Context, req RunRequest) (RunResult,
 	}
 	started := b.rt.Clock.Now()
 	leaseID := req.ID
+	slug := ""
 	acquired := false
 	var err error
 	if leaseID == "" {
-		leaseID, _, err = b.warmupLease(ctx, req.Repo, req.Reclaim)
+		leaseID, slug, err = b.warmupLease(ctx, req.Repo, req.Reclaim)
 		if err != nil {
 			return RunResult{}, err
 		}
@@ -107,7 +110,7 @@ func (b *blacksmithBackend) Run(ctx context.Context, req RunRequest) (RunResult,
 		if err != nil {
 			return RunResult{}, err
 		}
-		slug, err := blacksmithClaimSlug(req.ID, leaseID)
+		slug, err = blacksmithClaimSlug(req.ID, leaseID)
 		if err != nil {
 			return RunResult{}, err
 		}
@@ -135,6 +138,7 @@ func (b *blacksmithBackend) Run(ctx context.Context, req RunRequest) (RunResult,
 		if err := writeTimingJSON(b.rt.Stderr, timingReport{
 			Provider:      blacksmithTestboxProvider,
 			LeaseID:       leaseID,
+			Slug:          slug,
 			SyncPhases:    []timingPhase{{Name: "delegated", Skipped: true, Reason: "blacksmith-testbox owns sync"}},
 			SyncDelegated: true,
 			CommandMs:     commandDuration.Milliseconds(),
@@ -263,7 +267,16 @@ func (b *blacksmithBackend) runTestbox(ctx context.Context, leaseID string, comm
 		return 2
 	}
 	args := blacksmithRunArgs(b.cfg, leaseID, keyPath, command, debug || b.cfg.Blacksmith.Debug, shellMode)
-	result, err := b.runCommand(ctx, args, b.rt.Stdout, b.rt.Stderr)
+	result, timedOut, err := b.runCommandWithSyncGuard(ctx, args, b.rt.Stdout, b.rt.Stderr)
+	if timedOut {
+		fmt.Fprintf(
+			b.rt.Stderr,
+			"Blacksmith Testbox sync produced no post-sync output for %s; terminating local runner. "+
+				"Rerun with CRABBOX_BLACKSMITH_SYNC_TIMEOUT_MS=0 to disable this guard.\n",
+			blacksmithSyncTimeout(os.Getenv),
+		)
+		return 124
+	}
 	if err != nil {
 		return result.ExitCode
 	}
@@ -286,6 +299,95 @@ func (b *blacksmithBackend) runCommand(ctx context.Context, args []string, stdou
 	return result, nil
 }
 
+func (b *blacksmithBackend) runCommandWithSyncGuard(ctx context.Context, args []string, stdout, stderr io.Writer) (LocalCommandResult, bool, error) {
+	timeout := blacksmithSyncTimeout(os.Getenv)
+	if timeout <= 0 {
+		result, err := b.runCommand(ctx, args, stdout, stderr)
+		return result, false, err
+	}
+	guardCtx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	tracker := &blacksmithSyncTracker{}
+	resultCh := make(chan struct {
+		result LocalCommandResult
+		err    error
+	}, 1)
+	go func() {
+		result, err := b.runCommand(
+			guardCtx,
+			args,
+			blacksmithSyncGuardWriter{w: stdout, tracker: tracker},
+			blacksmithSyncGuardWriter{w: stderr, tracker: tracker},
+		)
+		resultCh <- struct {
+			result LocalCommandResult
+			err    error
+		}{result: result, err: err}
+	}()
+	ticker := time.NewTicker(minBlacksmithDuration(timeout, time.Second))
+	defer ticker.Stop()
+	timedOut := false
+	for {
+		select {
+		case result := <-resultCh:
+			return result.result, timedOut, result.err
+		case <-ticker.C:
+			if !tracker.syncStalled(timeout, b.rt.Clock.Now()) {
+				continue
+			}
+			timedOut = true
+			cancel()
+		}
+	}
+}
+
+type blacksmithSyncTracker struct {
+	mu           sync.Mutex
+	syncingSince time.Time
+}
+
+func (t *blacksmithSyncTracker) observe(text string, now time.Time) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if strings.Contains(text, "Syncing...") {
+		if t.syncingSince.IsZero() {
+			t.syncingSince = now
+		}
+		return
+	}
+	if !t.syncingSince.IsZero() && blacksmithPostSyncPattern.MatchString(text) {
+		t.syncingSince = time.Time{}
+	}
+}
+
+func (t *blacksmithSyncTracker) syncStalled(timeout time.Duration, now time.Time) bool {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	return !t.syncingSince.IsZero() && now.Sub(t.syncingSince) >= timeout
+}
+
+type blacksmithSyncGuardWriter struct {
+	w       io.Writer
+	tracker *blacksmithSyncTracker
+}
+
+func (w blacksmithSyncGuardWriter) Write(chunk []byte) (int, error) {
+	if w.tracker != nil {
+		w.tracker.observe(string(chunk), time.Now())
+	}
+	if w.w == nil {
+		return len(chunk), nil
+	}
+	return w.w.Write(chunk)
+}
+
+func minBlacksmithDuration(left, right time.Duration) time.Duration {
+	if left < right {
+		return left
+	}
+	return right
+}
+
 func (b *blacksmithBackend) listIDsBestEffort(ctx context.Context) map[string]bool {
 	out, err := b.commandOutput(ctx, blacksmithListAllArgs(b.cfg))
 	if err != nil {

internal/providers/blacksmith/backend_test.go

@@ -1,6 +1,7 @@
 package blacksmith
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"io"
@@ -29,6 +30,16 @@ func (r *blacksmithFuncRunner) Run(_ context.Context, req LocalCommandRequest) (
 	return LocalCommandResult{}, nil
 }
 
+type blockingSyncRunner struct{}
+
+func (blockingSyncRunner) Run(ctx context.Context, req LocalCommandRequest) (LocalCommandResult, error) {
+	if req.Stdout != nil {
+		_, _ = req.Stdout.Write([]byte("Syncing... waiting for remote workspace\n"))
+	}
+	<-ctx.Done()
+	return LocalCommandResult{ExitCode: 1}, ctx.Err()
+}
+
 func newTestBlacksmithBackend(cfg Config, runner CommandRunner) *blacksmithBackend {
 	return &blacksmithBackend{
 		spec: Provider{}.Spec(),
@@ -285,6 +296,34 @@ func TestBlacksmithOneShotRunRemovesClaimAfterStop(t *testing.T) {
 	}
 }
 
+func TestBlacksmithRunTerminatesSyncStall(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("XDG_CONFIG_HOME", filepath.Join(home, ".config"))
+	t.Setenv("CRABBOX_BLACKSMITH_SYNC_TIMEOUT_MS", "1")
+	if _, _, err := ensureTestboxKey("tbx_syncstall"); err != nil {
+		t.Fatal(err)
+	}
+	var stderr bytes.Buffer
+	backend := &blacksmithBackend{
+		spec: Provider{}.Spec(),
+		cfg:  baseConfig(),
+		rt: Runtime{
+			Stdout: io.Discard,
+			Stderr: &stderr,
+			Clock:  testClock{},
+			Exec:   blockingSyncRunner{},
+		},
+	}
+	code := backend.runTestbox(context.Background(), "tbx_syncstall", []string{"pnpm", "test"}, false, false)
+	if code != 124 {
+		t.Fatalf("exit=%d want 124", code)
+	}
+	if !strings.Contains(stderr.String(), "Blacksmith Testbox sync produced no post-sync output") {
+		t.Fatalf("stderr=%q", stderr.String())
+	}
+}
+
 func TestBlacksmithBackendUsesInjectedCommandRunnerForListAndStatus(t *testing.T) {
 	runner := &blacksmithFuncRunner{fn: func(LocalCommandRequest) (LocalCommandResult, error) {
 		return LocalCommandResult{

internal/providers/blacksmith/helpers.go

@@ -4,6 +4,7 @@ import (
 	"flag"
 	"fmt"
 	"regexp"
+	"strconv"
 	"strings"
 	"time"
 
@@ -14,6 +15,7 @@ const blacksmithTestboxProvider = "blacksmith-testbox"
 
 var (
 	blacksmithIDPattern       = regexp.MustCompile(`\btbx_[A-Za-z0-9_-]+\b`)
+	blacksmithPostSyncPattern = regexp.MustCompile(`(?i)\b(running|executing|command|pnpm|npm|yarn|bun)\b`)
 	blacksmithCleanupAttempts = 36
 	blacksmithCleanupDelay    = 5 * time.Second
 	blacksmithCleanupQuiet    = 12
@@ -191,6 +193,20 @@ func parseBlacksmithID(output string) string {
 	return blacksmithIDPattern.FindString(output)
 }
 
+func blacksmithSyncTimeout(env func(string) string) time.Duration {
+	for _, key := range []string{"CRABBOX_BLACKSMITH_SYNC_TIMEOUT_MS", "OPENCLAW_TESTBOX_SYNC_TIMEOUT_MS"} {
+		raw := strings.TrimSpace(env(key))
+		if raw == "" {
+			continue
+		}
+		parsed, err := strconv.Atoi(raw)
+		if err == nil && parsed >= 0 {
+			return time.Duration(parsed) * time.Millisecond
+		}
+	}
+	return 5 * time.Minute
+}
+
 func resolveBlacksmithLeaseID(identifier, repoRoot string, reclaim bool) (string, error) {
 	if identifier == "" {
 		return "", exit(2, "blacksmith-testbox requires --id <tbx-id-or-slug>")