@regressionproof/snapshotter 0.7.1 → 0.7.3

package/build/components/ErrorHandler.js

@@ -5,6 +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"));
 class ErrorHandler {
     constructor() { }
     static Handler() {
@@ -22,8 +23,7 @@ class ErrorHandler {
         }
     }
     persistError(mirrorPath, err) {
-        const snapshotterDir = path_1.default.join(mirrorPath, '.snapshotter');
-        (0, fs_1.mkdirSync)(snapshotterDir, { recursive: true });
+        SnapshotterState_js_1.default.EnsureStateDir(mirrorPath);
         const errorPath = this.getErrorFilePath(mirrorPath);
         const errorData = {
             message: err instanceof Error ? err.message : String(err),
@@ -39,7 +39,8 @@ class ErrorHandler {
         }
     }
     getErrorFilePath(mirrorPath) {
-        return path_1.default.join(mirrorPath, '.snapshotter', ErrorHandler.ERROR_FILE_NAME);
+        const stateDir = SnapshotterState_js_1.default.GetStateDir(mirrorPath);
+        return path_1.default.join(stateDir, ErrorHandler.ERROR_FILE_NAME);
     }
 }
 ErrorHandler.ERROR_FILE_NAME = 'lastError.json';

package/build/esm/components/ErrorHandler.js

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import path from 'path';
+import SnapshotterState from '../utilities/SnapshotterState.js.js';
 class ErrorHandler {
     constructor() { }
     static Handler() {
@@ -17,8 +18,7 @@ class ErrorHandler {
         }
     }
     persistError(mirrorPath, err) {
-        const snapshotterDir = path.join(mirrorPath, '.snapshotter');
-        mkdirSync(snapshotterDir, { recursive: true });
+        SnapshotterState.EnsureStateDir(mirrorPath);
         const errorPath = this.getErrorFilePath(mirrorPath);
         const errorData = {
             message: err instanceof Error ? err.message : String(err),
@@ -34,7 +34,8 @@ class ErrorHandler {
         }
     }
     getErrorFilePath(mirrorPath) {
-        return path.join(mirrorPath, '.snapshotter', ErrorHandler.ERROR_FILE_NAME);
+        const stateDir = SnapshotterState.GetStateDir(mirrorPath);
+        return path.join(stateDir, ErrorHandler.ERROR_FILE_NAME);
     }
 }
 ErrorHandler.ERROR_FILE_NAME = 'lastError.json';

package/build/esm/scripts/runPush.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/scripts/runPush.js

@@ -0,0 +1,83 @@
+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 { 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';
+const LOCK_FILE_NAME = 'push.lock';
+const PENDING_FILE_NAME = 'push.pending';
+const log = buildLog('Snapshotter');
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mirrorPath = getEnvOrExit('MIRROR_PATH');
+        const remoteUrl = getEnvOrExit('REMOTE_URL');
+        const remoteToken = getEnvOrExit('REMOTE_TOKEN');
+        const stateDir = SnapshotterState.EnsureStateDir(mirrorPath);
+        const lockPath = path.join(stateDir, LOCK_FILE_NAME);
+        const pendingPath = path.join(stateDir, PENDING_FILE_NAME);
+        if (existsSync(lockPath)) {
+            writeFileSync(pendingPath, new Date().toISOString());
+            log.info('Push already running, marked pending', mirrorPath);
+            return;
+        }
+        try {
+            writeFileSync(lockPath, process.pid.toString());
+            const remote = {
+                url: remoteUrl,
+                token: remoteToken,
+            };
+            yield processLoop(mirrorPath, remote, pendingPath);
+        }
+        finally {
+            if (existsSync(lockPath)) {
+                unlinkSync(lockPath);
+            }
+        }
+    });
+}
+function processLoop(mirrorPath, remote, pendingPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        while (true) {
+            if (existsSync(pendingPath)) {
+                unlinkSync(pendingPath);
+            }
+            try {
+                log.info('Push starting', remote.url);
+                yield gitPush(mirrorPath, remote, log);
+                log.info('Push completed', remote.url);
+                ErrorHandler.Handler().clearError(mirrorPath);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                log.error('Push failed', message);
+                ErrorHandler.Handler().persistError(mirrorPath, err);
+                writeFileSync(pendingPath, new Date().toISOString());
+                return;
+            }
+            if (!existsSync(pendingPath)) {
+                return;
+            }
+        }
+    });
+}
+function getEnvOrExit(name) {
+    const value = process.env[name];
+    if (!value) {
+        console.error(`Missing required env var: ${name}`);
+        process.exit(1);
+    }
+    return value;
+}
+main().catch((err) => {
+    console.error('Push script failed:', err);
+    process.exit(1);
+});

package/build/esm/scripts/runSnapshot.js

@@ -17,19 +17,19 @@ const PENDING_FILE_NAME = 'pending.json';
 const log = buildLog('Snapshotter');
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const snapshotterDir = process.argv[2];
-        if (!snapshotterDir) {
-            console.error('Usage: runSnapshot <snapshotter-dir>');
+        const stateDir = process.argv[2];
+        if (!stateDir) {
+            console.error('Usage: runSnapshot <state-dir>');
             process.exit(1);
         }
-        const lockPath = path.join(snapshotterDir, LOCK_FILE_NAME);
+        const lockPath = path.join(stateDir, LOCK_FILE_NAME);
         if (existsSync(lockPath)) {
             log.info('Another snapshot is running, exiting');
             process.exit(0);
         }
         try {
             writeFileSync(lockPath, process.pid.toString());
-            yield processLoop(snapshotterDir);
+            yield processLoop(stateDir);
         }
         finally {
             if (existsSync(lockPath)) {
@@ -38,9 +38,9 @@ function main() {
         }
     });
 }
-function processLoop(snapshotterDir) {
+function processLoop(stateDir) {
     return __awaiter(this, void 0, void 0, function* () {
-        const pendingPath = path.join(snapshotterDir, PENDING_FILE_NAME);
+        const pendingPath = path.join(stateDir, PENDING_FILE_NAME);
         while (existsSync(pendingPath)) {
             const options = JSON.parse(readFileSync(pendingPath, 'utf-8'));
             unlinkSync(pendingPath);

package/build/esm/strategies/AsyncStrategy.js

@@ -1,7 +1,8 @@
 import { spawn } from 'child_process';
-import { mkdirSync, writeFileSync } from 'fs';
+import { writeFileSync } from 'fs';
 import path from 'path';
 import { buildLog } from '@sprucelabs/spruce-skill-utils';
+import SnapshotterState from '../utilities/SnapshotterState.js.js';
 export default class AsyncStrategy {
     constructor() {
         this.log = buildLog('Snapshotter');
@@ -11,19 +12,18 @@ export default class AsyncStrategy {
         return new this();
     }
     execute(options) {
-        const snapshotterDir = this.writeOptionsFile(options);
-        this.spawnSnapshotProcess(snapshotterDir);
+        const stateDir = this.writeOptionsFile(options);
+        this.spawnSnapshotProcess(stateDir);
         this.log.info('Snapshot queued (running in background)', options.mirrorPath);
     }
     writeOptionsFile(options) {
-        const snapshotterDir = path.join(options.mirrorPath, '.snapshotter');
-        mkdirSync(snapshotterDir, { recursive: true });
-        const optionsPath = path.join(snapshotterDir, 'pending.json');
+        const stateDir = SnapshotterState.EnsureStateDir(options.mirrorPath);
+        const optionsPath = path.join(stateDir, 'pending.json');
         writeFileSync(optionsPath, JSON.stringify(options, null, 2));
-        return snapshotterDir;
+        return stateDir;
     }
-    spawnSnapshotProcess(snapshotterDir) {
-        const child = spawn('node', [this.scriptPath, snapshotterDir], {
+    spawnSnapshotProcess(stateDir) {
+        const child = spawn('node', [this.scriptPath, stateDir], {
             detached: true,
             stdio: 'ignore',
         });

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

@@ -2,7 +2,9 @@ import { SnapshotOptions } from '../snapshotter.types.js';
 import SnapshotStrategy from './SnapshotStrategy.js';
 export default class SyncStrategy implements SnapshotStrategy {
     private log;
+    private pushScriptPath;
     private constructor();
     static Strategy(): SyncStrategy;
     execute(options: SnapshotOptions): Promise<void>;
+    private spawnPushProcess;
 }

package/build/esm/strategies/SyncStrategy.js

@@ -7,14 +7,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+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, gitPush } from '../git.js.js';
+import { gitCommit } from '../git.js.js';
+import SnapshotterState from '../utilities/SnapshotterState.js.js';
 export default class SyncStrategy {
     constructor() {
         this.log = buildLog('Snapshotter');
+        this.pushScriptPath = path.join(__dirname, '..', 'scripts', 'runPush.js');
     }
     static Strategy() {
         return new this();
@@ -27,6 +31,7 @@ export default class SyncStrategy {
             this.log.info('Starting snapshot', sourcePath, mirrorPath);
             try {
                 yield FileSyncer.Syncer().sync(sourcePath, mirrorPath);
+                SnapshotterState.CleanupLegacyMirrorState(mirrorPath);
                 this.log.info('Files synced', mirrorPath);
                 TestResultsWriter.Writer().write(mirrorPath, testResults);
                 this.log.info('Test results saved', mirrorPath);
@@ -36,10 +41,8 @@ export default class SyncStrategy {
                     ErrorHandler.Handler().clearError(mirrorPath);
                     return;
                 }
-                this.log.info('Commit created, pushing', remote.url);
-                yield gitPush(mirrorPath, remote, this.log);
-                this.log.info('Push completed', remote.url);
-                ErrorHandler.Handler().clearError(mirrorPath);
+                this.log.info('Commit created, queueing push', remote.url);
+                this.spawnPushProcess(mirrorPath, remote);
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -49,4 +52,12 @@ export default class SyncStrategy {
             }
         });
     }
+    spawnPushProcess(mirrorPath, remote) {
+        const child = spawn('node', [this.pushScriptPath], {
+            detached: true,
+            stdio: 'ignore',
+            env: Object.assign(Object.assign({}, process.env), { MIRROR_PATH: mirrorPath, REMOTE_URL: remote.url, REMOTE_TOKEN: remote.token }),
+        });
+        child.unref();
+    }
 }

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

@@ -0,0 +1,8 @@
+export default class SnapshotterState {
+    private static readonly STATE_DIR_NAME;
+    private static readonly LEGACY_RUNTIME_FILES;
+    private constructor();
+    static GetStateDir(mirrorPath: string): string;
+    static EnsureStateDir(mirrorPath: string): string;
+    static CleanupLegacyMirrorState(mirrorPath: string): void;
+}

package/build/esm/utilities/SnapshotterState.js

@@ -0,0 +1,34 @@
+import { existsSync, mkdirSync, unlinkSync } from 'fs';
+import path from 'path';
+class SnapshotterState {
+    constructor() { }
+    static GetStateDir(mirrorPath) {
+        return path.join(path.dirname(mirrorPath), SnapshotterState.STATE_DIR_NAME);
+    }
+    static EnsureStateDir(mirrorPath) {
+        const stateDir = SnapshotterState.GetStateDir(mirrorPath);
+        mkdirSync(stateDir, { recursive: true });
+        return stateDir;
+    }
+    static CleanupLegacyMirrorState(mirrorPath) {
+        const legacyDir = path.join(mirrorPath, SnapshotterState.STATE_DIR_NAME);
+        if (!existsSync(legacyDir)) {
+            return;
+        }
+        for (const file of SnapshotterState.LEGACY_RUNTIME_FILES) {
+            const filePath = path.join(legacyDir, file);
+            if (existsSync(filePath)) {
+                unlinkSync(filePath);
+            }
+        }
+    }
+}
+SnapshotterState.STATE_DIR_NAME = '.snapshotter';
+SnapshotterState.LEGACY_RUNTIME_FILES = [
+    'push.lock',
+    'push.pending',
+    'lastError.json',
+    'snapshot.lock',
+    'pending.json',
+];
+export default SnapshotterState;

package/build/scripts/runPush.d.ts

@@ -0,0 +1 @@
+export {};

package/build/scripts/runPush.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 LOCK_FILE_NAME = 'push.lock';
+const PENDING_FILE_NAME = 'push.pending';
+const log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
+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 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)) {
+        (0, fs_1.writeFileSync)(pendingPath, new Date().toISOString());
+        log.info('Push already running, marked pending', mirrorPath);
+        return;
+    }
+    try {
+        (0, fs_1.writeFileSync)(lockPath, process.pid.toString());
+        const remote = {
+            url: remoteUrl,
+            token: remoteToken,
+        };
+        await processLoop(mirrorPath, remote, pendingPath);
+    }
+    finally {
+        if ((0, fs_1.existsSync)(lockPath)) {
+            (0, fs_1.unlinkSync)(lockPath);
+        }
+    }
+}
+async function processLoop(mirrorPath, remote, pendingPath) {
+    while (true) {
+        if ((0, fs_1.existsSync)(pendingPath)) {
+            (0, fs_1.unlinkSync)(pendingPath);
+        }
+        try {
+            log.info('Push starting', remote.url);
+            await (0, git_js_1.gitPush)(mirrorPath, remote, log);
+            log.info('Push completed', remote.url);
+            ErrorHandler_js_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);
+            (0, fs_1.writeFileSync)(pendingPath, new Date().toISOString());
+            return;
+        }
+        if (!(0, fs_1.existsSync)(pendingPath)) {
+            return;
+        }
+    }
+}
+function getEnvOrExit(name) {
+    const value = process.env[name];
+    if (!value) {
+        console.error(`Missing required env var: ${name}`);
+        process.exit(1);
+    }
+    return value;
+}
+main().catch((err) => {
+    console.error('Push script failed:', err);
+    process.exit(1);
+});

package/build/scripts/runSnapshot.js

@@ -12,19 +12,19 @@ const LOCK_FILE_NAME = 'snapshot.lock';
 const PENDING_FILE_NAME = 'pending.json';
 const log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
 async function main() {
-    const snapshotterDir = process.argv[2];
-    if (!snapshotterDir) {
-        console.error('Usage: runSnapshot <snapshotter-dir>');
+    const stateDir = process.argv[2];
+    if (!stateDir) {
+        console.error('Usage: runSnapshot <state-dir>');
         process.exit(1);
     }
-    const lockPath = path_1.default.join(snapshotterDir, LOCK_FILE_NAME);
+    const lockPath = path_1.default.join(stateDir, LOCK_FILE_NAME);
     if ((0, fs_1.existsSync)(lockPath)) {
         log.info('Another snapshot is running, exiting');
         process.exit(0);
     }
     try {
         (0, fs_1.writeFileSync)(lockPath, process.pid.toString());
-        await processLoop(snapshotterDir);
+        await processLoop(stateDir);
     }
     finally {
         if ((0, fs_1.existsSync)(lockPath)) {
@@ -32,8 +32,8 @@ async function main() {
         }
     }
 }
-async function processLoop(snapshotterDir) {
-    const pendingPath = path_1.default.join(snapshotterDir, PENDING_FILE_NAME);
+async function processLoop(stateDir) {
+    const pendingPath = path_1.default.join(stateDir, PENDING_FILE_NAME);
     while ((0, fs_1.existsSync)(pendingPath)) {
         const options = JSON.parse((0, fs_1.readFileSync)(pendingPath, 'utf-8'));
         (0, fs_1.unlinkSync)(pendingPath);

package/build/strategies/AsyncStrategy.js

@@ -7,6 +7,7 @@ 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"));
 class AsyncStrategy {
     constructor() {
         this.log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
@@ -16,19 +17,18 @@ class AsyncStrategy {
         return new this();
     }
     execute(options) {
-        const snapshotterDir = this.writeOptionsFile(options);
-        this.spawnSnapshotProcess(snapshotterDir);
+        const stateDir = this.writeOptionsFile(options);
+        this.spawnSnapshotProcess(stateDir);
         this.log.info('Snapshot queued (running in background)', options.mirrorPath);
     }
     writeOptionsFile(options) {
-        const snapshotterDir = path_1.default.join(options.mirrorPath, '.snapshotter');
-        (0, fs_1.mkdirSync)(snapshotterDir, { recursive: true });
-        const optionsPath = path_1.default.join(snapshotterDir, 'pending.json');
+        const stateDir = SnapshotterState_js_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 snapshotterDir;
+        return stateDir;
     }
-    spawnSnapshotProcess(snapshotterDir) {
-        const child = (0, child_process_1.spawn)('node', [this.scriptPath, snapshotterDir], {
+    spawnSnapshotProcess(stateDir) {
+        const child = (0, child_process_1.spawn)('node', [this.scriptPath, stateDir], {
             detached: true,
             stdio: 'ignore',
         });

package/build/strategies/SyncStrategy.d.ts

@@ -2,7 +2,9 @@ import { SnapshotOptions } from '../snapshotter.types.js';
 import SnapshotStrategy from './SnapshotStrategy.js';
 export default class SyncStrategy implements SnapshotStrategy {
     private log;
+    private pushScriptPath;
     private constructor();
     static Strategy(): SyncStrategy;
     execute(options: SnapshotOptions): Promise<void>;
+    private spawnPushProcess;
 }

package/build/strategies/SyncStrategy.js

@@ -3,14 +3,18 @@ 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 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"));
 class SyncStrategy {
     constructor() {
         this.log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
+        this.pushScriptPath = path_1.default.join(__dirname, '..', 'scripts', 'runPush.js');
     }
     static Strategy() {
         return new this();
@@ -21,6 +25,7 @@ class SyncStrategy {
         this.log.info('Starting snapshot', sourcePath, mirrorPath);
         try {
             await FileSyncer_js_1.default.Syncer().sync(sourcePath, mirrorPath);
+            SnapshotterState_js_1.default.CleanupLegacyMirrorState(mirrorPath);
             this.log.info('Files synced', mirrorPath);
             TestResultsWriter_js_1.default.Writer().write(mirrorPath, testResults);
             this.log.info('Test results saved', mirrorPath);
@@ -30,10 +35,8 @@ class SyncStrategy {
                 ErrorHandler_js_1.default.Handler().clearError(mirrorPath);
                 return;
             }
-            this.log.info('Commit created, pushing', remote.url);
-            await (0, git_js_1.gitPush)(mirrorPath, remote, this.log);
-            this.log.info('Push completed', remote.url);
-            ErrorHandler_js_1.default.Handler().clearError(mirrorPath);
+            this.log.info('Commit created, queueing push', remote.url);
+            this.spawnPushProcess(mirrorPath, remote);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -42,5 +45,18 @@ class SyncStrategy {
             throw err;
         }
     }
+    spawnPushProcess(mirrorPath, remote) {
+        const child = (0, child_process_1.spawn)('node', [this.pushScriptPath], {
+            detached: true,
+            stdio: 'ignore',
+            env: {
+                ...process.env,
+                MIRROR_PATH: mirrorPath,
+                REMOTE_URL: remote.url,
+                REMOTE_TOKEN: remote.token,
+            },
+        });
+        child.unref();
+    }
 }
 exports.default = SyncStrategy;

package/build/utilities/SnapshotterState.d.ts

@@ -0,0 +1,8 @@
+export default class SnapshotterState {
+    private static readonly STATE_DIR_NAME;
+    private static readonly LEGACY_RUNTIME_FILES;
+    private constructor();
+    static GetStateDir(mirrorPath: string): string;
+    static EnsureStateDir(mirrorPath: string): string;
+    static CleanupLegacyMirrorState(mirrorPath: string): void;
+}

package/build/utilities/SnapshotterState.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 fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+class SnapshotterState {
+    constructor() { }
+    static GetStateDir(mirrorPath) {
+        return path_1.default.join(path_1.default.dirname(mirrorPath), SnapshotterState.STATE_DIR_NAME);
+    }
+    static EnsureStateDir(mirrorPath) {
+        const stateDir = SnapshotterState.GetStateDir(mirrorPath);
+        (0, fs_1.mkdirSync)(stateDir, { recursive: true });
+        return stateDir;
+    }
+    static CleanupLegacyMirrorState(mirrorPath) {
+        const legacyDir = path_1.default.join(mirrorPath, SnapshotterState.STATE_DIR_NAME);
+        if (!(0, fs_1.existsSync)(legacyDir)) {
+            return;
+        }
+        for (const file of SnapshotterState.LEGACY_RUNTIME_FILES) {
+            const filePath = path_1.default.join(legacyDir, file);
+            if ((0, fs_1.existsSync)(filePath)) {
+                (0, fs_1.unlinkSync)(filePath);
+            }
+        }
+    }
+}
+SnapshotterState.STATE_DIR_NAME = '.snapshotter';
+SnapshotterState.LEGACY_RUNTIME_FILES = [
+    'push.lock',
+    'push.pending',
+    'lastError.json',
+    'snapshot.lock',
+    'pending.json',
+];
+exports.default = SnapshotterState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@regressionproof/snapshotter",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "publishConfig": {
     "access": "public"
   },
@@ -94,5 +94,5 @@
     "@sprucelabs/spruce-core-schemas": "^42.1.3",
     "@sprucelabs/spruce-skill-utils": "^34.0.3"
   },
-  "gitHead": "c38dea336a4653790787044ca8b4209a9e5352fa"
+  "gitHead": "11e6ee4957dfa9a0160dac49bb007f196c9beab4"
 }