smart_box 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdd527c54db2a72e0d40528a4fb248a712f06a8f28bd11e7b81c995963e1a4e1
-  data.tar.gz: b277525806bbccc5ad7a979733d0e9fcaa7ad483f8c8910e5d5105ea78f94712
+  metadata.gz: c0b203b0fd0f6c0c5b2736ac7249ed7d2cca87fa8ea7e457384082f96acbeae8
+  data.tar.gz: 22aa9f3e46150e1c2c787c9b5de6c094bfe3b85e3bf556ace43ee10f84a9061e
 SHA512:
-  metadata.gz: 61675f220c4dda1cae98b9091201057351b9abd65dfe4d4c4c906aa4be4e926e0091619079034a88fdb8209c17e7fc434014b432bb8397b869fcddd413c40ca2
-  data.tar.gz: b14f1b4116d23c01e540eac1275a5048e8decc279034ee33fde8f5b374314402fb2ec0a291a20762cef9e553a1c992425bdb9c19509f2b7bc51ec21371b8c268
+  metadata.gz: d2a894d704e2db93123bfb1a5d63fcfd643e33667760e1e0a5d1fdce0508d79f6e5d62802e1fb504ae668889b71e8b142b6a6a9f3faf6f18f96102b274d08541
+  data.tar.gz: 256bc4f7134d0356df2318602c8798434f84b089c5e8b601a309bb5b786ac9c1fb5191406c22c064a8d9f05d01fde797b2c834583495ac41b5a387757a0b2f68

data/lib/smart_box/box.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "time"
+require "open3"
 require_relative "errors"
 require_relative "metadata"
 require_relative "modes/copy_mode"
@@ -127,12 +128,11 @@ module SmartBox
     def git_status_short
       return [] unless Dir.exist?(@workspace_path)
 
-      Dir.chdir(@workspace_path) do
-        out = `git status --porcelain 2>/dev/null`
-        return [] unless $?.success?
+      out, _err, status = Open3.capture3("git", "status", "--porcelain",
+                                         chdir: @workspace_path)
+      return [] unless status.success?
 
-        out.lines.map(&:chomp).reject(&:empty?)
-      end
+      out.lines.map(&:chomp).reject(&:empty?)
     end
 
     def run(command, env: {}, timeout: nil, allow_dangerous: false)
@@ -149,10 +149,9 @@ module SmartBox
     def checkpoint(name)
       raise Error, "Workspace does not exist" unless Dir.exist?(@workspace_path)
 
-      Dir.chdir(@workspace_path) do
-        system("git", "add", "-A", out: File::NULL, err: File::NULL)
-        system("git", "commit", "--allow-empty", "-m", name, out: File::NULL, err: File::NULL)
-      end
+      system("git", "add", "-A", chdir: @workspace_path, out: File::NULL, err: File::NULL)
+      system("git", "commit", "--allow-empty", "-m", name,
+             chdir: @workspace_path, out: File::NULL, err: File::NULL)
 
       commit = git_latest_commit
       cp_id = "cp-#{format('%03d', (@metadata.checkpoints.size + 1))}"
@@ -181,10 +180,10 @@ module SmartBox
       cp = @metadata.checkpoints.detect { |c| c["id"] == checkpoint_id }
       raise CheckpointNotFoundError, "Checkpoint '#{checkpoint_id}' not found" unless cp
 
-      Dir.chdir(@workspace_path) do
-        system("git", "reset", "--hard", cp["git_commit"], out: File::NULL, err: File::NULL)
-        system("git", "clean", "-fd", out: File::NULL, err: File::NULL)
-      end
+      system("git", "reset", "--hard", cp["git_commit"],
+             chdir: @workspace_path, out: File::NULL, err: File::NULL)
+      system("git", "clean", "-fd",
+             chdir: @workspace_path, out: File::NULL, err: File::NULL)
 
       @metadata.load!
       @metadata.updated_at = Time.now.utc.iso8601
@@ -196,25 +195,25 @@ module SmartBox
     def diff(from: nil, to: nil)
       raise Error, "Workspace does not exist" unless Dir.exist?(@workspace_path)
 
-      Dir.chdir(@workspace_path) do
-        # Stage everything so untracked files appear in diff
-        system("git", "add", "-A", out: File::NULL, err: File::NULL)
+      system("git", "add", "-A", chdir: @workspace_path, out: File::NULL, err: File::NULL)
 
-        from_commit = if from
-                        resolve_checkpoint_commit(from)
-                      else
-                        init = @metadata.checkpoints.first
-                        init ? init["git_commit"] : "HEAD~1"
-                      end
+      from_commit = if from
+                      resolve_checkpoint_commit(from)
+                    else
+                      init = @metadata.checkpoints.first
+                      init ? init["git_commit"] : "HEAD~1"
+                    end
 
-        to_commit = to ? resolve_checkpoint_commit(to) : nil
+      to_commit = to ? resolve_checkpoint_commit(to) : nil
 
-        if to_commit
-          `git diff #{from_commit} #{to_commit} 2>/dev/null`
-        else
-          `git diff --cached #{from_commit} 2>/dev/null`
-        end
+      if to_commit
+        out, _err, _st = Open3.capture3("git", "diff", from_commit, to_commit,
+                                        chdir: @workspace_path)
+      else
+        out, _err, _st = Open3.capture3("git", "diff", "--cached", from_commit,
+                                        chdir: @workspace_path)
       end
+      out.to_s
     end
 
     def export_patch(output:, from: nil, to: nil)
@@ -249,36 +248,29 @@ module SmartBox
         backup_patch_path = File.join(@box_dir, "patches", "backup.patch")
         FileUtils.mkdir_p(File.join(@box_dir, "patches"))
 
-        Dir.chdir(@source_path) do
-          backup = `git diff 2>/dev/null`
-          File.write(backup_patch_path, backup) unless backup.empty?
-        end
+        backup, _err, _st = Open3.capture3("git", "diff", chdir: @source_path)
+        File.write(backup_patch_path, backup) unless backup.empty?
 
         # Apply the patch
-        Dir.chdir(@source_path) do
-          IO.popen(["git", "apply", "-v"], "w") do |io|
-            io.write(patch_content)
-          end
-
-          unless $?.success?
-            raise PatchApplyError, "Failed to apply patch. The source project may have conflicts."
-          end
-
-          # Show what changed
-          result_diff = `git diff 2>/dev/null`
-          result_diff
+        _apply_out, _apply_err, status =
+          Open3.capture3("git", "apply", "-v",
+                         stdin_data: patch_content, chdir: @source_path)
+
+        unless status.success?
+          raise PatchApplyError, "Failed to apply patch. The source project may have conflicts."
         end
+
+        # Show what changed
+        result_diff, _err2, _st2 = Open3.capture3("git", "diff", chdir: @source_path)
+        result_diff
       else
         # Non-git source: apply patch with patch command
         backup_patch_path = File.join(@box_dir, "patches", "backup.diff")
         FileUtils.mkdir_p(File.join(@box_dir, "patches"))
         File.write(backup_patch_path, "backup not available for non-git source")
 
-        Dir.chdir(@source_path) do
-          IO.popen(["patch", "-p1", "-N", "-r", "/dev/null"], "w") do |io|
-            io.write(patch_content)
-          end
-        end
+        Open3.capture3("patch", "-p1", "-N", "-r", "/dev/null",
+                       stdin_data: patch_content, chdir: @source_path)
 
         "Patch applied to non-git source at #{@source_path}"
       end
@@ -299,7 +291,10 @@ module SmartBox
 
     def source_clean?
       return true unless Dir.exist?(File.join(@source_path, ".git"))
-      Dir.chdir(@source_path) { `git status --porcelain 2>/dev/null`.strip.empty? }
+
+      out, _err, _st = Open3.capture3("git", "status", "--porcelain",
+                                      chdir: @source_path)
+      out.strip.empty?
     end
 
     private
@@ -338,27 +333,27 @@ module SmartBox
       # wrongly return "none". File.exist? is true for both files and dirs.
       return "none" unless File.exist?(File.join(@workspace_path, ".git"))
 
-      Dir.chdir(@workspace_path) do
-        `git rev-parse HEAD 2>/dev/null`.strip
-      end
+      out, _err, _st = Open3.capture3("git", "rev-parse", "HEAD",
+                                      chdir: @workspace_path)
+      out.strip
     end
 
     def source_git_commit
       git_dir = File.join(@source_path, ".git")
       return "none" unless Dir.exist?(git_dir)
 
-      Dir.chdir(@source_path) do
-        `git rev-parse HEAD 2>/dev/null`.strip
-      end
+      out, _err, _st = Open3.capture3("git", "rev-parse", "HEAD",
+                                      chdir: @source_path)
+      out.strip
     end
 
     def source_git_branch
       git_dir = File.join(@source_path, ".git")
       return "none" unless Dir.exist?(git_dir)
 
-      Dir.chdir(@source_path) do
-        `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
-      end
+      out, _err, _st = Open3.capture3("git", "rev-parse", "--abbrev-ref", "HEAD",
+                                      chdir: @source_path)
+      out.strip
     end
 
     def resolve_checkpoint_commit(checkpoint_id)

data/lib/smart_box/modes/copy_mode.rb

@@ -93,13 +93,14 @@ module SmartBox
       end
 
       def init_git!
-        Dir.chdir(@workspace_path) do
-          system("git", "init", out: File::NULL, err: File::NULL)
-          system("git", "config", "user.email", "smart_box@localhost", out: File::NULL, err: File::NULL)
-          system("git", "config", "user.name", "smart_box", out: File::NULL, err: File::NULL)
-          system("git", "add", "-A", out: File::NULL, err: File::NULL)
-          system("git", "commit", "-m", "smart_box initial checkpoint", out: File::NULL, err: File::NULL)
-        end
+        system("git", "init", chdir: @workspace_path, out: File::NULL, err: File::NULL)
+        system("git", "config", "user.email", "smart_box@localhost",
+               chdir: @workspace_path, out: File::NULL, err: File::NULL)
+        system("git", "config", "user.name", "smart_box",
+               chdir: @workspace_path, out: File::NULL, err: File::NULL)
+        system("git", "add", "-A", chdir: @workspace_path, out: File::NULL, err: File::NULL)
+        system("git", "commit", "-m", "smart_box initial checkpoint",
+               chdir: @workspace_path, out: File::NULL, err: File::NULL)
       end
     end
   end

data/lib/smart_box/modes/git_worktree_mode.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "open3"
+
 module SmartBox
   module Modes
     class GitWorktreeMode
@@ -46,25 +48,23 @@ module SmartBox
       end
 
       def source_clean?
-        Dir.chdir(@source_path) do
-          `git status --porcelain 2>/dev/null`.strip.empty?
-        end
+        out, _err, _st = Open3.capture3("git", "status", "--porcelain",
+                                        chdir: @source_path)
+        out.strip.empty?
       end
 
       def ensure_branch!
-        Dir.chdir(@source_path) do
-          branches = `git branch --list #{@branch_name} 2>/dev/null`.strip
-          if branches.empty?
-            system("git", "branch", @branch_name, out: File::NULL, err: File::NULL)
-          end
+        branches, _err, _st = Open3.capture3("git", "branch", "--list", @branch_name,
+                                             chdir: @source_path)
+        if branches.strip.empty?
+          system("git", "branch", @branch_name,
+                 chdir: @source_path, out: File::NULL, err: File::NULL)
         end
       end
 
       def create_worktree!
-        Dir.chdir(@source_path) do
-          system("git", "worktree", "add", @workspace_path, @branch_name,
-                 out: File::NULL, err: File::NULL)
-        end
+        system("git", "worktree", "add", @workspace_path, @branch_name,
+               chdir: @source_path, out: File::NULL, err: File::NULL)
 
         unless Dir.exist?(@workspace_path)
           raise SmartBox::Error, "Failed to create git worktree at #{@workspace_path}"
@@ -72,27 +72,22 @@ module SmartBox
       end
 
       def init_checkpoint!
-        Dir.chdir(@workspace_path) do
-          system("git", "add", "-A", out: File::NULL, err: File::NULL)
-          system("git", "commit", "--allow-empty", "-m", "smart_box initial checkpoint",
-                 out: File::NULL, err: File::NULL)
-        end
+        system("git", "add", "-A", chdir: @workspace_path, out: File::NULL, err: File::NULL)
+        system("git", "commit", "--allow-empty", "-m", "smart_box initial checkpoint",
+               chdir: @workspace_path, out: File::NULL, err: File::NULL)
       end
 
       def remove_worktree!
-        Dir.chdir(@source_path) do
-          system("git", "worktree", "remove", @workspace_path, "--force",
-                 out: File::NULL, err: File::NULL)
-          system("git", "branch", "-D", @branch_name,
-                 out: File::NULL, err: File::NULL)
-        end
+        system("git", "worktree", "remove", @workspace_path, "--force",
+               chdir: @source_path, out: File::NULL, err: File::NULL)
+        system("git", "branch", "-D", @branch_name,
+               chdir: @source_path, out: File::NULL, err: File::NULL)
       end
 
       def worktree_exists?
-        Dir.chdir(@source_path) do
-          worktrees = `git worktree list --porcelain 2>/dev/null`
-          worktrees.include?(@workspace_path)
-        end
+        worktrees, _err, _st = Open3.capture3("git", "worktree", "list", "--porcelain",
+                                              chdir: @source_path)
+        worktrees.include?(@workspace_path)
       end
     end
   end

data/lib/smart_box/runner.rb

@@ -4,6 +4,7 @@ require "open3"
 require "json"
 require "time"
 require "shellwords"
+require "fileutils"
 require_relative "command_result"
 require_relative "errors"
 
@@ -21,6 +22,11 @@ module SmartBox
       /\bchown\s+-R\b/
     ].freeze
 
+    # Exit code used when a command exceeds its timeout (GNU timeout convention).
+    TIMEOUT_EXIT_CODE = 124
+    # Grace period in seconds between TERM and KILL when terminating a process group.
+    KILL_GRACE_SECONDS = 2
+
     attr_reader :box_id, :workspace_path, :logs_dir
 
     def initialize(box_id:, workspace_path:, logs_dir:)
@@ -69,17 +75,25 @@ module SmartBox
       stderr = ""
       exit_code = nil
 
-      Dir.chdir(@workspace_path) do
-        args = Shellwords.split(command)
-        if env && !env.empty?
-          stdout, stderr, status = Open3.capture3(env, *args, chdir: @workspace_path)
-        else
-          stdout, stderr, status = Open3.capture3(*args, chdir: @workspace_path)
+      args = Shellwords.split(command)
+      # Never switch the parent process directory: all execution is confined to
+      # the workspace via Open3's `chdir:` option. This avoids Ruby's
+      # process-wide `conflicting chdir during another chdir block` error when
+      # boxes run in background threads alongside other threads in the process.
+      if timeout && timeout.to_f > 0
+        stdout, stderr, exit_code = execute_with_timeout(args, env, timeout.to_f)
+      else
+        begin
+          if env && !env.empty?
+            stdout, stderr, status = Open3.capture3(env, *args, chdir: @workspace_path)
+          else
+            stdout, stderr, status = Open3.capture3(*args, chdir: @workspace_path)
+          end
+          exit_code = status.exitstatus
+        rescue Errno::ENOENT => e
+          stderr = "Command not found: #{e.message}"
+          exit_code = 127
         end
-        exit_code = status.exitstatus
-      rescue Errno::ENOENT => e
-        stderr = "Command not found: #{e.message}"
-        exit_code = 127
       end
 
       ended_at = Time.now
@@ -98,6 +112,55 @@ module SmartBox
       )
     end
 
+    # Runs a command with a hard timeout by spawning it in its own process group
+    # (pgroup: true) and killing the whole group on timeout. This kills child
+    # processes too (e.g. find/rsync), unlike Ruby's Timeout.timeout.
+    def execute_with_timeout(args, env, timeout_s)
+      popen_args = env && !env.empty? ? [env, *args] : args
+      Open3.popen3(*popen_args, chdir: @workspace_path, pgroup: true) do |stdin, out, err, wait_thr|
+        stdin.close
+
+        # Drain stdout/stderr concurrently to avoid pipe buffer deadlocks.
+        out_reader = Thread.new { out.read }
+        err_reader = Thread.new { err.read }
+
+        waiter = Thread.new { wait_thr.join }
+        timed_out = false
+        unless waiter.join(timeout_s)
+          timed_out = true
+          kill_process_group!(wait_thr)
+        end
+        waiter.kill if waiter.alive?
+
+        stdout = out_reader.value
+        stderr = err_reader.value
+        exit_code = timed_out ? TIMEOUT_EXIT_CODE : wait_thr.value.exitstatus
+
+        if timed_out
+          marker = "[timeout] command exceeded #{format('%g', timeout_s)}s and was killed (exit #{TIMEOUT_EXIT_CODE})"
+          stderr = stderr.to_s.empty? ? marker : "#{stderr.rstrip}\n#{marker}"
+        end
+
+        [stdout, stderr, exit_code]
+      end
+    rescue Errno::ENOENT => e
+      ["", "Command not found: #{e.message}", 127]
+    end
+
+    # Sends TERM to the whole process group, waits a grace period, then KILL.
+    def kill_process_group!(wait_thr)
+      %w[TERM KILL].each_with_index do |signal, idx|
+        break unless wait_thr.alive?
+
+        begin
+          Process.kill(signal, -wait_thr.pid)
+        rescue Errno::ESRCH, Errno::EPERM
+          break # Process group is already gone (or we lack permission).
+        end
+        wait_thr.join(KILL_GRACE_SECONDS) if idx.zero?
+      end
+    end
+
     def write_logs(command, result, idx)
       write_human_log(command, result)
       write_jsonl_log(command, result, idx)

data/lib/smart_box/version.rb

@@ -1,3 +1,3 @@
 module SmartBox
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_box
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - SmartBox Team
@@ -50,7 +50,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.13
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A local reversible sandbox system for agent task execution
 test_files: []