@saeed42/worktree-worker 1.3.1 → 1.3.2

package/dist/main.js

@@ -613,57 +613,107 @@ var RepoService = class {
       if (isSameRepo) {
         log.info("Repository already initialized with same URL, fetching latest");
         await gitService.fetch("origin", repoRoot, auth);
-        const targetBranch = options.branch || env.DEFAULT_BRANCH;
+        const targetBranch2 = options.branch || env.DEFAULT_BRANCH;
         const currentBranch = status.branch || "";
-        if (targetBranch !== currentBranch) {
-          log.info("Switching to requested branch", { from: currentBranch, to: targetBranch });
-          const checkoutResult = await gitService.exec(["checkout", targetBranch], repoRoot);
+        if (targetBranch2 !== currentBranch) {
+          log.info("Switching to requested branch", { from: currentBranch, to: targetBranch2 });
+          const checkoutResult = await gitService.exec(["checkout", targetBranch2], repoRoot);
           if (checkoutResult.code !== 0) {
             await gitService.exec(
-              ["checkout", "-b", targetBranch, `origin/${targetBranch}`],
+              ["checkout", "-b", targetBranch2, `origin/${targetBranch2}`],
               repoRoot
             );
           }
         }
-        const headSha2 = await gitService.getHeadSha(repoRoot);
-        const branch2 = await gitService.getCurrentBranch(repoRoot);
-        return { path: repoRoot, branch: branch2, headSha: headSha2, remote: status.remote };
+        const headSha3 = await gitService.getHeadSha(repoRoot);
+        const branch3 = await gitService.getCurrentBranch(repoRoot);
+        return { path: repoRoot, branch: branch3, headSha: headSha3, remote: status.remote };
       }
       if (!options.force) {
         throw new Error(
           `Repository already initialized with different URL. Current: ${currentUrl}, Requested: ${requestedUrl}. Use force=true to re-initialize (this will delete all worktrees).`
         );
       }
-      log.warn("Force re-init: cleaning all worktrees and repo");
+      log.warn("Force re-init: cleaning worktrees and updating remote in-place");
       await this.cleanAllWorktrees();
-      await rm(repoRoot, { recursive: true, force: true });
+      const cleanUrl = options.repoUrl.replace(/^https:\/\/[^@]+@/, "https://");
+      await gitService.exec(["remote", "set-url", "origin", cleanUrl], repoRoot);
+      await gitService.exec(["config", "--local", "user.name", "origin-agent[bot]"], repoRoot);
+      await gitService.exec([
+        "config",
+        "--local",
+        "user.email",
+        "origin-agent[bot]@users.noreply.github.com"
+      ], repoRoot);
+      await gitService.exec(["config", "--local", "safe.directory", repoRoot], repoRoot);
+      const targetBranch = options.branch || env.DEFAULT_BRANCH;
+      log.info("Fetching from new remote", { branch: targetBranch });
+      await gitService.fetch("origin", repoRoot, auth);
+      try {
+        await gitService.exec(["checkout", "-B", targetBranch, `origin/${targetBranch}`, "--force"], repoRoot);
+      } catch {
+        await gitService.exec(["checkout", "-B", targetBranch, "--force"], repoRoot);
+      }
+      await gitService.exec(["branch", `--set-upstream-to=origin/${targetBranch}`, targetBranch], repoRoot).catch(
+        () => {
+        }
+      );
+      const headSha2 = await gitService.getHeadSha(repoRoot);
+      const branch2 = await gitService.getCurrentBranch(repoRoot);
+      const remote2 = await gitService.getRemoteUrl("origin", repoRoot);
+      log.info("Repository re-initialized in-place", { branch: branch2, headSha: headSha2 });
+      return { path: repoRoot, branch: branch2, headSha: headSha2, remote: remote2 };
     }
     const parentDir = repoRoot.split("/").slice(0, -1).join("/");
     await mkdir2(parentDir, { recursive: true });
     await mkdir2(env.TRIALS_WORKSPACE_DIR, { recursive: true });
+    const dirExists = await stat2(repoRoot).then(() => true).catch(() => false);
     const branch = options.branch || env.DEFAULT_BRANCH;
-    log.info("Cloning repository", { branch });
-    await gitService.cloneRepo(options.repoUrl, repoRoot, {
-      branch,
-      blobless: true,
-      githubToken: options.githubToken
-    });
-    await gitService.exec(["config", "--local", "user.name", "origin-agent[bot]"], repoRoot);
-    await gitService.exec([
-      "config",
-      "--local",
-      "user.email",
-      "origin-agent[bot]@users.noreply.github.com"
-    ], repoRoot);
-    await gitService.exec(["config", "--local", "safe.directory", repoRoot], repoRoot);
-    const cleanUrl = options.repoUrl.replace(/^https:\/\/[^@]+@/, "https://");
-    await gitService.exec(["remote", "set-url", "origin", cleanUrl], repoRoot);
-    log.info("Fetching all remote refs");
-    await gitService.fetch("origin", repoRoot, auth);
-    await gitService.exec(["branch", `--set-upstream-to=origin/${branch}`, branch], repoRoot).catch(
-      () => {
-      }
-    );
+    if (dirExists) {
+      log.info("Directory exists, initializing git in-place", { branch });
+      await gitService.exec(["init"], repoRoot);
+      await gitService.exec(["config", "--local", "user.name", "origin-agent[bot]"], repoRoot);
+      await gitService.exec([
+        "config",
+        "--local",
+        "user.email",
+        "origin-agent[bot]@users.noreply.github.com"
+      ], repoRoot);
+      await gitService.exec(["config", "--local", "safe.directory", repoRoot], repoRoot);
+      const cleanUrl = options.repoUrl.replace(/^https:\/\/[^@]+@/, "https://");
+      await gitService.exec(["remote", "add", "origin", cleanUrl], repoRoot).catch(async () => {
+        await gitService.exec(["remote", "set-url", "origin", cleanUrl], repoRoot);
+      });
+      await gitService.fetch("origin", repoRoot, auth);
+      await gitService.exec(["checkout", "-B", branch, `origin/${branch}`, "--force"], repoRoot);
+      await gitService.exec(["branch", `--set-upstream-to=origin/${branch}`, branch], repoRoot).catch(
+        () => {
+        }
+      );
+    } else {
+      log.info("Cloning repository", { branch });
+      await gitService.cloneRepo(options.repoUrl, repoRoot, {
+        branch,
+        blobless: true,
+        githubToken: options.githubToken
+      });
+      await gitService.exec(["config", "--local", "user.name", "origin-agent[bot]"], repoRoot);
+      await gitService.exec([
+        "config",
+        "--local",
+        "user.email",
+        "origin-agent[bot]@users.noreply.github.com"
+      ], repoRoot);
+      await gitService.exec(["config", "--local", "safe.directory", repoRoot], repoRoot);
+      const cleanUrl = options.repoUrl.replace(/^https:\/\/[^@]+@/, "https://");
+      await gitService.exec(["remote", "set-url", "origin", cleanUrl], repoRoot);
+      log.info("Fetching all remote refs");
+      await gitService.fetch("origin", repoRoot, auth);
+      await gitService.exec(["branch", `--set-upstream-to=origin/${branch}`, branch], repoRoot).catch(
+        () => {
+        }
+      );
+    }
     const isEmpty = await gitService.isEmptyRepo(repoRoot);
     if (isEmpty) {
       log.warn("Repository is empty (no commits)", { repoUrl: options.repoUrl });
@@ -873,6 +923,7 @@ var WorktreeService = class {
       hasRepoUrl: !!options.repoUrl
     });
     await mkdir3(env.TRIALS_WORKSPACE_DIR, { recursive: true });
+    await this.opportunisticCleanup();
     let repoStatus = await repoService.getStatus();
     const isValidGitHubRemote = (remote) => {
       if (!remote) return false;
@@ -1118,59 +1169,98 @@ var WorktreeService = class {
     return { branch, pushed: true };
   }
   /**
-   * Cleanup stale worktrees based on age and optionally disk pressure
-   * 
-   * Strategy:
-   * 1. Always clean worktrees older than CLEANUP_AFTER_HOURS (default 24h)
-   * 2. If disk usage is high (>80%), also clean worktrees older than 6h
-   * 3. If disk usage is critical (>90%), clean all worktrees older than 1h
+   * Count current worktrees
    */
-  async cleanupStaleWorktrees() {
-    const log = logger.child({ service: "worktree", action: "cleanup" });
-    let cleaned = 0;
-    const errors = [];
-    let diskUsagePercent;
-    let cutoffHours = env.CLEANUP_AFTER_HOURS;
+  async countWorktrees() {
     try {
-      const diskInfo = await this.getDiskUsage();
-      diskUsagePercent = diskInfo.usedPercent;
-      if (diskUsagePercent > 90) {
-        cutoffHours = 1;
-        log.warn("Critical disk usage, aggressive cleanup", { diskUsagePercent, cutoffHours });
-      } else if (diskUsagePercent > 80) {
-        cutoffHours = 6;
-        log.info("High disk usage, moderate cleanup", { diskUsagePercent, cutoffHours });
-      }
-    } catch (err) {
-      log.warn("Could not check disk usage", { error: err instanceof Error ? err.message : String(err) });
+      const entries = await readdir2(env.TRIALS_WORKSPACE_DIR, { withFileTypes: true });
+      return entries.filter((e) => e.isDirectory()).length;
+    } catch {
+      return 0;
     }
-    const cutoffTime = Date.now() - cutoffHours * 60 * 60 * 1e3;
+  }
+  /**
+   * Get worktrees sorted by modification time (oldest first)
+   */
+  async getWorktreesByAge() {
     try {
       const entries = await readdir2(env.TRIALS_WORKSPACE_DIR, { withFileTypes: true });
-      const worktreesWithStats = [];
+      const worktrees = [];
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const worktreePath = `${env.TRIALS_WORKSPACE_DIR}/${entry.name}`;
         try {
           const stats = await stat3(worktreePath);
-          worktreesWithStats.push({ path: worktreePath, mtime: stats.mtimeMs });
+          worktrees.push({ path: worktreePath, mtime: stats.mtimeMs });
         } catch {
         }
       }
-      worktreesWithStats.sort((a, b) => a.mtime - b.mtime);
-      for (const wt of worktreesWithStats) {
-        if (wt.mtime < cutoffTime) {
+      return worktrees.sort((a, b) => a.mtime - b.mtime);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Opportunistic cleanup - run before creating new worktrees
+   * 
+   * Strategy:
+   * 1. Always clean worktrees older than CLEANUP_AFTER_HOURS
+   * 2. If count exceeds MAX_WORKTREES, clean oldest until under limit
+   */
+  async opportunisticCleanup(maxWorktrees = 20) {
+    const log = logger.child({ service: "worktree", action: "opportunistic-cleanup" });
+    try {
+      const worktrees = await this.getWorktreesByAge();
+      const count = worktrees.length;
+      const cutoffTime = Date.now() - env.CLEANUP_AFTER_HOURS * 60 * 60 * 1e3;
+      let cleaned = 0;
+      for (const wt of worktrees) {
+        const isStale = wt.mtime < cutoffTime;
+        const isOverLimit = count - cleaned > maxWorktrees;
+        if (isStale || isOverLimit) {
           try {
-            log.info("Cleaning up stale worktree", {
+            await rm2(wt.path, { recursive: true, force: true });
+            cleaned++;
+            log.debug("Cleaned worktree", {
               path: wt.path,
+              reason: isStale ? "stale" : "over_limit",
               ageHours: Math.round((Date.now() - wt.mtime) / (60 * 60 * 1e3))
             });
-            await rm2(wt.path, { recursive: true, force: true });
+          } catch {
+          }
+        }
+      }
+      if (cleaned > 0) {
+        log.info("Opportunistic cleanup completed", { cleaned, remaining: count - cleaned });
+        await gitService.pruneWorktrees(env.BASE_WORKSPACE_DIR).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  /**
+   * Cleanup stale worktrees
+   */
+  async cleanupStaleWorktrees() {
+    const log = logger.child({ service: "worktree", action: "cleanup" });
+    let cleaned = 0;
+    const errors = [];
+    const cutoffTime = Date.now() - env.CLEANUP_AFTER_HOURS * 60 * 60 * 1e3;
+    try {
+      const entries = await readdir2(env.TRIALS_WORKSPACE_DIR, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const worktreePath = `${env.TRIALS_WORKSPACE_DIR}/${entry.name}`;
+        try {
+          const stats = await stat3(worktreePath);
+          if (stats.mtimeMs < cutoffTime) {
+            log.info("Cleaning up stale worktree", { path: worktreePath });
+            await rm2(worktreePath, { recursive: true, force: true });
             cleaned++;
-          } catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            errors.push(`${wt.path}: ${errMsg}`);
           }
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          errors.push(`${worktreePath}: ${errMsg}`);
         }
       }
       await gitService.pruneWorktrees(env.BASE_WORKSPACE_DIR);
@@ -1178,23 +1268,8 @@ var WorktreeService = class {
       const errMsg = err instanceof Error ? err.message : String(err);
       errors.push(`readdir: ${errMsg}`);
     }
-    log.info("Cleanup completed", { cleaned, errorCount: errors.length, diskUsagePercent });
-    return { cleaned, errors, diskUsagePercent };
-  }
-  /**
-   * Get disk usage information for the workspace partition
-   */
-  async getDiskUsage() {
-    const { exec } = await import("child_process");
-    const { promisify } = await import("util");
-    const execAsync = promisify(exec);
-    const { stdout } = await execAsync(`df -B1 ${env.BASE_WORKSPACE_DIR} | tail -1`);
-    const parts = stdout.trim().split(/\s+/);
-    const total = parseInt(parts[1], 10);
-    const used = parseInt(parts[2], 10);
-    const free = parseInt(parts[3], 10);
-    const usedPercent = parseInt(parts[4].replace("%", ""), 10);
-    return { total, used, free, usedPercent };
+    log.info("Cleanup completed", { cleaned, errorCount: errors.length });
+    return { cleaned, errors };
   }
 };
 var worktreeService = new WorktreeService();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saeed42/worktree-worker",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "Git worktree management service for AI agent trials",
   "type": "module",
   "main": "dist/main.js",