@regressionproof/snapshotter 0.5.3 → 0.5.5

package/build/.spruce/errors/errors.types.d.ts

@@ -6,6 +6,7 @@ export declare namespace SpruceErrors.RegressionproofSnapshotter {
         'command': string;
         'stdout'?: string | undefined | null;
         'stderr'?: string | undefined | null;
+        'version': string;
     }
     interface ExecCommandFailedSchema extends SpruceSchema.Schema {
         id: 'execCommandFailed';
@@ -29,6 +30,12 @@ export declare namespace SpruceErrors.RegressionproofSnapshotter {
                 type: 'text';
                 options: undefined;
             };
+            /** . */
+            'version': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
         };
     }
     type ExecCommandFailedEntity = SchemaEntity<SpruceErrors.RegressionproofSnapshotter.ExecCommandFailedSchema>;

package/build/.spruce/errors/regressionproofSnapshotter/execCommandFailed.schema.js

@@ -23,6 +23,12 @@ const execCommandFailedSchema = {
             type: 'text',
             options: undefined
         },
+        /** . */
+        'version': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
     }
 };
 schema_1.SchemaRegistry.getInstance().trackSchema(execCommandFailedSchema);

package/build/errors/SpruceError.js

@@ -25,7 +25,7 @@ ${options.stderr ?? '<no stderr>'}`;
         const fullMessage = options.friendlyMessage
             ? options.friendlyMessage
             : message;
-        return fullMessage;
+        return `${fullMessage} (v${options.version})`;
     }
 }
 exports.default = SpruceError;

package/build/errors/execCommandFailed.builder.d.ts

@@ -13,6 +13,10 @@ declare const _default: {
         stderr: {
             type: "text";
         };
+        version: {
+            type: "text";
+            isRequired: true;
+        };
     };
 };
 export default _default;

package/build/errors/execCommandFailed.builder.js

@@ -16,5 +16,9 @@ exports.default = (0, schema_1.buildErrorSchema)({
         stderr: {
             type: 'text',
         },
+        version: {
+            type: 'text',
+            isRequired: true,
+        },
     },
 });

package/build/esm/.spruce/errors/errors.types.d.ts

@@ -6,6 +6,7 @@ export declare namespace SpruceErrors.RegressionproofSnapshotter {
         'command': string;
         'stdout'?: string | undefined | null;
         'stderr'?: string | undefined | null;
+        'version': string;
     }
     interface ExecCommandFailedSchema extends SpruceSchema.Schema {
         id: 'execCommandFailed';
@@ -29,6 +30,12 @@ export declare namespace SpruceErrors.RegressionproofSnapshotter {
                 type: 'text';
                 options: undefined;
             };
+            /** . */
+            'version': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
         };
     }
     type ExecCommandFailedEntity = SchemaEntity<SpruceErrors.RegressionproofSnapshotter.ExecCommandFailedSchema>;

package/build/esm/errors/SpruceError.js

@@ -21,6 +21,6 @@ ${(_b = options.stderr) !== null && _b !== void 0 ? _b : '<no stderr>'}`;
         const fullMessage = options.friendlyMessage
             ? options.friendlyMessage
             : message;
-        return fullMessage;
+        return `${fullMessage} (v${options.version})`;
     }
 }

package/build/esm/errors/execCommandFailed.builder.d.ts

@@ -13,6 +13,10 @@ declare const _default: {
         stderr: {
             type: "text";
         };
+        version: {
+            type: "text";
+            isRequired: true;
+        };
     };
 };
 export default _default;

package/build/esm/errors/execCommandFailed.builder.js

@@ -14,5 +14,9 @@ export default buildErrorSchema({
         stderr: {
             type: 'text',
         },
+        version: {
+            type: 'text',
+            isRequired: true,
+        },
     },
 });

package/build/esm/git.js

@@ -8,10 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { exec } from 'child_process';
-import { existsSync } from 'fs';
+import { existsSync, unlinkSync } from 'fs';
 import path from 'path';
 import { promisify } from 'util';
 import SpruceError from './errors/SpruceError.js.js';
+import { getPackageVersion } from './utilities/version.js.js';
 const execAsync = promisify(exec);
 export function gitCommit(mirrorPath, log) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -19,6 +20,7 @@ export function gitCommit(mirrorPath, log) {
         if (!existsSync(gitDir)) {
             yield execOrThrow(`git -C "${mirrorPath}" init`, log);
         }
+        cleanupGitLockFiles(mirrorPath, log);
         yield execOrThrow(`git -C "${mirrorPath}" add -A`, log);
         const { stdout } = yield execOrThrow(`git -C "${mirrorPath}" status --porcelain`);
         if (!stdout.trim()) {
@@ -32,44 +34,73 @@ export function gitCommit(mirrorPath, log) {
 }
 export function gitPush(mirrorPath, remote, log) {
     return __awaiter(this, void 0, void 0, function* () {
+        cleanupGitLockFiles(mirrorPath, log);
         const authedUrl = remote.url.replace('://', `://${remote.token}@`);
-        const originExists = yield remoteExists(mirrorPath, 'origin');
-        if (originExists) {
-            yield execOrThrow(`git -C "${mirrorPath}" remote set-url origin "${authedUrl}"`);
-        }
-        else {
+        const currentUrl = yield getRemoteUrl(mirrorPath, 'origin');
+        if (currentUrl === null) {
             yield execOrThrow(`git -C "${mirrorPath}" remote add origin "${authedUrl}"`);
         }
-        yield execOrThrow(`git -C "${mirrorPath}" fetch origin`, log);
-        if (yield hasRemoteHead(mirrorPath)) {
-            yield execOrThrow(`git -C "${mirrorPath}" rebase origin/HEAD`, log);
+        else if (currentUrl !== authedUrl) {
+            yield execOrThrow(`git -C "${mirrorPath}" remote set-url origin "${authedUrl}"`);
         }
+        yield pullFromRemote(mirrorPath, log);
         yield execOrThrow(`git -C "${mirrorPath}" push -u origin HEAD`, log);
     });
 }
-function remoteExists(mirrorPath, remoteName) {
+function pullFromRemote(mirrorPath, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield execOrThrow(`git -C "${mirrorPath}" fetch origin`, log);
+        const branch = yield getCurrentBranch(mirrorPath);
+        const remoteBranchExists = yield checkRemoteBranchExists(mirrorPath, branch);
+        if (remoteBranchExists) {
+            yield execOrThrow(`git -C "${mirrorPath}" rebase origin/${branch}`, log);
+        }
+    });
+}
+function getCurrentBranch(mirrorPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { stdout } = yield execAsync(`git -C "${mirrorPath}" rev-parse --abbrev-ref HEAD`);
+        return stdout.trim();
+    });
+}
+function checkRemoteBranchExists(mirrorPath, branch) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            const { stdout } = yield execAsync(`git -C "${mirrorPath}" remote`);
-            const remotes = stdout.trim().split('\n');
-            return remotes.includes(remoteName);
+            const { stdout } = yield execAsync(`git -C "${mirrorPath}" ls-remote --heads origin ${branch}`);
+            return stdout.trim().length > 0;
         }
         catch (_a) {
             return false;
         }
     });
 }
-function hasRemoteHead(mirrorPath) {
+function getRemoteUrl(mirrorPath, remoteName) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            yield execAsync(`git -C "${mirrorPath}" symbolic-ref -q refs/remotes/origin/HEAD`);
-            return true;
+            const { stdout } = yield execAsync(`git -C "${mirrorPath}" remote get-url ${remoteName}`);
+            return stdout.trim();
         }
         catch (_a) {
-            return false;
+            return null;
         }
     });
 }
+function cleanupGitLockFiles(mirrorPath, log) {
+    var _a;
+    const lockFiles = ['config.lock', 'index.lock', 'HEAD.lock'];
+    for (const lockFile of lockFiles) {
+        const lockPath = path.join(mirrorPath, '.git', lockFile);
+        if (existsSync(lockPath)) {
+            try {
+                unlinkSync(lockPath);
+                log === null || log === void 0 ? void 0 : log.info(`Removed stale lock file: ${lockFile}`);
+            }
+            catch (_b) {
+                (_a = log === null || log === void 0 ? void 0 : log.warn) === null || _a === void 0 ? void 0 : _a.call(log, `Failed to remove lock file: ${lockFile}`);
+            }
+        }
+    }
+}
 function execOrThrow(command, log) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b;
@@ -86,6 +117,7 @@ function execOrThrow(command, log) {
                 command,
                 stdout,
                 stderr,
+                version: getPackageVersion(),
             });
         }
     });

package/build/esm/utilities/version.d.ts

@@ -0,0 +1 @@
+export declare function getPackageVersion(): string;

package/build/esm/utilities/version.js

@@ -0,0 +1,13 @@
+import { readFileSync } from 'node:fs';
+import path from 'path';
+export function getPackageVersion() {
+    var _a;
+    try {
+        const packagePath = path.join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        return (_a = packageJson.version) !== null && _a !== void 0 ? _a : '*** unable to resolve version ***';
+    }
+    catch (_b) {
+        return '*** unable to resolve version ***';
+    }
+}

package/build/git.js

@@ -10,12 +10,14 @@ const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const util_1 = require("util");
 const SpruceError_js_1 = __importDefault(require("./errors/SpruceError.js"));
+const version_js_1 = require("./utilities/version.js");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 async function gitCommit(mirrorPath, log) {
     const gitDir = path_1.default.join(mirrorPath, '.git');
     if (!(0, fs_1.existsSync)(gitDir)) {
         await execOrThrow(`git -C "${mirrorPath}" init`, log);
     }
+    cleanupGitLockFiles(mirrorPath, log);
     await execOrThrow(`git -C "${mirrorPath}" add -A`, log);
     const { stdout } = await execOrThrow(`git -C "${mirrorPath}" status --porcelain`);
     if (!stdout.trim()) {
@@ -27,37 +29,61 @@ async function gitCommit(mirrorPath, log) {
     return true;
 }
 async function gitPush(mirrorPath, remote, log) {
+    cleanupGitLockFiles(mirrorPath, log);
     const authedUrl = remote.url.replace('://', `://${remote.token}@`);
-    const originExists = await remoteExists(mirrorPath, 'origin');
-    if (originExists) {
-        await execOrThrow(`git -C "${mirrorPath}" remote set-url origin "${authedUrl}"`);
-    }
-    else {
+    const currentUrl = await getRemoteUrl(mirrorPath, 'origin');
+    if (currentUrl === null) {
         await execOrThrow(`git -C "${mirrorPath}" remote add origin "${authedUrl}"`);
     }
-    await execOrThrow(`git -C "${mirrorPath}" fetch origin`, log);
-    if (await hasRemoteHead(mirrorPath)) {
-        await execOrThrow(`git -C "${mirrorPath}" rebase origin/HEAD`, log);
+    else if (currentUrl !== authedUrl) {
+        await execOrThrow(`git -C "${mirrorPath}" remote set-url origin "${authedUrl}"`);
     }
+    await pullFromRemote(mirrorPath, log);
     await execOrThrow(`git -C "${mirrorPath}" push -u origin HEAD`, log);
 }
-async function remoteExists(mirrorPath, remoteName) {
+async function pullFromRemote(mirrorPath, log) {
+    await execOrThrow(`git -C "${mirrorPath}" fetch origin`, log);
+    const branch = await getCurrentBranch(mirrorPath);
+    const remoteBranchExists = await checkRemoteBranchExists(mirrorPath, branch);
+    if (remoteBranchExists) {
+        await execOrThrow(`git -C "${mirrorPath}" rebase origin/${branch}`, log);
+    }
+}
+async function getCurrentBranch(mirrorPath) {
+    const { stdout } = await execAsync(`git -C "${mirrorPath}" rev-parse --abbrev-ref HEAD`);
+    return stdout.trim();
+}
+async function checkRemoteBranchExists(mirrorPath, branch) {
     try {
-        const { stdout } = await execAsync(`git -C "${mirrorPath}" remote`);
-        const remotes = stdout.trim().split('\n');
-        return remotes.includes(remoteName);
+        const { stdout } = await execAsync(`git -C "${mirrorPath}" ls-remote --heads origin ${branch}`);
+        return stdout.trim().length > 0;
     }
     catch {
         return false;
     }
 }
-async function hasRemoteHead(mirrorPath) {
+async function getRemoteUrl(mirrorPath, remoteName) {
     try {
-        await execAsync(`git -C "${mirrorPath}" symbolic-ref -q refs/remotes/origin/HEAD`);
-        return true;
+        const { stdout } = await execAsync(`git -C "${mirrorPath}" remote get-url ${remoteName}`);
+        return stdout.trim();
     }
     catch {
-        return false;
+        return null;
+    }
+}
+function cleanupGitLockFiles(mirrorPath, log) {
+    const lockFiles = ['config.lock', 'index.lock', 'HEAD.lock'];
+    for (const lockFile of lockFiles) {
+        const lockPath = path_1.default.join(mirrorPath, '.git', lockFile);
+        if ((0, fs_1.existsSync)(lockPath)) {
+            try {
+                (0, fs_1.unlinkSync)(lockPath);
+                log?.info(`Removed stale lock file: ${lockFile}`);
+            }
+            catch {
+                log?.warn?.(`Failed to remove lock file: ${lockFile}`);
+            }
+        }
     }
 }
 async function execOrThrow(command, log) {
@@ -74,6 +100,7 @@ async function execOrThrow(command, log) {
             command,
             stdout,
             stderr,
+            version: (0, version_js_1.getPackageVersion)(),
         });
     }
 }

package/build/utilities/version.d.ts

@@ -0,0 +1 @@
+export declare function getPackageVersion(): string;

package/build/utilities/version.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = getPackageVersion;
+const node_fs_1 = require("node:fs");
+const path_1 = __importDefault(require("path"));
+function getPackageVersion() {
+    try {
+        const packagePath = path_1.default.join(__dirname, '../../package.json');
+        const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packagePath, 'utf-8'));
+        return packageJson.version ?? '*** unable to resolve version ***';
+    }
+    catch {
+        return '*** unable to resolve version ***';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@regressionproof/snapshotter",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "publishConfig": {
     "access": "public"
   },
@@ -94,5 +94,5 @@
     "@sprucelabs/spruce-core-schemas": "^42.1.3",
     "@sprucelabs/spruce-skill-utils": "^34.0.3"
   },
-  "gitHead": "d54c041a4d6b4cd88d35025ef1ee6d9acb6ad664"
+  "gitHead": "960e13b1ccdd3227d7e0aad8451e6eb851189746"
 }