@regressionproof/snapshotter 0.7.0 → 0.7.2

package/build/Snapshotter.d.ts

@@ -0,0 +1,11 @@
+import { SnapshotOptions } from './snapshotter.types.js';
+export default class Snapshotter {
+    private strategy;
+    private constructor();
+    static Snapshotter(options?: SnapshotterOptions): Snapshotter;
+    snapshot(options: SnapshotOptions): void | Promise<void>;
+    checkForPreviousFailure(mirrorPath: string): void;
+}
+export interface SnapshotterOptions {
+    mode?: 'sync' | 'async';
+}

package/build/Snapshotter.js

@@ -0,0 +1,25 @@
+"use strict";
+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"));
+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();
+        return new this(strategy);
+    }
+    snapshot(options) {
+        return this.strategy.execute(options);
+    }
+    checkForPreviousFailure(mirrorPath) {
+        ErrorHandler_js_1.default.Handler().checkForPreviousFailure(mirrorPath);
+    }
+}
+exports.default = Snapshotter;

package/build/components/ErrorHandler.d.ts

@@ -0,0 +1,9 @@
+export default class ErrorHandler {
+    private static readonly ERROR_FILE_NAME;
+    private constructor();
+    static Handler(): ErrorHandler;
+    checkForPreviousFailure(mirrorPath: string): void;
+    persistError(mirrorPath: string, err: unknown): void;
+    clearError(mirrorPath: string): void;
+    private getErrorFilePath;
+}

package/build/components/ErrorHandler.js

@@ -0,0 +1,46 @@
+"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 ErrorHandler {
+    constructor() { }
+    static Handler() {
+        return new this();
+    }
+    checkForPreviousFailure(mirrorPath) {
+        const errorPath = this.getErrorFilePath(mirrorPath);
+        if ((0, fs_1.existsSync)(errorPath)) {
+            const errorData = JSON.parse((0, fs_1.readFileSync)(errorPath, 'utf-8'));
+            (0, fs_1.unlinkSync)(errorPath);
+            throw new Error(`Previous snapshot failed: ${errorData.message}\n` +
+                `Timestamp: ${errorData.timestamp}\n` +
+                `This error was from a background snapshot that failed. ` +
+                `The snapshot has been retried - if this error persists, check your configuration.`);
+        }
+    }
+    persistError(mirrorPath, err) {
+        const snapshotterDir = path_1.default.join(mirrorPath, '.snapshotter');
+        (0, fs_1.mkdirSync)(snapshotterDir, { recursive: true });
+        const errorPath = this.getErrorFilePath(mirrorPath);
+        const errorData = {
+            message: err instanceof Error ? err.message : String(err),
+            stack: err instanceof Error ? err.stack : undefined,
+            timestamp: new Date().toISOString(),
+        };
+        (0, fs_1.writeFileSync)(errorPath, JSON.stringify(errorData, null, 2));
+    }
+    clearError(mirrorPath) {
+        const errorPath = this.getErrorFilePath(mirrorPath);
+        if ((0, fs_1.existsSync)(errorPath)) {
+            (0, fs_1.unlinkSync)(errorPath);
+        }
+    }
+    getErrorFilePath(mirrorPath) {
+        return path_1.default.join(mirrorPath, '.snapshotter', ErrorHandler.ERROR_FILE_NAME);
+    }
+}
+ErrorHandler.ERROR_FILE_NAME = 'lastError.json';
+exports.default = ErrorHandler;

package/build/components/FileSyncer.d.ts

@@ -0,0 +1,8 @@
+export default class FileSyncer {
+    private static readonly DEFAULT_EXCLUDES;
+    private constructor();
+    static Syncer(): FileSyncer;
+    sync(sourcePath: string, mirrorPath: string): Promise<void>;
+    private syncWithGitIgnore;
+    private syncWithDelete;
+}

package/build/{sync.js → components/FileSyncer.js}

@@ -3,13 +3,40 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncFiles = syncFiles;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const util_1 = require("util");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
-const DEFAULT_EXCLUDES = [
+class FileSyncer {
+    constructor() { }
+    static Syncer() {
+        return new this();
+    }
+    async sync(sourcePath, mirrorPath) {
+        const hasGitIgnore = (0, fs_1.existsSync)(path_1.default.join(sourcePath, '.gitignore'));
+        const excludes = FileSyncer.DEFAULT_EXCLUDES.map((e) => `--exclude='${e}'`).join(' ');
+        if (hasGitIgnore) {
+            await this.syncWithGitIgnore(sourcePath, mirrorPath, excludes);
+        }
+        else {
+            await this.syncWithDelete(sourcePath, mirrorPath, excludes);
+        }
+    }
+    async syncWithGitIgnore(sourcePath, mirrorPath, excludes) {
+        // Filter through a file existence check to handle deleted files in git index
+        // This is more portable than --ignore-missing-args which isn't available on older rsync (macOS)
+        const cmd = `cd "${sourcePath}" && git ls-files --cached --others --exclude-standard -z | ` +
+            `while IFS= read -r -d '' file; do [ -e "$file" ] && printf '%s\\0' "$file"; done | ` +
+            `rsync -av --files-from=- --from0 ${excludes} . "${mirrorPath}/"`;
+        await execAsync(cmd);
+    }
+    async syncWithDelete(sourcePath, mirrorPath, excludes) {
+        const cmd = `rsync -av --delete ${excludes} "${sourcePath}/" "${mirrorPath}/"`;
+        await execAsync(cmd);
+    }
+}
+FileSyncer.DEFAULT_EXCLUDES = [
     'node_modules',
     'build',
     '*.env*',
@@ -21,17 +48,4 @@ const DEFAULT_EXCLUDES = [
     '*secret*',
     '*.local',
 ];
-async function syncFiles(sourcePath, mirrorPath) {
-    const hasGitIgnore = (0, fs_1.existsSync)(path_1.default.join(sourcePath, '.gitignore'));
-    const excludes = DEFAULT_EXCLUDES.map((e) => `--exclude='${e}'`).join(' ');
-    if (hasGitIgnore) {
-        // Filter through a file existence check to handle deleted files in git index
-        // This is more portable than --ignore-missing-args which isn't available on older rsync (macOS)
-        const cmd = `cd "${sourcePath}" && git ls-files --cached --others --exclude-standard -z | while IFS= read -r -d '' file; do [ -e "$file" ] && printf '%s\\0' "$file"; done | rsync -av --files-from=- --from0 ${excludes} . "${mirrorPath}/"`;
-        await execAsync(cmd);
-    }
-    else {
-        const cmd = `rsync -av --delete ${excludes} "${sourcePath}/" "${mirrorPath}/"`;
-        await execAsync(cmd);
-    }
-}
+exports.default = FileSyncer;

package/build/components/TestResultsWriter.d.ts

@@ -0,0 +1,7 @@
+import { TestResults } from '../snapshotter.types.js';
+export default class TestResultsWriter {
+    private constructor();
+    static Writer(): TestResultsWriter;
+    write(mirrorPath: string, testResults: TestResults): void;
+    private sortTestResults;
+}

package/build/components/TestResultsWriter.js

@@ -0,0 +1,45 @@
+"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 TestResultsWriter {
+    constructor() { }
+    static Writer() {
+        return new this();
+    }
+    write(mirrorPath, testResults) {
+        const snapshotterDir = path_1.default.join(mirrorPath, '.snapshotter');
+        (0, fs_1.mkdirSync)(snapshotterDir, { recursive: true });
+        const sorted = this.sortTestResults(testResults);
+        (0, fs_1.writeFileSync)(path_1.default.join(snapshotterDir, 'testResults.json'), JSON.stringify(sorted, null, 2));
+    }
+    sortTestResults(testResults) {
+        const suites = [...testResults.suites].map((suite) => ({
+            ...suite,
+            tests: [...suite.tests].sort((left, right) => left.name.localeCompare(right.name)),
+        }));
+        suites.sort((left, right) => left.path.localeCompare(right.path));
+        const typeErrors = testResults.typeErrors
+            ? [...testResults.typeErrors].sort((left, right) => {
+                const fileCompare = left.file.localeCompare(right.file);
+                if (fileCompare !== 0) {
+                    return fileCompare;
+                }
+                const lineCompare = left.line - right.line;
+                if (lineCompare !== 0) {
+                    return lineCompare;
+                }
+                return left.column - right.column;
+            })
+            : undefined;
+        return {
+            ...testResults,
+            suites,
+            typeErrors,
+        };
+    }
+}
+exports.default = TestResultsWriter;

package/build/esm/Snapshotter.d.ts

@@ -0,0 +1,11 @@
+import { SnapshotOptions } from './snapshotter.types.js';
+export default class Snapshotter {
+    private strategy;
+    private constructor();
+    static Snapshotter(options?: SnapshotterOptions): Snapshotter;
+    snapshot(options: SnapshotOptions): void | Promise<void>;
+    checkForPreviousFailure(mirrorPath: string): void;
+}
+export interface SnapshotterOptions {
+    mode?: 'sync' | 'async';
+}

package/build/esm/Snapshotter.js

@@ -0,0 +1,20 @@
+import ErrorHandler from './components/ErrorHandler.js.js';
+import AsyncStrategy from './strategies/AsyncStrategy.js.js';
+import SyncStrategy from './strategies/SyncStrategy.js.js';
+export default class Snapshotter {
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    static Snapshotter(options) {
+        var _a;
+        const mode = (_a = options === null || options === void 0 ? void 0 : options.mode) !== null && _a !== void 0 ? _a : 'async';
+        const strategy = mode === 'sync' ? SyncStrategy.Strategy() : AsyncStrategy.Strategy();
+        return new this(strategy);
+    }
+    snapshot(options) {
+        return this.strategy.execute(options);
+    }
+    checkForPreviousFailure(mirrorPath) {
+        ErrorHandler.Handler().checkForPreviousFailure(mirrorPath);
+    }
+}

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

@@ -0,0 +1,9 @@
+export default class ErrorHandler {
+    private static readonly ERROR_FILE_NAME;
+    private constructor();
+    static Handler(): ErrorHandler;
+    checkForPreviousFailure(mirrorPath: string): void;
+    persistError(mirrorPath: string, err: unknown): void;
+    clearError(mirrorPath: string): void;
+    private getErrorFilePath;
+}

package/build/esm/components/ErrorHandler.js

@@ -0,0 +1,41 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
+import path from 'path';
+class ErrorHandler {
+    constructor() { }
+    static Handler() {
+        return new this();
+    }
+    checkForPreviousFailure(mirrorPath) {
+        const errorPath = this.getErrorFilePath(mirrorPath);
+        if (existsSync(errorPath)) {
+            const errorData = JSON.parse(readFileSync(errorPath, 'utf-8'));
+            unlinkSync(errorPath);
+            throw new Error(`Previous snapshot failed: ${errorData.message}\n` +
+                `Timestamp: ${errorData.timestamp}\n` +
+                `This error was from a background snapshot that failed. ` +
+                `The snapshot has been retried - if this error persists, check your configuration.`);
+        }
+    }
+    persistError(mirrorPath, err) {
+        const snapshotterDir = path.join(mirrorPath, '.snapshotter');
+        mkdirSync(snapshotterDir, { recursive: true });
+        const errorPath = this.getErrorFilePath(mirrorPath);
+        const errorData = {
+            message: err instanceof Error ? err.message : String(err),
+            stack: err instanceof Error ? err.stack : undefined,
+            timestamp: new Date().toISOString(),
+        };
+        writeFileSync(errorPath, JSON.stringify(errorData, null, 2));
+    }
+    clearError(mirrorPath) {
+        const errorPath = this.getErrorFilePath(mirrorPath);
+        if (existsSync(errorPath)) {
+            unlinkSync(errorPath);
+        }
+    }
+    getErrorFilePath(mirrorPath) {
+        return path.join(mirrorPath, '.snapshotter', ErrorHandler.ERROR_FILE_NAME);
+    }
+}
+ErrorHandler.ERROR_FILE_NAME = 'lastError.json';
+export default ErrorHandler;

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

@@ -0,0 +1,8 @@
+export default class FileSyncer {
+    private static readonly DEFAULT_EXCLUDES;
+    private constructor();
+    static Syncer(): FileSyncer;
+    sync(sourcePath: string, mirrorPath: string): Promise<void>;
+    private syncWithGitIgnore;
+    private syncWithDelete;
+}

package/build/esm/{sync.js → components/FileSyncer.js}

@@ -12,7 +12,41 @@ import { existsSync } from 'fs';
 import path from 'path';
 import { promisify } from 'util';
 const execAsync = promisify(exec);
-const DEFAULT_EXCLUDES = [
+class FileSyncer {
+    constructor() { }
+    static Syncer() {
+        return new this();
+    }
+    sync(sourcePath, mirrorPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasGitIgnore = existsSync(path.join(sourcePath, '.gitignore'));
+            const excludes = FileSyncer.DEFAULT_EXCLUDES.map((e) => `--exclude='${e}'`).join(' ');
+            if (hasGitIgnore) {
+                yield this.syncWithGitIgnore(sourcePath, mirrorPath, excludes);
+            }
+            else {
+                yield this.syncWithDelete(sourcePath, mirrorPath, excludes);
+            }
+        });
+    }
+    syncWithGitIgnore(sourcePath, mirrorPath, excludes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Filter through a file existence check to handle deleted files in git index
+            // This is more portable than --ignore-missing-args which isn't available on older rsync (macOS)
+            const cmd = `cd "${sourcePath}" && git ls-files --cached --others --exclude-standard -z | ` +
+                `while IFS= read -r -d '' file; do [ -e "$file" ] && printf '%s\\0' "$file"; done | ` +
+                `rsync -av --files-from=- --from0 ${excludes} . "${mirrorPath}/"`;
+            yield execAsync(cmd);
+        });
+    }
+    syncWithDelete(sourcePath, mirrorPath, excludes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cmd = `rsync -av --delete ${excludes} "${sourcePath}/" "${mirrorPath}/"`;
+            yield execAsync(cmd);
+        });
+    }
+}
+FileSyncer.DEFAULT_EXCLUDES = [
     'node_modules',
     'build',
     '*.env*',
@@ -24,19 +58,4 @@ const DEFAULT_EXCLUDES = [
     '*secret*',
     '*.local',
 ];
-export function syncFiles(sourcePath, mirrorPath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const hasGitIgnore = existsSync(path.join(sourcePath, '.gitignore'));
-        const excludes = DEFAULT_EXCLUDES.map((e) => `--exclude='${e}'`).join(' ');
-        if (hasGitIgnore) {
-            // Filter through a file existence check to handle deleted files in git index
-            // This is more portable than --ignore-missing-args which isn't available on older rsync (macOS)
-            const cmd = `cd "${sourcePath}" && git ls-files --cached --others --exclude-standard -z | while IFS= read -r -d '' file; do [ -e "$file" ] && printf '%s\\0' "$file"; done | rsync -av --files-from=- --from0 ${excludes} . "${mirrorPath}/"`;
-            yield execAsync(cmd);
-        }
-        else {
-            const cmd = `rsync -av --delete ${excludes} "${sourcePath}/" "${mirrorPath}/"`;
-            yield execAsync(cmd);
-        }
-    });
-}
+export default FileSyncer;

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

@@ -0,0 +1,7 @@
+import { TestResults } from '../snapshotter.types.js';
+export default class TestResultsWriter {
+    private constructor();
+    static Writer(): TestResultsWriter;
+    write(mirrorPath: string, testResults: TestResults): void;
+    private sortTestResults;
+}

package/build/esm/components/TestResultsWriter.js

@@ -0,0 +1,33 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
+export default class TestResultsWriter {
+    constructor() { }
+    static Writer() {
+        return new this();
+    }
+    write(mirrorPath, testResults) {
+        const snapshotterDir = path.join(mirrorPath, '.snapshotter');
+        mkdirSync(snapshotterDir, { recursive: true });
+        const sorted = this.sortTestResults(testResults);
+        writeFileSync(path.join(snapshotterDir, 'testResults.json'), JSON.stringify(sorted, null, 2));
+    }
+    sortTestResults(testResults) {
+        const suites = [...testResults.suites].map((suite) => (Object.assign(Object.assign({}, suite), { tests: [...suite.tests].sort((left, right) => left.name.localeCompare(right.name)) })));
+        suites.sort((left, right) => left.path.localeCompare(right.path));
+        const typeErrors = testResults.typeErrors
+            ? [...testResults.typeErrors].sort((left, right) => {
+                const fileCompare = left.file.localeCompare(right.file);
+                if (fileCompare !== 0) {
+                    return fileCompare;
+                }
+                const lineCompare = left.line - right.line;
+                if (lineCompare !== 0) {
+                    return lineCompare;
+                }
+                return left.column - right.column;
+            })
+            : undefined;
+        return Object.assign(Object.assign({}, testResults), { suites,
+            typeErrors });
+    }
+}

package/build/esm/index.d.ts

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

package/build/esm/index.js

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

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, mkdirSync, 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';
+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 snapshotterDir = path.join(mirrorPath, '.snapshotter');
+        mkdirSync(snapshotterDir, { recursive: true });
+        const lockPath = path.join(snapshotterDir, LOCK_FILE_NAME);
+        const pendingPath = path.join(snapshotterDir, 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

@@ -7,12 +7,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import path from 'path';
 import { buildLog } from '@sprucelabs/spruce-skill-utils';
-import { gitCommit, gitPush } from '../git.js.js';
-import { syncFiles } from '../sync.js.js';
-const ERROR_FILE_NAME = 'lastError.json';
+import ErrorHandler from '../components/ErrorHandler.js.js';
+import SyncStrategy from '../strategies/SyncStrategy.js.js';
 const LOCK_FILE_NAME = 'snapshot.lock';
 const PENDING_FILE_NAME = 'pending.json';
 const log = buildLog('Snapshotter');
@@ -51,74 +50,16 @@ function processLoop(snapshotterDir) {
 }
 function executeSnapshot(options) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const sourcePath = (_a = options.sourcePath) !== null && _a !== void 0 ? _a : process.cwd();
-        const { mirrorPath, testResults, remote } = options;
-        log.info('Starting snapshot', sourcePath, mirrorPath);
         try {
-            yield syncFiles(sourcePath, mirrorPath);
-            log.info('Files synced', mirrorPath);
-            const snapshotterDir = path.join(mirrorPath, '.snapshotter');
-            mkdirSync(snapshotterDir, { recursive: true });
-            writeFileSync(path.join(snapshotterDir, 'testResults.json'), JSON.stringify(sortTestResults(testResults), null, 2));
-            log.info('Test results saved', snapshotterDir);
-            const committed = yield gitCommit(mirrorPath, log);
-            if (!committed) {
-                log.info('No changes to commit', mirrorPath);
-                clearError(mirrorPath);
-                return;
-            }
-            log.info('Commit created, pushing', remote.url);
-            yield gitPush(mirrorPath, remote, log);
-            log.info('Push completed', remote.url);
-            clearError(mirrorPath);
+            yield SyncStrategy.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);
-            persistError(mirrorPath, err);
+            ErrorHandler.Handler().persistError(options.mirrorPath, err);
         }
     });
 }
-function persistError(mirrorPath, err) {
-    const snapshotterDir = path.join(mirrorPath, '.snapshotter');
-    mkdirSync(snapshotterDir, { recursive: true });
-    const errorPath = getErrorFilePath(mirrorPath);
-    const errorData = {
-        message: err instanceof Error ? err.message : String(err),
-        stack: err instanceof Error ? err.stack : undefined,
-        timestamp: new Date().toISOString(),
-    };
-    writeFileSync(errorPath, JSON.stringify(errorData, null, 2));
-}
-function clearError(mirrorPath) {
-    const errorPath = getErrorFilePath(mirrorPath);
-    if (existsSync(errorPath)) {
-        unlinkSync(errorPath);
-    }
-}
-function getErrorFilePath(mirrorPath) {
-    return path.join(mirrorPath, '.snapshotter', ERROR_FILE_NAME);
-}
-function sortTestResults(testResults) {
-    const suites = [...testResults.suites].map((suite) => (Object.assign(Object.assign({}, suite), { tests: [...suite.tests].sort((left, right) => left.name.localeCompare(right.name)) })));
-    suites.sort((left, right) => left.path.localeCompare(right.path));
-    const typeErrors = testResults.typeErrors
-        ? [...testResults.typeErrors].sort((left, right) => {
-            const fileCompare = left.file.localeCompare(right.file);
-            if (fileCompare !== 0) {
-                return fileCompare;
-            }
-            const lineCompare = left.line - right.line;
-            if (lineCompare !== 0) {
-                return lineCompare;
-            }
-            return left.column - right.column;
-        })
-        : undefined;
-    return Object.assign(Object.assign({}, testResults), { suites,
-        typeErrors });
-}
 main().catch((err) => {
     console.error('Snapshot script failed:', err);
     process.exit(1);

package/build/esm/scripts/testManual.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { snapshot } from '../index.js';
+import { Snapshotter } from '../index.js';
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const sourcePath = process.env.SOURCE_PATH;
@@ -22,7 +22,8 @@ function main() {
         console.log('  Source:', sourcePath);
         console.log('  Mirror:', mirrorPath);
         console.log('  Remote:', remoteUrl);
-        const result = yield snapshot({
+        const snapshotter = Snapshotter.Snapshotter({ mode: 'sync' });
+        yield snapshotter.snapshot({
             sourcePath,
             mirrorPath,
             testResults: {
@@ -51,7 +52,7 @@ function main() {
                 token: remoteToken,
             },
         });
-        console.log('Snapshot created:', result);
+        console.log('Snapshot completed');
     });
 }
 main().catch((err) => {

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

@@ -0,0 +1,11 @@
+import { SnapshotOptions } from '../snapshotter.types.js';
+import SnapshotStrategy from './SnapshotStrategy.js';
+export default class AsyncStrategy implements SnapshotStrategy {
+    private log;
+    private scriptPath;
+    private constructor();
+    static Strategy(): AsyncStrategy;
+    execute(options: SnapshotOptions): void;
+    private writeOptionsFile;
+    private spawnSnapshotProcess;
+}

package/build/esm/strategies/AsyncStrategy.js

@@ -0,0 +1,32 @@
+import { spawn } from 'child_process';
+import { mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
+import { buildLog } from '@sprucelabs/spruce-skill-utils';
+export default class AsyncStrategy {
+    constructor() {
+        this.log = buildLog('Snapshotter');
+        this.scriptPath = path.join(__dirname, '..', 'scripts', 'runSnapshot.js');
+    }
+    static Strategy() {
+        return new this();
+    }
+    execute(options) {
+        const snapshotterDir = this.writeOptionsFile(options);
+        this.spawnSnapshotProcess(snapshotterDir);
+        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');
+        writeFileSync(optionsPath, JSON.stringify(options, null, 2));
+        return snapshotterDir;
+    }
+    spawnSnapshotProcess(snapshotterDir) {
+        const child = spawn('node', [this.scriptPath, snapshotterDir], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+    }
+}

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

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

package/build/esm/strategies/SnapshotStrategy.js

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

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,61 @@
+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 { 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';
+export default class SyncStrategy {
+    constructor() {
+        this.log = buildLog('Snapshotter');
+        this.pushScriptPath = path.join(__dirname, '..', 'scripts', 'runPush.js');
+    }
+    static Strategy() {
+        return new this();
+    }
+    execute(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const sourcePath = (_a = options.sourcePath) !== null && _a !== void 0 ? _a : process.cwd();
+            const { mirrorPath, testResults, remote } = options;
+            this.log.info('Starting snapshot', sourcePath, mirrorPath);
+            try {
+                yield FileSyncer.Syncer().sync(sourcePath, mirrorPath);
+                this.log.info('Files synced', mirrorPath);
+                TestResultsWriter.Writer().write(mirrorPath, testResults);
+                this.log.info('Test results saved', mirrorPath);
+                const committed = yield gitCommit(mirrorPath, this.log);
+                if (!committed) {
+                    this.log.info('No changes to commit', mirrorPath);
+                    ErrorHandler.Handler().clearError(mirrorPath);
+                    return;
+                }
+                this.log.info('Commit created, queueing push', remote.url);
+                this.spawnPushProcess(mirrorPath, remote);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.log.error('Snapshot failed', message);
+                ErrorHandler.Handler().persistError(mirrorPath, err);
+                throw err;
+            }
+        });
+    }
+    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/index.d.ts

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

package/build/index.js

@@ -13,9 +13,11 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkForPreviousSnapshotFailure = exports.snapshot = void 0;
-var snapshot_js_1 = require("./snapshot.js");
-Object.defineProperty(exports, "snapshot", { enumerable: true, get: function () { return snapshot_js_1.snapshot; } });
-Object.defineProperty(exports, "checkForPreviousSnapshotFailure", { enumerable: true, get: function () { return snapshot_js_1.checkForPreviousSnapshotFailure; } });
+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);

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 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 snapshotterDir = path_1.default.join(mirrorPath, '.snapshotter');
+    (0, fs_1.mkdirSync)(snapshotterDir, { recursive: true });
+    const lockPath = path_1.default.join(snapshotterDir, LOCK_FILE_NAME);
+    const pendingPath = path_1.default.join(snapshotterDir, 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

@@ -6,9 +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 git_js_1 = require("../git.js");
-const sync_js_1 = require("../sync.js");
-const ERROR_FILE_NAME = 'lastError.json';
+const ErrorHandler_js_1 = __importDefault(require("../components/ErrorHandler.js"));
+const SyncStrategy_js_1 = __importDefault(require("../strategies/SyncStrategy.js"));
 const LOCK_FILE_NAME = 'snapshot.lock';
 const PENDING_FILE_NAME = 'pending.json';
 const log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
@@ -42,78 +41,15 @@ async function processLoop(snapshotterDir) {
     }
 }
 async function executeSnapshot(options) {
-    const sourcePath = options.sourcePath ?? process.cwd();
-    const { mirrorPath, testResults, remote } = options;
-    log.info('Starting snapshot', sourcePath, mirrorPath);
     try {
-        await (0, sync_js_1.syncFiles)(sourcePath, mirrorPath);
-        log.info('Files synced', mirrorPath);
-        const snapshotterDir = path_1.default.join(mirrorPath, '.snapshotter');
-        (0, fs_1.mkdirSync)(snapshotterDir, { recursive: true });
-        (0, fs_1.writeFileSync)(path_1.default.join(snapshotterDir, 'testResults.json'), JSON.stringify(sortTestResults(testResults), null, 2));
-        log.info('Test results saved', snapshotterDir);
-        const committed = await (0, git_js_1.gitCommit)(mirrorPath, log);
-        if (!committed) {
-            log.info('No changes to commit', mirrorPath);
-            clearError(mirrorPath);
-            return;
-        }
-        log.info('Commit created, pushing', remote.url);
-        await (0, git_js_1.gitPush)(mirrorPath, remote, log);
-        log.info('Push completed', remote.url);
-        clearError(mirrorPath);
+        await SyncStrategy_js_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);
-        persistError(mirrorPath, err);
-    }
-}
-function persistError(mirrorPath, err) {
-    const snapshotterDir = path_1.default.join(mirrorPath, '.snapshotter');
-    (0, fs_1.mkdirSync)(snapshotterDir, { recursive: true });
-    const errorPath = getErrorFilePath(mirrorPath);
-    const errorData = {
-        message: err instanceof Error ? err.message : String(err),
-        stack: err instanceof Error ? err.stack : undefined,
-        timestamp: new Date().toISOString(),
-    };
-    (0, fs_1.writeFileSync)(errorPath, JSON.stringify(errorData, null, 2));
-}
-function clearError(mirrorPath) {
-    const errorPath = getErrorFilePath(mirrorPath);
-    if ((0, fs_1.existsSync)(errorPath)) {
-        (0, fs_1.unlinkSync)(errorPath);
+        ErrorHandler_js_1.default.Handler().persistError(options.mirrorPath, err);
     }
 }
-function getErrorFilePath(mirrorPath) {
-    return path_1.default.join(mirrorPath, '.snapshotter', ERROR_FILE_NAME);
-}
-function sortTestResults(testResults) {
-    const suites = [...testResults.suites].map((suite) => ({
-        ...suite,
-        tests: [...suite.tests].sort((left, right) => left.name.localeCompare(right.name)),
-    }));
-    suites.sort((left, right) => left.path.localeCompare(right.path));
-    const typeErrors = testResults.typeErrors
-        ? [...testResults.typeErrors].sort((left, right) => {
-            const fileCompare = left.file.localeCompare(right.file);
-            if (fileCompare !== 0) {
-                return fileCompare;
-            }
-            const lineCompare = left.line - right.line;
-            if (lineCompare !== 0) {
-                return lineCompare;
-            }
-            return left.column - right.column;
-        })
-        : undefined;
-    return {
-        ...testResults,
-        suites,
-        typeErrors,
-    };
-}
 main().catch((err) => {
     console.error('Snapshot script failed:', err);
     process.exit(1);

package/build/scripts/testManual.js

@@ -14,7 +14,8 @@ async function main() {
     console.log('  Source:', sourcePath);
     console.log('  Mirror:', mirrorPath);
     console.log('  Remote:', remoteUrl);
-    const result = await (0, index_1.snapshot)({
+    const snapshotter = index_1.Snapshotter.Snapshotter({ mode: 'sync' });
+    await snapshotter.snapshot({
         sourcePath,
         mirrorPath,
         testResults: {
@@ -43,7 +44,7 @@ async function main() {
             token: remoteToken,
         },
     });
-    console.log('Snapshot created:', result);
+    console.log('Snapshot completed');
 }
 main().catch((err) => {
     console.error('Error:', err.message);

package/build/strategies/AsyncStrategy.d.ts

@@ -0,0 +1,11 @@
+import { SnapshotOptions } from '../snapshotter.types.js';
+import SnapshotStrategy from './SnapshotStrategy.js';
+export default class AsyncStrategy implements SnapshotStrategy {
+    private log;
+    private scriptPath;
+    private constructor();
+    static Strategy(): AsyncStrategy;
+    execute(options: SnapshotOptions): void;
+    private writeOptionsFile;
+    private spawnSnapshotProcess;
+}

package/build/strategies/AsyncStrategy.js

@@ -0,0 +1,38 @@
+"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 fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+class AsyncStrategy {
+    constructor() {
+        this.log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
+        this.scriptPath = path_1.default.join(__dirname, '..', 'scripts', 'runSnapshot.js');
+    }
+    static Strategy() {
+        return new this();
+    }
+    execute(options) {
+        const snapshotterDir = this.writeOptionsFile(options);
+        this.spawnSnapshotProcess(snapshotterDir);
+        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');
+        (0, fs_1.writeFileSync)(optionsPath, JSON.stringify(options, null, 2));
+        return snapshotterDir;
+    }
+    spawnSnapshotProcess(snapshotterDir) {
+        const child = (0, child_process_1.spawn)('node', [this.scriptPath, snapshotterDir], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+    }
+}
+exports.default = AsyncStrategy;

package/build/strategies/SnapshotStrategy.d.ts

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

package/build/strategies/SnapshotStrategy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/strategies/SyncStrategy.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,60 @@
+"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 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");
+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();
+    }
+    async execute(options) {
+        const sourcePath = options.sourcePath ?? process.cwd();
+        const { mirrorPath, testResults, remote } = options;
+        this.log.info('Starting snapshot', sourcePath, mirrorPath);
+        try {
+            await FileSyncer_js_1.default.Syncer().sync(sourcePath, mirrorPath);
+            this.log.info('Files synced', mirrorPath);
+            TestResultsWriter_js_1.default.Writer().write(mirrorPath, testResults);
+            this.log.info('Test results saved', mirrorPath);
+            const committed = await (0, git_js_1.gitCommit)(mirrorPath, this.log);
+            if (!committed) {
+                this.log.info('No changes to commit', mirrorPath);
+                ErrorHandler_js_1.default.Handler().clearError(mirrorPath);
+                return;
+            }
+            this.log.info('Commit created, queueing push', remote.url);
+            this.spawnPushProcess(mirrorPath, remote);
+        }
+        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);
+            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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@regressionproof/snapshotter",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "publishConfig": {
     "access": "public"
   },
@@ -94,5 +94,5 @@
     "@sprucelabs/spruce-core-schemas": "^42.1.3",
     "@sprucelabs/spruce-skill-utils": "^34.0.3"
   },
-  "gitHead": "860c3695ab884487c654e5cf794262bff8ea1570"
+  "gitHead": "a557f1266fcb9720f9551efb6fa6523e7390101e"
 }

package/build/esm/snapshot.d.ts

@@ -1,3 +0,0 @@
-import { SnapshotOptions } from './snapshotter.types.js';
-export declare function snapshot(options: SnapshotOptions): void;
-export declare function checkForPreviousSnapshotFailure(mirrorPath: string): void;

package/build/esm/snapshot.js

@@ -1,40 +0,0 @@
-import { spawn } from 'child_process';
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
-import path from 'path';
-import { buildLog } from '@sprucelabs/spruce-skill-utils';
-const ERROR_FILE_NAME = 'lastError.json';
-const log = buildLog('Snapshotter');
-const scriptPath = path.join(__dirname, 'scripts', 'runSnapshot.js');
-export function snapshot(options) {
-    const snapshotterDir = writeOptionsFile(options);
-    spawnSnapshotProcess(snapshotterDir);
-    log.info('Snapshot queued (running in background)', options.mirrorPath);
-}
-export function checkForPreviousSnapshotFailure(mirrorPath) {
-    const errorPath = getErrorFilePath(mirrorPath);
-    if (existsSync(errorPath)) {
-        const errorData = JSON.parse(readFileSync(errorPath, 'utf-8'));
-        unlinkSync(errorPath);
-        throw new Error(`Previous snapshot failed: ${errorData.message}\n` +
-            `Timestamp: ${errorData.timestamp}\n` +
-            `This error was from a background snapshot that failed. ` +
-            `The snapshot has been retried - if this error persists, check your configuration.`);
-    }
-}
-function writeOptionsFile(options) {
-    const snapshotterDir = path.join(options.mirrorPath, '.snapshotter');
-    mkdirSync(snapshotterDir, { recursive: true });
-    const optionsPath = path.join(snapshotterDir, 'pending.json');
-    writeFileSync(optionsPath, JSON.stringify(options, null, 2));
-    return snapshotterDir;
-}
-function spawnSnapshotProcess(snapshotterDir) {
-    const child = spawn('node', [scriptPath, snapshotterDir], {
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-}
-function getErrorFilePath(mirrorPath) {
-    return path.join(mirrorPath, '.snapshotter', ERROR_FILE_NAME);
-}

package/build/esm/sync.d.ts

@@ -1 +0,0 @@
-export declare function syncFiles(sourcePath: string, mirrorPath: string): Promise<void>;

package/build/snapshot.d.ts

@@ -1,3 +0,0 @@
-import { SnapshotOptions } from './snapshotter.types.js';
-export declare function snapshot(options: SnapshotOptions): void;
-export declare function checkForPreviousSnapshotFailure(mirrorPath: string): void;

package/build/snapshot.js

@@ -1,47 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.snapshot = snapshot;
-exports.checkForPreviousSnapshotFailure = checkForPreviousSnapshotFailure;
-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 ERROR_FILE_NAME = 'lastError.json';
-const log = (0, spruce_skill_utils_1.buildLog)('Snapshotter');
-const scriptPath = path_1.default.join(__dirname, 'scripts', 'runSnapshot.js');
-function snapshot(options) {
-    const snapshotterDir = writeOptionsFile(options);
-    spawnSnapshotProcess(snapshotterDir);
-    log.info('Snapshot queued (running in background)', options.mirrorPath);
-}
-function checkForPreviousSnapshotFailure(mirrorPath) {
-    const errorPath = getErrorFilePath(mirrorPath);
-    if ((0, fs_1.existsSync)(errorPath)) {
-        const errorData = JSON.parse((0, fs_1.readFileSync)(errorPath, 'utf-8'));
-        (0, fs_1.unlinkSync)(errorPath);
-        throw new Error(`Previous snapshot failed: ${errorData.message}\n` +
-            `Timestamp: ${errorData.timestamp}\n` +
-            `This error was from a background snapshot that failed. ` +
-            `The snapshot has been retried - if this error persists, check your configuration.`);
-    }
-}
-function 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');
-    (0, fs_1.writeFileSync)(optionsPath, JSON.stringify(options, null, 2));
-    return snapshotterDir;
-}
-function spawnSnapshotProcess(snapshotterDir) {
-    const child = (0, child_process_1.spawn)('node', [scriptPath, snapshotterDir], {
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-}
-function getErrorFilePath(mirrorPath) {
-    return path_1.default.join(mirrorPath, '.snapshotter', ERROR_FILE_NAME);
-}

package/build/sync.d.ts

@@ -1 +0,0 @@
-export declare function syncFiles(sourcePath: string, mirrorPath: string): Promise<void>;