@bridge4dev/runner 0.22.1 → 0.27.0

package/dist/git.js

@@ -3,32 +3,121 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { previewsDir, worktreesDir } from './paths.js';
+import { firstUnreachableAncestor, inspectPath, looksLikeDubiousOwnership, runnerIdentity, safeDirectoryCommand, } from './environment.js';
 const execFileAsync = promisify(execFile);
 const GIT_TIMEOUT_MS = 30_000;
 async function git(cwd, ...args) {
     const { stdout } = await execFileAsync('git', args, { cwd, timeout: GIT_TIMEOUT_MS });
     return stdout.trim();
 }
+/**
+ * Can this runner actually work in this directory — as the user it runs as?
+ *
+ * Everything here answers with the fix rather than the symptom. Binding a
+ * project is the moment the two legitimate install choices (root / dedicated
+ * user) start to differ, and until now the second one failed by forwarding
+ * git's own words to a dashboard the person may have no shell behind:
+ * «git check failed: fatal: detected dubious ownership in repository at
+ * '/opt/ids'». That sentence is true and unactionable.
+ */
 export async function validateWorkspacePath(workspacePath) {
-    if (!fs.existsSync(workspacePath) || !fs.statSync(workspacePath).isDirectory()) {
-        return { ok: false, exists: false, isGitRepo: false, error: 'Directory does not exist' };
+    const me = runnerIdentity();
+    const dir = inspectPath(workspacePath);
+    // «Cannot look» and «is not there» are opposite instructions to whoever reads
+    // this, and both arrive as a thrown `statSync`. A dedicated-user install hits
+    // the first one constantly — usually on a directory ABOVE the project, which
+    // is why the blocking one is named rather than the one that was asked about.
+    if (dir.unreachable) {
+        const blocked = firstUnreachableAncestor(workspacePath) ?? workspacePath;
+        return {
+            ok: false,
+            exists: true,
+            isGitRepo: false,
+            error: `The runner runs as ${me.user} and is not allowed into ${blocked}, so it cannot reach ${workspacePath}. ` +
+                `Grant that user access to the directory (for example \`chmod o+x ${blocked}\`, ` +
+                `or \`setfacl -m u:${me.user}:x ${blocked}\`), then try again.`,
+        };
+    }
+    if (!dir.exists || !dir.isDirectory) {
+        return {
+            ok: false,
+            exists: dir.exists,
+            isGitRepo: false,
+            error: dir.exists
+                ? `${workspacePath} is not a directory`
+                : `${workspacePath} does not exist on this server`,
+        };
+    }
+    // A directory we cannot even enter: as a non-root runner this is the most
+    // common outcome of pointing at somebody else's project, and git's error for
+    // it says nothing about permissions.
+    if (!dir.readable) {
+        return {
+            ok: false,
+            exists: true,
+            isGitRepo: false,
+            error: `The runner runs as ${me.user} and cannot read ${workspacePath}. ` +
+                `Give that user access (for example \`setfacl -R -m u:${me.user}:rX ${workspacePath}\`, ` +
+                `or \`chown -R ${me.user} ${workspacePath}\` if the directory is meant to be theirs), then try again.`,
+        };
     }
     try {
         const inside = await git(workspacePath, 'rev-parse', '--is-inside-work-tree');
         if (inside !== 'true') {
             return { ok: false, exists: true, isGitRepo: false, error: 'Not a git work tree' };
         }
-        const branch = await git(workspacePath, 'rev-parse', '--abbrev-ref', 'HEAD');
-        return { ok: true, exists: true, isGitRepo: true, branch };
     }
     catch (error) {
+        const message = String(error instanceof Error ? error.message : error);
+        if (looksLikeDubiousOwnership(message)) {
+            // The single most common failure of a dedicated-user install, and the one
+            // whose fix is one line — which is why we print the line.
+            const owner = dir.ownerUid >= 0 ? ` (it belongs to uid ${dir.ownerUid})` : '';
+            return {
+                ok: false,
+                exists: true,
+                isGitRepo: false,
+                error: `Git refuses to use ${workspacePath} because the runner runs as ${me.user} and does not own it${owner}. ` +
+                    `Run this on the server as ${me.user}: ${safeDirectoryCommand(workspacePath)} — ` +
+                    `or run \`devbridge-runner doctor --fix\`, which does it for every bound project. ` +
+                    `Note: if you instead hand the directory over with \`chown\`, add the same line for its previous owner, ` +
+                    `who will otherwise lose git in that repository.`,
+            };
+        }
         return {
             ok: false,
             exists: true,
             isGitRepo: false,
-            error: `git check failed: ${String(error instanceof Error ? error.message : error).slice(0, 300)}`,
+            error: `git check failed: ${message.slice(0, 300)}`,
         };
     }
+    // Sessions write here: a worktree registers itself inside `.git/worktrees`,
+    // and a DIRECT-mode session commits in the tree itself. Read-only access
+    // binds fine and then fails on the first session, which is the worst place
+    // to learn about it.
+    const gitDir = await resolveGitDir(workspacePath);
+    const gitAccess = gitDir ? inspectPath(gitDir) : null;
+    if (gitAccess && gitAccess.exists && !gitAccess.writable) {
+        return {
+            ok: false,
+            exists: true,
+            isGitRepo: true,
+            error: `The runner runs as ${me.user} and cannot write to ${gitDir}, so it could not create a branch or a worktree here. ` +
+                `Give that user write access to the repository (for example \`chown -R ${me.user} ${workspacePath}\`), then try again.`,
+        };
+    }
+    const branch = await git(workspacePath, 'rev-parse', '--abbrev-ref', 'HEAD');
+    return { ok: true, exists: true, isGitRepo: true, branch };
+}
+/** The real `.git` directory of a work tree (a linked worktree has a file there). */
+async function resolveGitDir(workspacePath) {
+    try {
+        const common = await git(workspacePath, 'rev-parse', '--git-common-dir');
+        return path.resolve(workspacePath, common);
+    }
+    catch {
+        return null;
+    }
 }
 export function sessionShortId(sessionId) {
     return sessionId.replace(/-/g, '').slice(0, 8);