@peakflo/agent-harness 0.2.17-rc.2 → 0.2.17

package/dist/github-workspace.d.ts

@@ -41,6 +41,9 @@ export declare class GitHubWorkspaceProvider implements WorkspaceProvider {
     /** Never fetch a different repository into a shared durable bare clone. */
     private bareRepositoryPath;
     private isUnusableCheckout;
+    private checkoutPath;
+    /** Locate only this checkout's registration; never prune sibling records. */
+    private worktreeRegistration;
     /**
      * A session owns its checkout, including branch changes and detached HEAD.
      * Check its root and repository identity, never its branch or commit. Keep

package/dist/github-workspace.js

@@ -87,6 +87,8 @@ class GitHubWorkspaceProvider {
             }
         }
         this.gitEnvironment.GIT_TERMINAL_PROMPT = '0';
+        // Recovery classifies Git's stable diagnostics, never localized text.
+        this.gitEnvironment.LC_ALL = 'C';
         this.rememberDirectUrls(options.directUrls ?? []);
     }
     rememberDirectUrls(urls) {
@@ -152,6 +154,41 @@ class GitHubWorkspaceProvider {
         return (gitError.code === 128 &&
             /not a git repository|invalid gitfile format|bad config line/i.test(gitError.stderr ?? ''));
     }
+    async checkoutPath(path) {
+        // Resolve the parent, not the checkout entry: it may now be a symlink or
+        // be missing. Match the registered location without following its target.
+        return (0, node_path_1.join)(await (0, promises_1.realpath)((0, node_path_1.dirname)(path)), (0, node_path_1.basename)(path));
+    }
+    /** Locate only this checkout's registration; never prune sibling records. */
+    async worktreeRegistration(bare, worktree) {
+        const canonical = await this.checkoutPath(worktree);
+        const root = (0, node_path_1.join)(bare, 'worktrees');
+        const entries = await (0, promises_1.readdir)(root, { withFileTypes: true }).catch((error) => {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.isSymbolicLink())
+                continue;
+            const admin = (0, node_path_1.join)(root, entry.name);
+            const target = await (0, promises_1.readFile)((0, node_path_1.join)(admin, 'gitdir'), 'utf8').catch((error) => {
+                if (error.code === 'ENOENT')
+                    return '';
+                throw error;
+            });
+            if ((0, node_path_1.basename)(target.trim()) !== '.git')
+                continue;
+            const parent = await this.checkoutPath((0, node_path_1.dirname)(target.trim())).catch((error) => {
+                if (error.code === 'ENOENT')
+                    return null;
+                throw error;
+            });
+            if (parent === canonical)
+                return admin;
+        }
+        return null;
+    }
     /**
      * A session owns its checkout, including branch changes and detached HEAD.
      * Check its root and repository identity, never its branch or commit. Keep
@@ -163,11 +200,10 @@ class GitHubWorkspaceProvider {
             entry = await (0, promises_1.lstat)(worktree);
         }
         catch (error) {
-            if (error.code === 'ENOENT')
-                return false;
-            throw error;
+            if (error.code !== 'ENOENT')
+                throw error;
         }
-        if (entry.isDirectory() && !entry.isSymbolicLink()) {
+        if (entry?.isDirectory() && !entry.isSymbolicLink()) {
             try {
                 const [topLevel, origin, commonDir] = await Promise.all([
                     this.runGit(['rev-parse', '--show-toplevel'], { cwd: worktree }),
@@ -203,27 +239,56 @@ class GitHubWorkspaceProvider {
                 }
             }
         }
+        const registration = await this.worktreeRegistration(bare, worktree);
+        if (!entry && !registration)
+            return false;
         const backupRoot = await (0, promises_1.mkdtemp)((0, node_path_1.join)(this.sessionPath(sessionId), `.preserved-${Date.now()}-`));
         const backup = (0, node_path_1.join)(backupRoot, 'repository');
-        // Git updates a linked worktree's administrative paths when possible.
-        // A plain directory, symlink or broken checkout still keeps all bytes.
-        if (entry.isDirectory() && !entry.isSymbolicLink()) {
+        const repairRegistration = async () => {
+            try {
+                if (registration) {
+                    // Keep the index, HEAD and reflog. Retain the original .git bytes too.
+                    const gitFile = (0, node_path_1.join)(backup, '.git');
+                    await (0, promises_1.rename)(gitFile, (0, node_path_1.join)(backupRoot, 'original-git-file')).catch((error) => {
+                        if (error.code !== 'ENOENT')
+                            throw error;
+                    });
+                    await (0, promises_1.writeFile)(gitFile, `gitdir: ${registration}\n`, {
+                        mode: 0o600
+                    });
+                    await (0, promises_1.writeFile)((0, node_path_1.join)(registration, 'gitdir'), `${gitFile}\n`, {
+                        mode: 0o600
+                    });
+                }
+                await this.runGit(['worktree', 'repair', backup], { cwd: bare }).catch(() => undefined);
+            }
+            catch {
+                throw new Error(`Repository files were kept at ${backup}. Git state repair failed. ` +
+                    'Keep the saved folder and retry after the filesystem is available.');
+            }
+        };
+        if (!entry) {
+            // A removed checkout can still have staged work in its Git index.
+            await (0, promises_1.mkdir)(backup, { mode: 0o700 });
+            await repairRegistration();
+        }
+        else if (entry.isDirectory() && !entry.isSymbolicLink()) {
             await this.runGit(['worktree', 'move', worktree, backup], {
                 cwd: worktree
             }).catch(async () => {
                 await (0, promises_1.rename)(worktree, backup);
-                await this.runGit(['worktree', 'repair', backup], { cwd: bare }).catch(() => undefined);
+                await repairRegistration();
             });
         }
         else {
-            await (0, promises_1.rename)(worktree, backup);
+            await (0, promises_1.mkdir)(backup, { mode: 0o700 });
+            await (0, promises_1.rename)(worktree, (0, node_path_1.join)(backup, 'original-entry'));
+            await repairRegistration();
         }
-        // A broken .git file cannot be repaired. Remove only obsolete Git
-        // registrations now, before reusing the vacated path; keep all saved files.
-        await this.runGit(['worktree', 'prune', '--expire=now'], { cwd: bare });
         const notes = this.preparationNotes.get(sessionId) ?? [];
-        notes.push(`The previous repository folder could not be reused. All its files ` +
-            `were kept at ${backup}. A fresh checkout was prepared. ` +
+        notes.push(`The previous repository folder could not be reused. Its files and Git state ` +
+            `were kept under ${backupRoot}. Saved checkout: ${backup}. ` +
+            'A fresh checkout was prepared. ' +
             'Review the saved folder before you remove it.');
         this.preparationNotes.set(sessionId, notes);
         return false;
@@ -439,6 +504,12 @@ class GitHubWorkspaceProvider {
         let reusedWorktree = false;
         for (const repository of request.repositories) {
             const [owner, name] = repository.fullName.split('/');
+            const githubIdentity = githubRepositoryIdentity(repository.cloneUrl);
+            // GitHub's canonical clone endpoint is HTTPS owner/repo.git. Strip URL
+            // credentials and old loopback ports; the credential proxy supplies auth.
+            const transportUrl = githubIdentity
+                ? `https://${githubIdentity}.git`
+                : repository.cloneUrl;
             const bare = await this.bareRepositoryPath((0, node_path_1.join)(repositoriesRoot, `${owner}--${name}.git`), repository.cloneUrl);
             const worktree = (0, node_path_1.join)(sessionRoot, name);
             // The empty value resets every inherited/global helper. Without it, Git
@@ -456,7 +527,7 @@ class GitHubWorkspaceProvider {
                 });
             }
             catch {
-                await this.runGit([...gitArgs, 'clone', '--bare', repository.cloneUrl, bare], {
+                await this.runGit([...gitArgs, 'clone', '--bare', transportUrl, bare], {
                     timeout: 10 * 60_000,
                     maxBuffer: 10 * 1024 * 1024,
                     environment: gitNetworkEnvironment
@@ -469,16 +540,17 @@ class GitHubWorkspaceProvider {
             }
             // The identity check above permits old proxy/sentinel URL forms. Fetch
             // through the current lease URL so a stale loopback port cannot fail first.
-            await this.runGit(['config', 'remote.origin.url', repository.cloneUrl], {
-                cwd: bare
-            });
-            await this.runGit([...gitArgs, 'fetch', 'origin', '+refs/heads/*:refs/remotes/origin/*'], {
+            await this.runGit([
+                ...gitArgs,
+                'fetch',
+                transportUrl,
+                '+refs/heads/*:refs/remotes/origin/*'
+            ], {
                 cwd: bare,
                 timeout: 10 * 60_000,
                 maxBuffer: 10 * 1024 * 1024,
                 environment: gitNetworkEnvironment
             });
-            await this.runGit(['worktree', 'prune'], { cwd: bare });
             const branch = `agent/${request.sessionId}`;
             const reuse = await this.canReuseWorktree(bare, worktree, repository.cloneUrl, request.sessionId);
             if (!reuse) {
@@ -524,9 +596,9 @@ class GitHubWorkspaceProvider {
             await this.runGit(['config', '--worktree', 'core.bare', 'false'], {
                 cwd: worktree
             });
-            await this.runGit(['config', '--worktree', 'remote.origin.url', repository.cloneUrl], { cwd: worktree });
+            await this.runGit(['config', '--worktree', 'remote.origin.url', transportUrl], { cwd: worktree });
             const hooks = (0, node_path_1.join)(sessionRoot, '.github-hooks', name);
-            await (0, github_command_guards_1.installPushGuard)(hooks, request.sessionId, repository.defaultBranch, repository.cloneUrl);
+            await (0, github_command_guards_1.installPushGuard)(hooks, request.sessionId, repository.defaultBranch, transportUrl);
             await this.runGit(['config', '--worktree', 'core.hooksPath', hooks], {
                 cwd: worktree
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peakflo/agent-harness",
-  "version": "0.2.17-rc.2",
+  "version": "0.2.17",
   "description": "Headless Peakflo coding-agent harness. One codebase, three hosting modes: a Daytona cloud sandbox, a customer VM, and the 20x desktop.",
   "license": "MIT",
   "type": "commonjs",