@ferrule-io/ok-fine 0.3.6 → 0.3.8

package/dist/store/git-backend.js

@@ -1,13 +1,15 @@
-import { mkdir, readdir, readFile, rm, rmdir, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readdir, readFile, rm, rmdir } from "node:fs/promises";
 import { join, posix } from "node:path";
 import { OkfError } from "../errors.js";
 import { nowIso } from "../okf/frontmatter.js";
 import { PROJECT_RE } from "../okf/paths.js";
 import { parseActor } from "../okf/semantics.js";
-import { atomicWrite, isDirectory, listTreeFiles, pathExists } from "./fs-util.js";
+import { assertContainedPath, atomicWrite, listTreeFiles, pathExists } from "./fs-util.js";
 import { Git, isPushRejection, redactRemote } from "./git.js";
 import { Mutex } from "./mutex.js";
 import { PathIndex } from "./path-index.js";
+const REMOTE_BASE_REF = "refs/ok-fine/remote-base";
+const REMOTE_REWRITTEN_MSG = "remote history was rewritten; syncing halted. Stop ok-fine, remove DATA_DIR/repo, and restart to re-clone";
 function extractChangedProjects(diffOutput) {
     const lines = diffOutput
         .split(/\r?\n/)
@@ -32,11 +34,13 @@ class GitTx {
         this.index = index;
     }
     async writeFile(project, path, content) {
+        await assertContainedPath(this.repoDir, project, path);
         await atomicWrite(join(this.repoDir, project, path), content);
         this.index.add(project, path);
         this.touched = true;
     }
     async deleteFile(project, path) {
+        await assertContainedPath(this.repoDir, project, path);
         const projectDir = join(this.repoDir, project);
         await rm(join(projectDir, path), { force: true });
         let dir = posix.dirname(path);
@@ -57,15 +61,43 @@ class GitTx {
         this.touched = true;
     }
     async deleteProject(project) {
-        await rm(join(this.repoDir, project), { recursive: true, force: true });
+        const projectDir = join(this.repoDir, project);
+        try {
+            const s = await lstat(projectDir);
+            if (s.isSymbolicLink()) {
+                await rm(projectDir, { force: true });
+            }
+            else {
+                await rm(projectDir, { recursive: true, force: true });
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
         this.index.setProject(project, []);
         this.touched = true;
     }
     async replaceProject(project, source) {
         const projectDir = join(this.repoDir, project);
-        await rm(projectDir, { recursive: true, force: true });
+        try {
+            const s = await lstat(projectDir);
+            if (s.isSymbolicLink()) {
+                await rm(projectDir, { force: true });
+            }
+            else {
+                await rm(projectDir, { recursive: true, force: true });
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
         const written = [];
         for (const path of source.paths) {
+            await assertContainedPath(this.repoDir, project, path);
             const content = await source.read(path);
             if (content !== null) {
                 await atomicWrite(join(projectDir, path), content);
@@ -102,6 +134,7 @@ export class GitBackend {
     }
     async close() {
         await this.mutex.idle();
+        await this.git.close();
     }
     async projects() {
         return this.index.projects();
@@ -114,18 +147,30 @@ export class GitBackend {
             return null;
         }
         try {
-            return await readFile(join(this.repoDir, project, path));
-        }
-        catch (err) {
-            if (err.code === "ENOENT") {
+            await assertContainedPath(this.repoDir, project, path);
+            const fullPath = join(this.repoDir, project, path);
+            const s = await lstat(fullPath);
+            if (s.isSymbolicLink() || !s.isFile()) {
                 return null;
             }
-            throw err;
+            return await readFile(fullPath);
+        }
+        catch {
+            return null;
         }
     }
     async reindexProject(project) {
         const dir = join(this.repoDir, project);
-        const paths = (await isDirectory(dir)) ? await listTreeFiles(dir) : [];
+        let paths = [];
+        try {
+            const s = await lstat(dir);
+            if (!s.isSymbolicLink() && s.isDirectory()) {
+                paths = await listTreeFiles(dir);
+            }
+        }
+        catch {
+            paths = [];
+        }
         this.index.setProject(project, paths);
     }
     async reindexAll() {
@@ -200,6 +245,7 @@ export class GitBackend {
                 if (remoteBranchExists) {
                     await repo.git.run(["checkout", "-B", config.gitBranch, `origin/${config.gitBranch}`]);
                     headHasCommits = true;
+                    await repo.setRememberedRemoteTip(remoteBranchRev.stdout.trim());
                 }
                 else {
                     // Initialize empty bundle root files
@@ -214,6 +260,8 @@ export class GitBackend {
                         allowFail: true,
                     });
                     headHasCommits = true;
+                    const initialHead = (await repo.git.run(["rev-parse", "HEAD"])).stdout.trim();
+                    await repo.setRememberedRemoteTip(initialHead);
                 }
             }
             else {
@@ -245,24 +293,67 @@ export class GitBackend {
                     "okf: configure merge and ignore attributes",
                 ]);
                 if (repo.hasRemote) {
-                    await repo.git.run(["push", "origin", `HEAD:refs/heads/${config.gitBranch}`], {
+                    const pushRes = await repo.git.run(["push", "origin", `HEAD:refs/heads/${config.gitBranch}`], {
                         allowFail: true,
                     });
+                    if (pushRes.code === 0) {
+                        const headSha = (await repo.git.run(["rev-parse", "HEAD"])).stdout.trim();
+                        await repo.setRememberedRemoteTip(headSha);
+                    }
                 }
             }
         }
         await repo.reindexAll();
         return repo;
     }
+    async getRememberedRemoteTip() {
+        const res = await this.git.run(["rev-parse", "--verify", REMOTE_BASE_REF], {
+            allowFail: true,
+        });
+        if (res.code === 0 && res.stdout.trim().length > 0) {
+            return res.stdout.trim();
+        }
+        return null;
+    }
+    async setRememberedRemoteTip(sha) {
+        await this.git.run(["update-ref", REMOTE_BASE_REF, sha], { allowFail: true });
+    }
+    async isRemoteAncestorHalted(remoteTip) {
+        const rememberedTip = await this.getRememberedRemoteTip();
+        if (!rememberedTip) {
+            await this.setRememberedRemoteTip(remoteTip);
+            return false;
+        }
+        if (rememberedTip === remoteTip) {
+            return false;
+        }
+        const ancestorCheck = await this.git.run(["merge-base", "--is-ancestor", rememberedTip, remoteTip], {
+            allowFail: true,
+        });
+        if (ancestorCheck.code !== 0) {
+            this.lastError = REMOTE_REWRITTEN_MSG;
+            this.log.error({ rememberedTip, remoteTip }, REMOTE_REWRITTEN_MSG);
+            return true;
+        }
+        return false;
+    }
     async ensureAttributesAndIgnore() {
         let changed = false;
         const gitattributesPath = join(this.repoDir, ".gitattributes");
         let attrContent = "";
         try {
-            attrContent = await readFile(gitattributesPath, "utf8");
+            const s = await lstat(gitattributesPath);
+            if (s.isSymbolicLink()) {
+                await rm(gitattributesPath, { force: true });
+            }
+            else {
+                attrContent = await readFile(gitattributesPath, "utf8");
+            }
         }
-        catch {
-            // not exists
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
         }
         const requiredAttrLines = ["**/index.md merge=union", "**/log.md merge=union"];
         let newAttrContent = attrContent;
@@ -275,17 +366,25 @@ export class GitBackend {
             }
         }
         if (newAttrContent !== attrContent) {
-            await writeFile(gitattributesPath, newAttrContent, "utf8");
+            await atomicWrite(gitattributesPath, newAttrContent);
             await this.git.run(["add", ".gitattributes"]);
             changed = true;
         }
         const gitignorePath = join(this.repoDir, ".gitignore");
         let ignoreContent = "";
         try {
-            ignoreContent = await readFile(gitignorePath, "utf8");
+            const s = await lstat(gitignorePath);
+            if (s.isSymbolicLink()) {
+                await rm(gitignorePath, { force: true });
+            }
+            else {
+                ignoreContent = await readFile(gitignorePath, "utf8");
+            }
         }
-        catch {
-            // not exists
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
         }
         const requiredIgnoreLine = ".*.tmp";
         let newIgnoreContent = ignoreContent;
@@ -296,7 +395,7 @@ export class GitBackend {
             newIgnoreContent += `${requiredIgnoreLine}\n`;
         }
         if (newIgnoreContent !== ignoreContent) {
-            await writeFile(gitignorePath, newIgnoreContent, "utf8");
+            await atomicWrite(gitignorePath, newIgnoreContent);
             await this.git.run(["add", ".gitignore"]);
             changed = true;
         }
@@ -348,6 +447,7 @@ export class GitBackend {
     async transaction(spec, work) {
         return this.mutex.run(async () => {
             const warnings = [];
+            let syncHalted = false;
             // Step 1: Remote sync check before work
             if (this.hasRemote) {
                 const fetchRes = await this.git.run(["fetch", "origin", this.config.gitBranch], { allowFail: true });
@@ -356,20 +456,32 @@ export class GitBackend {
                     warnings.push(`remote unreachable: ${firstLine}`);
                 }
                 else {
-                    const behindRes = await this.git.run(["rev-list", "--count", `HEAD..origin/${this.config.gitBranch}`], {
+                    const remoteRevRes = await this.git.run(["rev-parse", "--verify", `origin/${this.config.gitBranch}`], {
                         allowFail: true,
                     });
-                    const behind = Number.parseInt(behindRes.stdout.trim(), 10) || 0;
-                    if (behind > 0) {
-                        const before = (await this.git.run(["rev-parse", "HEAD"])).stdout.trim();
-                        const rebaseRes = await this.git.run(["rebase", `origin/${this.config.gitBranch}`], { allowFail: true });
-                        if (rebaseRes.code !== 0) {
-                            warnings.push(await this.preserveConflict());
+                    if (remoteRevRes.code === 0) {
+                        const remoteTip = remoteRevRes.stdout.trim();
+                        if (await this.isRemoteAncestorHalted(remoteTip)) {
+                            syncHalted = true;
+                            warnings.push(this.lastError ?? REMOTE_REWRITTEN_MSG);
                         }
-                        const after = (await this.git.run(["rev-parse", "HEAD"])).stdout.trim();
-                        if (before !== after) {
-                            const diffRes = await this.git.run(["diff", "--name-only", before, after]);
-                            await this.resync(extractChangedProjects(diffRes.stdout));
+                    }
+                    if (!syncHalted) {
+                        const behindRes = await this.git.run(["rev-list", "--count", `HEAD..origin/${this.config.gitBranch}`], {
+                            allowFail: true,
+                        });
+                        const behind = Number.parseInt(behindRes.stdout.trim(), 10) || 0;
+                        if (behind > 0) {
+                            const before = (await this.git.run(["rev-parse", "HEAD"])).stdout.trim();
+                            const rebaseRes = await this.git.run(["rebase", `origin/${this.config.gitBranch}`], { allowFail: true });
+                            if (rebaseRes.code !== 0) {
+                                warnings.push(await this.preserveConflict());
+                            }
+                            const after = (await this.git.run(["rev-parse", "HEAD"])).stdout.trim();
+                            if (before !== after) {
+                                const diffRes = await this.git.run(["diff", "--name-only", before, after]);
+                                await this.resync(extractChangedProjects(diffRes.stdout));
+                            }
                         }
                     }
                 }
@@ -399,42 +511,61 @@ export class GitBackend {
                 // Step 4: Push commit if made
                 let pushed = null;
                 if (commitSha !== null && this.hasRemote) {
-                    let pushSuccess = false;
-                    for (let attempt = 0; attempt < 3; attempt++) {
-                        const pushRes = await this.git.run(["push", "origin", `HEAD:refs/heads/${this.config.gitBranch}`], {
-                            allowFail: true,
-                        });
-                        if (pushRes.code === 0) {
-                            pushSuccess = true;
-                            pushed = true;
-                            break;
-                        }
-                        if (isPushRejection(pushRes.stderr)) {
-                            const pre = (await this.git.run(["rev-parse", "HEAD"])).stdout.trim();
-                            await this.git.run(["fetch", "origin", this.config.gitBranch], { allowFail: true });
-                            const rebaseRes = await this.git.run(["rebase", `origin/${this.config.gitBranch}`], { allowFail: true });
-                            if (rebaseRes.code === 0) {
-                                const post = (await this.git.run(["rev-parse", "HEAD"])).stdout.trim();
-                                const diffRes = await this.git.run(["diff", "--name-only", pre, post]);
-                                await this.resync(extractChangedProjects(diffRes.stdout));
+                    if (syncHalted) {
+                        pushed = false;
+                    }
+                    else {
+                        let pushSuccess = false;
+                        for (let attempt = 0; attempt < 3; attempt++) {
+                            const pushRes = await this.git.run(["push", "origin", `HEAD:refs/heads/${this.config.gitBranch}`], {
+                                allowFail: true,
+                            });
+                            if (pushRes.code === 0) {
+                                pushSuccess = true;
+                                pushed = true;
+                                await this.setRememberedRemoteTip(commitSha);
+                                break;
+                            }
+                            if (isPushRejection(pushRes.stderr)) {
+                                const pre = (await this.git.run(["rev-parse", "HEAD"])).stdout.trim();
+                                await this.git.run(["fetch", "origin", this.config.gitBranch], { allowFail: true });
+                                const remoteRevRes = await this.git.run(["rev-parse", "--verify", `origin/${this.config.gitBranch}`], {
+                                    allowFail: true,
+                                });
+                                if (remoteRevRes.code === 0) {
+                                    const remoteTip = remoteRevRes.stdout.trim();
+                                    if (await this.isRemoteAncestorHalted(remoteTip)) {
+                                        pushed = false;
+                                        warnings.push(this.lastError ?? REMOTE_REWRITTEN_MSG);
+                                        break;
+                                    }
+                                }
+                                const rebaseRes = await this.git.run(["rebase", `origin/${this.config.gitBranch}`], {
+                                    allowFail: true,
+                                });
+                                if (rebaseRes.code === 0) {
+                                    const post = (await this.git.run(["rev-parse", "HEAD"])).stdout.trim();
+                                    const diffRes = await this.git.run(["diff", "--name-only", pre, post]);
+                                    await this.resync(extractChangedProjects(diffRes.stdout));
+                                }
+                                else {
+                                    await this.git.run(["rebase", "--abort"], { allowFail: true });
+                                    await this.git.run(["reset", "--hard", `origin/${this.config.gitBranch}`]);
+                                    await this.resync(spec.projects);
+                                    throw new OkfError("upstream_conflict", 409, "change conflicts with a concurrent upstream edit; re-read and retry");
+                                }
                             }
                             else {
-                                await this.git.run(["rebase", "--abort"], { allowFail: true });
-                                await this.git.run(["reset", "--hard", `origin/${this.config.gitBranch}`]);
-                                await this.resync(spec.projects);
-                                throw new OkfError("upstream_conflict", 409, "change conflicts with a concurrent upstream edit; re-read and retry");
+                                pushed = false;
+                                const firstLine = pushRes.stderr.split(/\r?\n/)[0] ?? "unknown error";
+                                warnings.push(`push failed; will retry on next sync: ${firstLine}`);
+                                break;
                             }
                         }
-                        else {
+                        if (!pushSuccess && pushed === null) {
                             pushed = false;
-                            const firstLine = pushRes.stderr.split(/\r?\n/)[0] ?? "unknown error";
-                            warnings.push(`push failed; will retry on next sync: ${firstLine}`);
-                            break;
                         }
                     }
-                    if (!pushSuccess && pushed === null) {
-                        pushed = false;
-                    }
                 }
                 return {
                     value: workRes.value,
@@ -463,6 +594,17 @@ export class GitBackend {
                 this.lastError = fetchRes.stderr.split(/\r?\n/)[0] ?? "fetch failed";
                 return this.syncStatus();
             }
+            const remoteRevRes = await this.git.run(["rev-parse", "--verify", `origin/${this.config.gitBranch}`], {
+                allowFail: true,
+            });
+            if (remoteRevRes.code !== 0) {
+                this.lastError = "remote ref not found";
+                return this.syncStatus();
+            }
+            const remoteTip = remoteRevRes.stdout.trim();
+            if (await this.isRemoteAncestorHalted(remoteTip)) {
+                return this.syncStatus();
+            }
             const behindRes = await this.git.run(["rev-list", "--count", `HEAD..origin/${this.config.gitBranch}`], {
                 allowFail: true,
             });
@@ -491,6 +633,13 @@ export class GitBackend {
                     const pushError = `push failed: ${pushRes.stderr.split(/\r?\n/)[0] ?? "unknown error"}`;
                     runError = runError ? `${runError}; ${pushError}` : pushError;
                 }
+                else {
+                    const headSha = (await this.git.run(["rev-parse", "HEAD"])).stdout.trim();
+                    await this.setRememberedRemoteTip(headSha);
+                }
+            }
+            else {
+                await this.setRememberedRemoteTip(remoteTip);
             }
             // lastError describes the most recent sync run only.
             this.lastError = runError;

package/dist/store/git.js

@@ -1,21 +1,70 @@
 import { spawn } from "node:child_process";
-import { chmod, copyFile, mkdir } from "node:fs/promises";
+import { chmod, copyFile, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { pathExists } from "./fs-util.js";
 export class GitError extends Error {
     args;
     code;
     stderr;
-    constructor(args, code, stderr) {
-        super(`git ${args.join(" ")} failed with exit code ${code}:\n${stderr}`);
+    constructor(args, code, stderr, configuredRemote) {
+        const redactedArgs = redactArgs(args, configuredRemote);
+        const redactedStderr = redactStderr(stderr);
+        super(`git ${redactedArgs.join(" ")} failed with exit code ${code}:\n${redactedStderr}`);
         this.name = "GitError";
-        this.args = args;
+        this.args = redactedArgs;
         this.code = code;
-        this.stderr = stderr;
+        this.stderr = redactedStderr;
     }
 }
 export function redactRemote(url) {
-    return url.replace(/(https?:\/\/)[^/@\s]+@/g, "$1");
+    return url.replace(/([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)[^/@\s]+@/g, "$1");
+}
+export function redactArgs(args, configuredRemote) {
+    const result = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === undefined) {
+            continue;
+        }
+        if (arg === "-m") {
+            result.push("-m");
+            if (i + 1 < args.length) {
+                result.push("<message>");
+                i++;
+            }
+            continue;
+        }
+        if (arg.startsWith("-m") && arg.length > 2) {
+            result.push("-m<message>");
+            continue;
+        }
+        if (arg === "--message") {
+            result.push("--message");
+            if (i + 1 < args.length) {
+                result.push("<message>");
+                i++;
+            }
+            continue;
+        }
+        if (arg.startsWith("--message=")) {
+            result.push("--message=<message>");
+            continue;
+        }
+        if ((configuredRemote && arg === configuredRemote) ||
+            arg.includes("://") ||
+            arg.startsWith("git@") ||
+            /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(arg) ||
+            /(https?:\/\/)[^/@\s]+@/.test(arg)) {
+            result.push(redactRemote(arg));
+            continue;
+        }
+        result.push(arg);
+    }
+    return result;
+}
+export function redactStderr(stderr) {
+    return redactRemote(stderr);
 }
 export function isPushRejection(stderr) {
     return stderr.includes("[rejected]") || stderr.includes("non-fast-forward") || stderr.includes("fetch first");
@@ -50,6 +99,7 @@ export class Git {
     homeDir;
     config;
     env;
+    sshTempDir;
     baseArgs;
     constructor(repoDir, homeDir, config) {
         this.repoDir = repoDir;
@@ -99,31 +149,54 @@ export class Git {
             "-c",
             "core.autocrlf=false",
             "-c",
+            "core.fsmonitor=false",
+            "-c",
+            "protocol.ext.allow=never",
+            "-c",
             "log.showSignature=false",
         ];
+        if (!config.gitHostEnv) {
+            this.baseArgs.push("-c", "core.sshCommand=ssh");
+        }
         if (config.gitHttpUsername && config.gitHttpPassword) {
             this.baseArgs.push("-c", "credential.helper=", "-c", "credential.helper=!f() { echo username=$GIT_HTTP_USERNAME; echo password=$GIT_HTTP_PASSWORD; }; f");
         }
     }
+    get sshKeyPath() {
+        return this.sshTempDir ? join(this.sshTempDir, "id_okf") : undefined;
+    }
+    async close() {
+        if (this.sshTempDir) {
+            try {
+                await rm(this.sshTempDir, { recursive: true, force: true });
+            }
+            finally {
+                this.sshTempDir = undefined;
+            }
+        }
+    }
     async prepareSsh() {
         if (!this.config.gitSshKeyPath) {
             return;
         }
-        const sshDir = join(this.homeDir, ".ssh");
-        await mkdir(sshDir, { recursive: true, mode: 0o700 });
-        const targetKeyPath = join(sshDir, "id_okf");
+        try {
+            await rm(join(this.homeDir, ".ssh", "id_okf"), { force: true });
+        }
+        catch {
+            // Ignore if homeDir or .ssh directory does not exist
+        }
+        if (!this.sshTempDir) {
+            this.sshTempDir = await mkdtemp(join(tmpdir(), "okf-ssh-"));
+            await chmod(this.sshTempDir, 0o700);
+        }
+        const targetKeyPath = join(this.sshTempDir, "id_okf");
         await copyFile(this.config.gitSshKeyPath, targetKeyPath);
         await chmod(targetKeyPath, 0o600);
-        let sshCmd = `ssh -i "${targetKeyPath}" -o IdentitiesOnly=yes -o BatchMode=yes`;
-        // The chart always sets the path; the Secret key is optional, so strict mode requires the file to exist.
         const knownHosts = this.config.gitSshKnownHostsPath;
-        if (knownHosts && (await pathExists(knownHosts))) {
-            sshCmd += ` -o UserKnownHostsFile="${knownHosts}" -o StrictHostKeyChecking=yes`;
-        }
-        else {
-            sshCmd += ` -o UserKnownHostsFile="${join(sshDir, "known_hosts")}" -o StrictHostKeyChecking=accept-new`;
+        if (!knownHosts || !(await pathExists(knownHosts))) {
+            throw new Error(`Configured known_hosts file does not exist: ${knownHosts}`);
         }
-        this.env.GIT_SSH_COMMAND = sshCmd;
+        this.env.GIT_SSH_COMMAND = `ssh -i "${targetKeyPath}" -o IdentitiesOnly=yes -o BatchMode=yes -o UserKnownHostsFile="${knownHosts}" -o StrictHostKeyChecking=yes`;
     }
     run(args, opts) {
         const { promise, resolve, reject } = Promise.withResolvers();
@@ -159,7 +232,7 @@ export class Git {
             const stdout = Buffer.concat(stdoutChunks).toString("utf8");
             const stderr = Buffer.concat(stderrChunks).toString("utf8") + extraStderr;
             if (failed && !opts?.allowFail) {
-                reject(new GitError(args, code, stderr));
+                reject(new GitError(args, code, stderr, this.config.gitRemoteUrl));
             }
             else {
                 resolve({ code, stdout, stderr });
@@ -192,7 +265,7 @@ export class Git {
         });
         child.on("close", (code) => {
             if (code !== 0 && code !== null) {
-                child.stdout.destroy(new GitError(args, code, stderrBuffer));
+                child.stdout.destroy(new GitError(args, code, stderrBuffer, this.config.gitRemoteUrl));
             }
         });
         return child.stdout;

package/dist/ui/assets/bash-BiGZg9Om.js

@@ -0,0 +1 @@
+import{t as e}from"./shellscript-CqHdAlCp.js";export{e as default};