@regressionproof/snapshotter 0.8.0 → 0.9.1

package/build/GitCommandRunner.d.ts

@@ -0,0 +1,10 @@
+export default class GitCommandRunner {
+    exec(command: string): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    execOrThrow(command: string): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+}

package/build/GitCommandRunner.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const SpruceError_1 = __importDefault(require("./errors/SpruceError"));
+const version_1 = require("./utilities/version");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class GitCommandRunner {
+    async exec(command) {
+        return await execAsync(command);
+    }
+    async execOrThrow(command) {
+        try {
+            return await execAsync(command);
+        }
+        catch (err) {
+            const error = err;
+            const stdout = error.stdout ?? '';
+            const stderr = error.stderr ?? '';
+            throw new SpruceError_1.default({
+                code: 'EXEC_COMMAND_FAILED',
+                command,
+                stdout,
+                stderr,
+                version: (0, version_1.getPackageVersion)(),
+            });
+        }
+    }
+}
+exports.default = GitCommandRunner;

package/build/MirrorSyncer.d.ts

@@ -0,0 +1,10 @@
+export default class MirrorSyncer {
+    private commandRunner;
+    syncBlocking(mirrorPath: string): Promise<void>;
+    /**
+     * Fire-and-forget sync to avoid slowing down callers like doctor --fix.
+     */
+    syncInBackground(mirrorPath: string): void;
+    private getCurrentBranch;
+    private checkRemoteBranchExists;
+}

package/build/MirrorSyncer.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const GitCommandRunner_1 = __importDefault(require("./GitCommandRunner"));
+class MirrorSyncer {
+    constructor() {
+        this.commandRunner = new GitCommandRunner_1.default();
+    }
+    async syncBlocking(mirrorPath) {
+        await this.commandRunner.execOrThrow(`git -C "${mirrorPath}" fetch origin`);
+        const branch = await this.getCurrentBranch(mirrorPath);
+        const remoteBranchExists = await this.checkRemoteBranchExists(mirrorPath, branch);
+        if (remoteBranchExists) {
+            await this.commandRunner.execOrThrow(`git -C "${mirrorPath}" rebase -X theirs origin/${branch}`);
+        }
+    }
+    /**
+     * Fire-and-forget sync to avoid slowing down callers like doctor --fix.
+     */
+    syncInBackground(mirrorPath) {
+        void this.syncBlocking(mirrorPath);
+    }
+    async getCurrentBranch(mirrorPath) {
+        const { stdout } = await this.commandRunner.exec(`git -C "${mirrorPath}" rev-parse --abbrev-ref HEAD`);
+        return stdout.trim();
+    }
+    async checkRemoteBranchExists(mirrorPath, branch) {
+        try {
+            const { stdout } = await this.commandRunner.exec(`git -C "${mirrorPath}" ls-remote --heads origin ${branch}`);
+            return stdout.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.default = MirrorSyncer;

package/build/Snapshotter.d.ts

@@ -1,4 +1,4 @@
-import { SnapshotOptions } from './snapshotter.types.js';
+import { SnapshotOptions } from './snapshotter.types';
 export default class Snapshotter {
     private strategy;
     private constructor();

package/build/Snapshotter.js

@@ -3,23 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ErrorHandler_js_1 = __importDefault(require("./components/ErrorHandler.js"));
-const AsyncStrategy_js_1 = __importDefault(require("./strategies/AsyncStrategy.js"));
-const SyncStrategy_js_1 = __importDefault(require("./strategies/SyncStrategy.js"));
+const ErrorHandler_1 = __importDefault(require("./components/ErrorHandler"));
+const AsyncStrategy_1 = __importDefault(require("./strategies/AsyncStrategy"));
+const SyncStrategy_1 = __importDefault(require("./strategies/SyncStrategy"));
 class Snapshotter {
     constructor(strategy) {
         this.strategy = strategy;
     }
     static Snapshotter(options) {
         const mode = options?.mode ?? 'async';
-        const strategy = mode === 'sync' ? SyncStrategy_js_1.default.Strategy() : AsyncStrategy_js_1.default.Strategy();
+        const strategy = mode === 'sync' ? SyncStrategy_1.default.Strategy() : AsyncStrategy_1.default.Strategy();
         return new this(strategy);
     }
     snapshot(options) {
         return this.strategy.execute(options);
     }
     checkForPreviousFailure(mirrorPath) {
-        ErrorHandler_js_1.default.Handler().checkForPreviousFailure(mirrorPath);
+        ErrorHandler_1.default.Handler().checkForPreviousFailure(mirrorPath);
     }
 }
 exports.default = Snapshotter;

package/build/components/ErrorHandler.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
-const SnapshotterState_js_1 = __importDefault(require("../utilities/SnapshotterState.js"));
+const SnapshotterState_1 = __importDefault(require("../utilities/SnapshotterState"));
 class ErrorHandler {
     constructor() { }
     static Handler() {
@@ -23,7 +23,7 @@ class ErrorHandler {
         }
     }
     persistError(mirrorPath, err) {
-        SnapshotterState_js_1.default.EnsureStateDir(mirrorPath);
+        SnapshotterState_1.default.EnsureStateDir(mirrorPath);
         const errorPath = this.getErrorFilePath(mirrorPath);
         const errorData = {
             message: err instanceof Error ? err.message : String(err),
@@ -39,7 +39,7 @@ class ErrorHandler {
         }
     }
     getErrorFilePath(mirrorPath) {
-        const stateDir = SnapshotterState_js_1.default.GetStateDir(mirrorPath);
+        const stateDir = SnapshotterState_1.default.GetStateDir(mirrorPath);
         return path_1.default.join(stateDir, ErrorHandler.ERROR_FILE_NAME);
     }
 }

package/build/components/TestResultsWriter.d.ts

@@ -1,4 +1,4 @@
-import { TestResults } from '../snapshotter.types.js';
+import { TestResults } from '../snapshotter.types';
 export default class TestResultsWriter {
     private constructor();
     static Writer(): TestResultsWriter;

package/build/esm/GitCommandRunner.d.ts

@@ -0,0 +1,10 @@
+export default class GitCommandRunner {
+    exec(command: string): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    execOrThrow(command: string): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+}

package/build/esm/GitCommandRunner.js

@@ -0,0 +1,41 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import SpruceError from './errors/SpruceError.js';
+import { getPackageVersion } from './utilities/version.js';
+const execAsync = promisify(exec);
+export default class GitCommandRunner {
+    exec(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield execAsync(command);
+        });
+    }
+    execOrThrow(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                return yield execAsync(command);
+            }
+            catch (err) {
+                const error = err;
+                const stdout = (_a = error.stdout) !== null && _a !== void 0 ? _a : '';
+                const stderr = (_b = error.stderr) !== null && _b !== void 0 ? _b : '';
+                throw new SpruceError({
+                    code: 'EXEC_COMMAND_FAILED',
+                    command,
+                    stdout,
+                    stderr,
+                    version: getPackageVersion(),
+                });
+            }
+        });
+    }
+}

package/build/esm/MirrorSyncer.d.ts

@@ -0,0 +1,10 @@
+export default class MirrorSyncer {
+    private commandRunner;
+    syncBlocking(mirrorPath: string): Promise<void>;
+    /**
+     * Fire-and-forget sync to avoid slowing down callers like doctor --fix.
+     */
+    syncInBackground(mirrorPath: string): void;
+    private getCurrentBranch;
+    private checkRemoteBranchExists;
+}

package/build/esm/MirrorSyncer.js

@@ -0,0 +1,48 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import GitCommandRunner from './GitCommandRunner.js';
+export default class MirrorSyncer {
+    constructor() {
+        this.commandRunner = new GitCommandRunner();
+    }
+    syncBlocking(mirrorPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.commandRunner.execOrThrow(`git -C "${mirrorPath}" fetch origin`);
+            const branch = yield this.getCurrentBranch(mirrorPath);
+            const remoteBranchExists = yield this.checkRemoteBranchExists(mirrorPath, branch);
+            if (remoteBranchExists) {
+                yield this.commandRunner.execOrThrow(`git -C "${mirrorPath}" rebase -X theirs origin/${branch}`);
+            }
+        });
+    }
+    /**
+     * Fire-and-forget sync to avoid slowing down callers like doctor --fix.
+     */
+    syncInBackground(mirrorPath) {
+        void this.syncBlocking(mirrorPath);
+    }
+    getCurrentBranch(mirrorPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { stdout } = yield this.commandRunner.exec(`git -C "${mirrorPath}" rev-parse --abbrev-ref HEAD`);
+            return stdout.trim();
+        });
+    }
+    checkRemoteBranchExists(mirrorPath, branch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { stdout } = yield this.commandRunner.exec(`git -C "${mirrorPath}" ls-remote --heads origin ${branch}`);
+                return stdout.trim().length > 0;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+}

package/build/esm/Snapshotter.d.ts

@@ -1,4 +1,4 @@
-import { SnapshotOptions } from './snapshotter.types.js';
+import { SnapshotOptions } from './snapshotter.types';
 export default class Snapshotter {
     private strategy;
     private constructor();

package/build/esm/Snapshotter.js

@@ -1,6 +1,6 @@
-import ErrorHandler from './components/ErrorHandler.js.js';
-import AsyncStrategy from './strategies/AsyncStrategy.js.js';
-import SyncStrategy from './strategies/SyncStrategy.js.js';
+import ErrorHandler from './components/ErrorHandler.js';
+import AsyncStrategy from './strategies/AsyncStrategy.js';
+import SyncStrategy from './strategies/SyncStrategy.js';
 export default class Snapshotter {
     constructor(strategy) {
         this.strategy = strategy;

package/build/esm/components/ErrorHandler.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import path from 'path';
-import SnapshotterState from '../utilities/SnapshotterState.js.js';
+import SnapshotterState from '../utilities/SnapshotterState.js';
 class ErrorHandler {
     constructor() { }
     static Handler() {

package/build/esm/components/TestResultsWriter.d.ts

@@ -1,4 +1,4 @@
-import { TestResults } from '../snapshotter.types.js';
+import { TestResults } from '../snapshotter.types';
 export default class TestResultsWriter {
     private constructor();
     static Writer(): TestResultsWriter;

package/build/esm/git.d.ts

@@ -1,4 +1,4 @@
 import { Log } from '@sprucelabs/spruce-skill-utils';
-import { RemoteOptions } from './snapshotter.types.js';
+import { RemoteOptions } from './snapshotter.types';
 export declare function gitCommit(mirrorPath: string, log?: Log): Promise<boolean>;
 export declare function gitPush(mirrorPath: string, remote: RemoteOptions, log?: Log): Promise<void>;

package/build/esm/git.js

@@ -7,13 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { exec } from 'child_process';
 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);
+import GitCommandRunner from './GitCommandRunner.js';
+import MirrorSyncer from './MirrorSyncer.js';
+const mirrorSyncer = new MirrorSyncer();
+const commandRunner = new GitCommandRunner();
 export function gitCommit(mirrorPath, log) {
     return __awaiter(this, void 0, void 0, function* () {
         const gitDir = path.join(mirrorPath, '.git');
@@ -48,36 +47,21 @@ export function gitPush(mirrorPath, remote, log) {
     });
 }
 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 -X theirs 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}" ls-remote --heads origin ${branch}`);
-            return stdout.trim().length > 0;
+            yield mirrorSyncer.syncBlocking(mirrorPath);
         }
-        catch (_a) {
-            return false;
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log === null || log === void 0 ? void 0 : log.error('Mirror sync failed', message);
+            throw err;
         }
     });
 }
 function getRemoteUrl(mirrorPath, remoteName) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            const { stdout } = yield execAsync(`git -C "${mirrorPath}" remote get-url ${remoteName}`);
+            const { stdout } = yield commandRunner.exec(`git -C "${mirrorPath}" remote get-url ${remoteName}`);
             return stdout.trim();
         }
         catch (_a) {
@@ -103,22 +87,14 @@ function cleanupGitLockFiles(mirrorPath, log) {
 }
 function execOrThrow(command, log) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+        var _a;
         try {
-            return yield execAsync(command);
+            return yield commandRunner.execOrThrow(command);
         }
         catch (err) {
             const error = err;
-            const stdout = (_a = error.stdout) !== null && _a !== void 0 ? _a : '';
-            const stderr = (_b = error.stderr) !== null && _b !== void 0 ? _b : '';
-            log === null || log === void 0 ? void 0 : log.error('Command failed', command, stderr);
-            throw new SpruceError({
-                code: 'EXEC_COMMAND_FAILED',
-                command,
-                stdout,
-                stderr,
-                version: getPackageVersion(),
-            });
+            log === null || log === void 0 ? void 0 : log.error('Command failed', command, (_a = error.stderr) !== null && _a !== void 0 ? _a : error.message);
+            throw err;
         }
     });
 }

package/build/esm/index.d.ts

@@ -1,3 +1,4 @@
-export { default as Snapshotter } from './Snapshotter.js';
-export type { SnapshotterOptions } from './Snapshotter.js';
-export * from './snapshotter.types.js';
+export { default as Snapshotter } from './Snapshotter';
+export type { SnapshotterOptions } from './Snapshotter';
+export * from './snapshotter.types';
+export { default as MirrorSyncer } from './MirrorSyncer';

package/build/esm/index.js

@@ -1,2 +1,3 @@
-export { default as Snapshotter } from './Snapshotter.js.js';
-export * from './snapshotter.types.js.js';
+export { default as Snapshotter } from './Snapshotter.js';
+export * from './snapshotter.types.js';
+export { default as MirrorSyncer } from './MirrorSyncer.js';

package/build/esm/scripts/runPush.js

@@ -10,9 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { existsSync, unlinkSync, writeFileSync } from 'fs';
 import path from 'path';
 import { buildLog } from '@sprucelabs/spruce-skill-utils';
-import ErrorHandler from '../components/ErrorHandler.js.js';
-import { gitPush } from '../git.js.js';
-import SnapshotterState from '../utilities/SnapshotterState.js.js';
+import ErrorHandler from '../components/ErrorHandler.js';
+import { gitPush } from '../git.js';
+import SnapshotterState from '../utilities/SnapshotterState.js';
 const LOCK_FILE_NAME = 'push.lock';
 const PENDING_FILE_NAME = 'push.pending';
 const log = buildLog('Snapshotter');

package/build/esm/scripts/runSnapshot.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import path from 'path';
 import { buildLog } from '@sprucelabs/spruce-skill-utils';
-import ErrorHandler from '../components/ErrorHandler.js.js';
-import SyncStrategy from '../strategies/SyncStrategy.js.js';
+import ErrorHandler from '../components/ErrorHandler.js';
+import SyncStrategy from '../strategies/SyncStrategy.js';
 const LOCK_FILE_NAME = 'snapshot.lock';
 const PENDING_FILE_NAME = 'pending.json';
 const log = buildLog('Snapshotter');

package/build/esm/strategies/AsyncStrategy.d.ts

@@ -1,5 +1,5 @@
-import { SnapshotOptions } from '../snapshotter.types.js';
-import SnapshotStrategy from './SnapshotStrategy.js';
+import { SnapshotOptions } from '../snapshotter.types';
+import SnapshotStrategy from './SnapshotStrategy';
 export default class AsyncStrategy implements SnapshotStrategy {
     private log;
     private scriptPath;

package/build/esm/strategies/AsyncStrategy.js

@@ -2,11 +2,11 @@ import { spawn } from 'child_process';
 import { writeFileSync } from 'fs';
 import path from 'path';
 import { buildLog } from '@sprucelabs/spruce-skill-utils';
-import SnapshotterState from '../utilities/SnapshotterState.js.js';
+import SnapshotterState from '../utilities/SnapshotterState.js';
 export default class AsyncStrategy {
     constructor() {
         this.log = buildLog('Snapshotter');
-        this.scriptPath = path.join(__dirname, '..', 'scripts', 'runSnapshot.js');
+        this.scriptPath = path.join(__dirname, '..', 'scripts', 'runSnapshot');
     }
     static Strategy() {
         return new this();

package/build/esm/strategies/SnapshotStrategy.d.ts

@@ -1,4 +1,4 @@
-import { SnapshotOptions } from '../snapshotter.types.js';
+import { SnapshotOptions } from '../snapshotter.types';
 export default interface SnapshotStrategy {
     execute(options: SnapshotOptions): Promise<void> | void;
 }

package/build/esm/strategies/SyncStrategy.d.ts

@@ -1,5 +1,5 @@
-import { SnapshotOptions } from '../snapshotter.types.js';
-import SnapshotStrategy from './SnapshotStrategy.js';
+import { SnapshotOptions } from '../snapshotter.types';
+import SnapshotStrategy from './SnapshotStrategy';
 export default class SyncStrategy implements SnapshotStrategy {
     private log;
     private pushScriptPath;

package/build/esm/strategies/SyncStrategy.js

@@ -10,15 +10,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { spawn } from 'child_process';
 import path from 'path';
 import { buildLog } from '@sprucelabs/spruce-skill-utils';
-import ErrorHandler from '../components/ErrorHandler.js.js';
-import FileSyncer from '../components/FileSyncer.js.js';
-import TestResultsWriter from '../components/TestResultsWriter.js.js';
-import { gitCommit } from '../git.js.js';
-import SnapshotterState from '../utilities/SnapshotterState.js.js';
+import ErrorHandler from '../components/ErrorHandler.js';
+import FileSyncer from '../components/FileSyncer.js';
+import TestResultsWriter from '../components/TestResultsWriter.js';
+import { gitCommit } from '../git.js';
+import SnapshotterState from '../utilities/SnapshotterState.js';
 export default class SyncStrategy {
     constructor() {
         this.log = buildLog('Snapshotter');
-        this.pushScriptPath = path.join(__dirname, '..', 'scripts', 'runPush.js');
+        this.pushScriptPath = path.join(__dirname, '..', 'scripts', 'runPush');
     }
     static Strategy() {
         return new this();

package/build/git.d.ts

@@ -1,4 +1,4 @@
 import { Log } from '@sprucelabs/spruce-skill-utils';
-import { RemoteOptions } from './snapshotter.types.js';
+import { RemoteOptions } from './snapshotter.types';
 export declare function gitCommit(mirrorPath: string, log?: Log): Promise<boolean>;
 export declare function gitPush(mirrorPath: string, remote: RemoteOptions, log?: Log): Promise<void>;

package/build/git.js

@@ -5,13 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitCommit = gitCommit;
 exports.gitPush = gitPush;
-const child_process_1 = require("child_process");
 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);
+const GitCommandRunner_1 = __importDefault(require("./GitCommandRunner"));
+const MirrorSyncer_1 = __importDefault(require("./MirrorSyncer"));
+const mirrorSyncer = new MirrorSyncer_1.default();
+const commandRunner = new GitCommandRunner_1.default();
 async function gitCommit(mirrorPath, log) {
     const gitDir = path_1.default.join(mirrorPath, '.git');
     if (!(0, fs_1.existsSync)(gitDir)) {
@@ -42,29 +41,18 @@ async function gitPush(mirrorPath, remote, log) {
     await execOrThrow(`git -C "${mirrorPath}" push -u origin HEAD`, log);
 }
 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 -X theirs 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}" ls-remote --heads origin ${branch}`);
-        return stdout.trim().length > 0;
+        await mirrorSyncer.syncBlocking(mirrorPath);
     }
-    catch {
-        return false;
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log?.error('Mirror sync failed', message);
+        throw err;
     }
 }
 async function getRemoteUrl(mirrorPath, remoteName) {
     try {
-        const { stdout } = await execAsync(`git -C "${mirrorPath}" remote get-url ${remoteName}`);
+        const { stdout } = await commandRunner.exec(`git -C "${mirrorPath}" remote get-url ${remoteName}`);
         return stdout.trim();
     }
     catch {
@@ -88,19 +76,11 @@ function cleanupGitLockFiles(mirrorPath, log) {
 }
 async function execOrThrow(command, log) {
     try {
-        return await execAsync(command);
+        return await commandRunner.execOrThrow(command);
     }
     catch (err) {
         const error = err;
-        const stdout = error.stdout ?? '';
-        const stderr = error.stderr ?? '';
-        log?.error('Command failed', command, stderr);
-        throw new SpruceError_js_1.default({
-            code: 'EXEC_COMMAND_FAILED',
-            command,
-            stdout,
-            stderr,
-            version: (0, version_js_1.getPackageVersion)(),
-        });
+        log?.error('Command failed', command, error.stderr ?? error.message);
+        throw err;
     }
 }

package/build/index.d.ts

@@ -1,3 +1,4 @@
-export { default as Snapshotter } from './Snapshotter.js';
-export type { SnapshotterOptions } from './Snapshotter.js';
-export * from './snapshotter.types.js';
+export { default as Snapshotter } from './Snapshotter';
+export type { SnapshotterOptions } from './Snapshotter';
+export * from './snapshotter.types';
+export { default as MirrorSyncer } from './MirrorSyncer';

package/build/index.js

@@ -17,7 +17,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Snapshotter = void 0;
-var Snapshotter_js_1 = require("./Snapshotter.js");
-Object.defineProperty(exports, "Snapshotter", { enumerable: true, get: function () { return __importDefault(Snapshotter_js_1).default; } });
-__exportStar(require("./snapshotter.types.js"), exports);
+exports.MirrorSyncer = exports.Snapshotter = void 0;
+var Snapshotter_1 = require("./Snapshotter");
+Object.defineProperty(exports, "Snapshotter", { enumerable: true, get: function () { return __importDefault(Snapshotter_1).default; } });
+__exportStar(require("./snapshotter.types"), exports);
+var MirrorSyncer_1 = require("./MirrorSyncer");
+Object.defineProperty(exports, "MirrorSyncer", { enumerable: true, get: function () { return __importDefault(MirrorSyncer_1).default; } });

package/build/scripts/runPush.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
-const ErrorHandler_js_1 = __importDefault(require("../components/ErrorHandler.js"));
-const git_js_1 = require("../git.js");
-const SnapshotterState_js_1 = __importDefault(require("../utilities/SnapshotterState.js"));
+const ErrorHandler_1 = __importDefault(require("../components/ErrorHandler"));
+const git_1 = require("../git");
+const SnapshotterState_1 = __importDefault(require("../utilities/SnapshotterState"));
 const LOCK_FILE_NAME = 'push.lock';
 const PENDING_FILE_NAME = 'push.pending';
 const log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
@@ -16,7 +16,7 @@ async function main() {
     const mirrorPath = getEnvOrExit('MIRROR_PATH');
     const remoteUrl = getEnvOrExit('REMOTE_URL');
     const remoteToken = getEnvOrExit('REMOTE_TOKEN');
-    const stateDir = SnapshotterState_js_1.default.EnsureStateDir(mirrorPath);
+    const stateDir = SnapshotterState_1.default.EnsureStateDir(mirrorPath);
     const lockPath = path_1.default.join(stateDir, LOCK_FILE_NAME);
     const pendingPath = path_1.default.join(stateDir, PENDING_FILE_NAME);
     if ((0, fs_1.existsSync)(lockPath)) {
@@ -45,14 +45,14 @@ async function processLoop(mirrorPath, remote, pendingPath) {
         }
         try {
             log.info('Push starting', remote.url);
-            await (0, git_js_1.gitPush)(mirrorPath, remote, log);
+            await (0, git_1.gitPush)(mirrorPath, remote, log);
             log.info('Push completed', remote.url);
-            ErrorHandler_js_1.default.Handler().clearError(mirrorPath);
+            ErrorHandler_1.default.Handler().clearError(mirrorPath);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             log.error('Push failed', message);
-            ErrorHandler_js_1.default.Handler().persistError(mirrorPath, err);
+            ErrorHandler_1.default.Handler().persistError(mirrorPath, err);
             (0, fs_1.writeFileSync)(pendingPath, new Date().toISOString());
             return;
         }

package/build/scripts/runSnapshot.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
-const ErrorHandler_js_1 = __importDefault(require("../components/ErrorHandler.js"));
-const SyncStrategy_js_1 = __importDefault(require("../strategies/SyncStrategy.js"));
+const ErrorHandler_1 = __importDefault(require("../components/ErrorHandler"));
+const SyncStrategy_1 = __importDefault(require("../strategies/SyncStrategy"));
 const LOCK_FILE_NAME = 'snapshot.lock';
 const PENDING_FILE_NAME = 'pending.json';
 const log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
@@ -42,12 +42,12 @@ async function processLoop(stateDir) {
 }
 async function executeSnapshot(options) {
     try {
-        await SyncStrategy_js_1.default.Strategy().execute(options);
+        await SyncStrategy_1.default.Strategy().execute(options);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         log.error('Snapshot failed (will surface on next test run)', message);
-        ErrorHandler_js_1.default.Handler().persistError(options.mirrorPath, err);
+        ErrorHandler_1.default.Handler().persistError(options.mirrorPath, err);
     }
 }
 main().catch((err) => {

package/build/strategies/AsyncStrategy.d.ts

@@ -1,5 +1,5 @@
-import { SnapshotOptions } from '../snapshotter.types.js';
-import SnapshotStrategy from './SnapshotStrategy.js';
+import { SnapshotOptions } from '../snapshotter.types';
+import SnapshotStrategy from './SnapshotStrategy';
 export default class AsyncStrategy implements SnapshotStrategy {
     private log;
     private scriptPath;

package/build/strategies/AsyncStrategy.js

@@ -7,11 +7,11 @@ const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
-const SnapshotterState_js_1 = __importDefault(require("../utilities/SnapshotterState.js"));
+const SnapshotterState_1 = __importDefault(require("../utilities/SnapshotterState"));
 class AsyncStrategy {
     constructor() {
         this.log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
-        this.scriptPath = path_1.default.join(__dirname, '..', 'scripts', 'runSnapshot.js');
+        this.scriptPath = path_1.default.join(__dirname, '..', 'scripts', 'runSnapshot');
     }
     static Strategy() {
         return new this();
@@ -22,7 +22,7 @@ class AsyncStrategy {
         this.log.info('Snapshot queued (running in background)', options.mirrorPath);
     }
     writeOptionsFile(options) {
-        const stateDir = SnapshotterState_js_1.default.EnsureStateDir(options.mirrorPath);
+        const stateDir = SnapshotterState_1.default.EnsureStateDir(options.mirrorPath);
         const optionsPath = path_1.default.join(stateDir, 'pending.json');
         (0, fs_1.writeFileSync)(optionsPath, JSON.stringify(options, null, 2));
         return stateDir;

package/build/strategies/SnapshotStrategy.d.ts

@@ -1,4 +1,4 @@
-import { SnapshotOptions } from '../snapshotter.types.js';
+import { SnapshotOptions } from '../snapshotter.types';
 export default interface SnapshotStrategy {
     execute(options: SnapshotOptions): Promise<void> | void;
 }

package/build/strategies/SyncStrategy.d.ts

@@ -1,5 +1,5 @@
-import { SnapshotOptions } from '../snapshotter.types.js';
-import SnapshotStrategy from './SnapshotStrategy.js';
+import { SnapshotOptions } from '../snapshotter.types';
+import SnapshotStrategy from './SnapshotStrategy';
 export default class SyncStrategy implements SnapshotStrategy {
     private log;
     private pushScriptPath;

package/build/strategies/SyncStrategy.js

@@ -6,15 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
-const ErrorHandler_js_1 = __importDefault(require("../components/ErrorHandler.js"));
-const FileSyncer_js_1 = __importDefault(require("../components/FileSyncer.js"));
-const TestResultsWriter_js_1 = __importDefault(require("../components/TestResultsWriter.js"));
-const git_js_1 = require("../git.js");
-const SnapshotterState_js_1 = __importDefault(require("../utilities/SnapshotterState.js"));
+const ErrorHandler_1 = __importDefault(require("../components/ErrorHandler"));
+const FileSyncer_1 = __importDefault(require("../components/FileSyncer"));
+const TestResultsWriter_1 = __importDefault(require("../components/TestResultsWriter"));
+const git_1 = require("../git");
+const SnapshotterState_1 = __importDefault(require("../utilities/SnapshotterState"));
 class SyncStrategy {
     constructor() {
         this.log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
-        this.pushScriptPath = path_1.default.join(__dirname, '..', 'scripts', 'runPush.js');
+        this.pushScriptPath = path_1.default.join(__dirname, '..', 'scripts', 'runPush');
     }
     static Strategy() {
         return new this();
@@ -24,15 +24,15 @@ class SyncStrategy {
         const { mirrorPath, testResults, remote } = options;
         this.log.info('Starting snapshot', sourcePath, mirrorPath);
         try {
-            await FileSyncer_js_1.default.Syncer().sync(sourcePath, mirrorPath);
-            SnapshotterState_js_1.default.CleanupLegacyMirrorState(mirrorPath);
+            await FileSyncer_1.default.Syncer().sync(sourcePath, mirrorPath);
+            SnapshotterState_1.default.CleanupLegacyMirrorState(mirrorPath);
             this.log.info('Files synced', mirrorPath);
-            TestResultsWriter_js_1.default.Writer().write(mirrorPath, testResults);
+            TestResultsWriter_1.default.Writer().write(mirrorPath, testResults);
             this.log.info('Test results saved', mirrorPath);
-            const committed = await (0, git_js_1.gitCommit)(mirrorPath, this.log);
+            const committed = await (0, git_1.gitCommit)(mirrorPath, this.log);
             if (!committed) {
                 this.log.info('No changes to commit', mirrorPath);
-                ErrorHandler_js_1.default.Handler().clearError(mirrorPath);
+                ErrorHandler_1.default.Handler().clearError(mirrorPath);
                 return;
             }
             this.log.info('Commit created, queueing push', remote.url);
@@ -41,7 +41,7 @@ class SyncStrategy {
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             this.log.error('Snapshot failed', message);
-            ErrorHandler_js_1.default.Handler().persistError(mirrorPath, err);
+            ErrorHandler_1.default.Handler().persistError(mirrorPath, err);
             throw err;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@regressionproof/snapshotter",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "publishConfig": {
     "access": "public"
   },
@@ -14,7 +14,7 @@
   "exports": {
     ".": {
       "import": {
-        "types": "./build/esm/index.d.ts",
+        "types": "./build/index.d.ts",
         "default": "./build/esm/index.js"
       },
       "require": {
@@ -25,7 +25,7 @@
   },
   "scripts": {
     "build.ci": "yarn run build.tsc && yarn run build.resolve-paths && yarn run lint",
-    "build.dev": "yarn run build.tsc --sourceMap ; yarn run resolve-paths.lint",
+    "build.dev": "yarn run build.dist",
     "build.copy-files": "mkdir -p build && rsync -avzq --exclude='*.ts' ./src/ ./build/",
     "build.resolve-paths": "resolve-path-aliases --target build --patterns '**/*.js,**/*.d.ts'",
     "build.tsc": "yarn run build.copy-files && tsc",
@@ -94,5 +94,5 @@
     "@sprucelabs/spruce-core-schemas": "^42.1.3",
     "@sprucelabs/spruce-skill-utils": "^34.0.3"
   },
-  "gitHead": "991c41905951b8c069c69b9a016affe53e819238"
+  "gitHead": "c3562cc2f17b9908feaccb45a62cb8ca18334657"
 }