runwork 0.15.0 → 0.15.2

package/dist/git/__tests__/preflight-resolution.test.js

@@ -1,366 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-// Mocks must be declared before imports of the module under test so vitest
-// hoists them above the static import.
-vi.mock('child_process', async () => {
-    const actual = await vi.importActual('child_process');
-    return { ...actual, execFileSync: vi.fn() };
-});
-vi.mock('fs', async () => {
-    const actual = await vi.importActual('fs');
-    return { ...actual, existsSync: vi.fn() };
-});
-vi.mock('os', async () => {
-    const actual = await vi.importActual('os');
-    return { ...actual, homedir: vi.fn(() => 'C:\\Users\\test') };
-});
-import { execFileSync } from 'child_process';
-import { existsSync } from 'fs';
-import { probeGit, resetGitProbeCache, buildMissingGitMessage, parseGitVersion, } from '../preflight.js';
-const mockedExec = vi.mocked(execFileSync);
-const mockedExists = vi.mocked(existsSync);
-function enoent(file) {
-    const err = new Error(`spawn ${file} ENOENT`);
-    err.code = 'ENOENT';
-    err.errno = -2;
-    err.syscall = `spawn ${file}`;
-    err.path = file;
-    return err;
-}
-describe('probeGit -- Windows fallback resolution', () => {
-    let originalPlatform;
-    let originalPath;
-    let originalProgramFiles;
-    let originalProgramFilesX86;
-    let originalLocalAppData;
-    beforeEach(() => {
-        resetGitProbeCache();
-        originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
-        Object.defineProperty(process, 'platform', { value: 'win32', writable: true, configurable: true });
-        originalPath = process.env.PATH;
-        originalProgramFiles = process.env.ProgramFiles;
-        originalProgramFilesX86 = process.env['ProgramFiles(x86)'];
-        originalLocalAppData = process.env.LOCALAPPDATA;
-        process.env.PATH = 'C:\\Windows\\system32;C:\\Windows';
-        process.env.ProgramFiles = 'C:\\Program Files';
-        process.env['ProgramFiles(x86)'] = 'C:\\Program Files (x86)';
-        process.env.LOCALAPPDATA = 'C:\\Users\\test\\AppData\\Local';
-        mockedExec.mockReset();
-        mockedExists.mockReset();
-    });
-    afterEach(() => {
-        if (originalPlatform)
-            Object.defineProperty(process, 'platform', originalPlatform);
-        if (originalPath !== undefined)
-            process.env.PATH = originalPath;
-        else
-            delete process.env.PATH;
-        if (originalProgramFiles !== undefined)
-            process.env.ProgramFiles = originalProgramFiles;
-        else
-            delete process.env.ProgramFiles;
-        if (originalProgramFilesX86 !== undefined)
-            process.env['ProgramFiles(x86)'] = originalProgramFilesX86;
-        else
-            delete process.env['ProgramFiles(x86)'];
-        if (originalLocalAppData !== undefined)
-            process.env.LOCALAPPDATA = originalLocalAppData;
-        else
-            delete process.env.LOCALAPPDATA;
-        delete process.env.Path;
-    });
-    it('resolves via where.exe when bare git lookup fails', () => {
-        const realGitPath = 'C:\\Program Files\\Git\\cmd\\git.exe';
-        mockedExec.mockImplementation((file) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                return Buffer.from(`${realGitPath}\r\n`);
-            if (file === realGitPath)
-                return Buffer.from('git version 2.43.0.windows.1');
-            throw enoent(file);
-        });
-        mockedExists.mockImplementation((p) => p === realGitPath);
-        const probe = probeGit();
-        expect(probe.installed).toBe(true);
-        expect(probe.source).toBe('where');
-        expect(probe.path).toBe(realGitPath);
-        expect(probe.version).toContain('git version 2.43.0');
-    });
-    it('prepends the resolved git directory to PATH', () => {
-        const realGitPath = 'C:\\Program Files\\Git\\cmd\\git.exe';
-        mockedExec.mockImplementation((file) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                return Buffer.from(`${realGitPath}\r\n`);
-            if (file === realGitPath)
-                return Buffer.from('git version 2.43.0');
-            throw enoent(file);
-        });
-        mockedExists.mockReturnValue(true);
-        probeGit();
-        expect(process.env.PATH?.split(';')[0]).toBe('C:\\Program Files\\Git\\cmd');
-    });
-    it('also mirrors the new value into Path (case variant) when present', () => {
-        process.env.Path = process.env.PATH; // simulate Windows where Path is set
-        const realGitPath = 'C:\\Program Files\\Git\\cmd\\git.exe';
-        mockedExec.mockImplementation((file) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                return Buffer.from(`${realGitPath}\r\n`);
-            if (file === realGitPath)
-                return Buffer.from('git version 2.43.0');
-            throw enoent(file);
-        });
-        mockedExists.mockReturnValue(true);
-        probeGit();
-        expect(process.env.Path).toBe(process.env.PATH);
-    });
-    it('prefers .exe match when where.exe lists multiple candidates', () => {
-        const exePath = 'C:\\Program Files\\Git\\cmd\\git.exe';
-        const cmdShim = 'C:\\Users\\test\\.runwork\\bin\\git';
-        mockedExec.mockImplementation((file) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                return Buffer.from(`${cmdShim}\r\n${exePath}\r\n`);
-            if (file === exePath)
-                return Buffer.from('git version 2.43.0');
-            throw enoent(file);
-        });
-        mockedExists.mockImplementation((p) => p === exePath || p === cmdShim);
-        const probe = probeGit();
-        expect(probe.path).toBe(exePath);
-    });
-    it('falls back to the registry when where.exe fails', () => {
-        const installRoot = 'C:\\Program Files\\Git';
-        const gitExe = 'C:\\Program Files\\Git\\cmd\\git.exe';
-        mockedExec.mockImplementation((file, args) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                throw enoent('where.exe');
-            if (file === 'reg.exe') {
-                // Only HKLM has a value; HKCU returns nothing (we throw to mimic).
-                const key = args?.[1] ?? '';
-                if (key.includes('HKLM')) {
-                    return Buffer.from('HKEY_LOCAL_MACHINE\\SOFTWARE\\GitForWindows\r\n' +
-                        `    InstallPath    REG_SZ    ${installRoot}\r\n`);
-                }
-                throw enoent('reg.exe');
-            }
-            if (file === gitExe)
-                return Buffer.from('git version 2.43.0');
-            throw enoent(file);
-        });
-        mockedExists.mockImplementation((p) => p === gitExe);
-        const probe = probeGit();
-        expect(probe.installed).toBe(true);
-        expect(probe.source).toBe('registry');
-        expect(probe.path).toBe(gitExe);
-        expect(process.env.PATH?.split(';')[0]).toBe('C:\\Program Files\\Git\\cmd');
-    });
-    it('honours HKCU\\Software\\GitForWindows when HKLM is empty', () => {
-        const installRoot = 'C:\\Users\\test\\AppData\\Local\\Programs\\Git';
-        const gitExe = 'C:\\Users\\test\\AppData\\Local\\Programs\\Git\\cmd\\git.exe';
-        mockedExec.mockImplementation((file, args) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                throw enoent('where.exe');
-            if (file === 'reg.exe') {
-                const key = args?.[1] ?? '';
-                if (key.includes('HKLM'))
-                    throw enoent('reg.exe');
-                if (key.includes('HKCU')) {
-                    return Buffer.from('HKEY_CURRENT_USER\\Software\\GitForWindows\r\n' +
-                        `    InstallPath    REG_SZ    ${installRoot}\r\n`);
-                }
-                throw enoent('reg.exe');
-            }
-            if (file === gitExe)
-                return Buffer.from('git version 2.43.0');
-            throw enoent(file);
-        });
-        mockedExists.mockImplementation((p) => p === gitExe);
-        const probe = probeGit();
-        expect(probe.installed).toBe(true);
-        expect(probe.source).toBe('registry');
-        expect(probe.path).toBe(gitExe);
-    });
-    it('falls back to canonical install path when where.exe and registry both fail', () => {
-        const canonical = 'C:\\Program Files\\Git\\cmd\\git.exe';
-        mockedExec.mockImplementation((file) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                throw enoent('where.exe');
-            if (file === 'reg.exe')
-                throw enoent('reg.exe');
-            if (file === canonical)
-                return Buffer.from('git version 2.43.0');
-            throw enoent(file);
-        });
-        mockedExists.mockImplementation((p) => p === canonical);
-        const probe = probeGit();
-        expect(probe.installed).toBe(true);
-        expect(probe.source).toBe('canonical');
-        expect(probe.path).toBe(canonical);
-        expect(process.env.PATH?.split(';')[0]).toBe('C:\\Program Files\\Git\\cmd');
-    });
-    it('finds a portable MinGit dropped under ~/.runwork/tools/mingit', () => {
-        const portable = 'C:\\Users\\test\\.runwork\\tools\\mingit\\cmd\\git.exe';
-        mockedExec.mockImplementation((file) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                throw enoent('where.exe');
-            if (file === 'reg.exe')
-                throw enoent('reg.exe');
-            if (file === portable)
-                return Buffer.from('git version 2.45.0.windows.1');
-            throw enoent(file);
-        });
-        mockedExists.mockImplementation((p) => p === portable);
-        const probe = probeGit();
-        expect(probe.installed).toBe(true);
-        expect(probe.source).toBe('canonical');
-        expect(probe.path).toBe(portable);
-    });
-    it('finds a Scoop install at ~/scoop/apps/git/current/cmd/git.exe', () => {
-        const scoop = 'C:\\Users\\test\\scoop\\apps\\git\\current\\cmd\\git.exe';
-        mockedExec.mockImplementation((file) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                throw enoent('where.exe');
-            if (file === 'reg.exe')
-                throw enoent('reg.exe');
-            if (file === scoop)
-                return Buffer.from('git version 2.45.0');
-            throw enoent(file);
-        });
-        mockedExists.mockImplementation((p) => p === scoop);
-        const probe = probeGit();
-        expect(probe.installed).toBe(true);
-        expect(probe.path).toBe(scoop);
-    });
-    it('returns installed=false when nothing resolves and preserves the bare-call error', () => {
-        mockedExec.mockImplementation((file) => { throw enoent(file); });
-        mockedExists.mockReturnValue(false);
-        const probe = probeGit();
-        expect(probe.installed).toBe(false);
-        expect(probe.error?.code).toBe('ENOENT');
-        expect(probe.error?.path).toBe('git');
-        // No PATH side-effect when nothing was resolved.
-        expect(process.env.PATH?.startsWith('C:\\Windows\\system32')).toBe(true);
-    });
-    it('caches the probe result across calls and stops re-spawning git', () => {
-        const realGitPath = 'C:\\Program Files\\Git\\cmd\\git.exe';
-        mockedExec.mockImplementation((file) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                return Buffer.from(`${realGitPath}\r\n`);
-            if (file === realGitPath)
-                return Buffer.from('git version 2.43.0');
-            throw enoent(file);
-        });
-        mockedExists.mockReturnValue(true);
-        const first = probeGit();
-        const callsAfterFirst = mockedExec.mock.calls.length;
-        const second = probeGit();
-        expect(second).toBe(first);
-        expect(mockedExec.mock.calls.length).toBe(callsAfterFirst);
-    });
-    it('does not double-prepend PATH on repeat probes after a cache reset', () => {
-        const realGitPath = 'C:\\Program Files\\Git\\cmd\\git.exe';
-        mockedExec.mockImplementation((file) => {
-            if (file === 'git')
-                throw enoent('git');
-            if (file === 'where.exe')
-                return Buffer.from(`${realGitPath}\r\n`);
-            if (file === realGitPath)
-                return Buffer.from('git version 2.43.0');
-            throw enoent(file);
-        });
-        mockedExists.mockReturnValue(true);
-        probeGit();
-        const pathAfterFirst = process.env.PATH;
-        resetGitProbeCache();
-        probeGit();
-        expect(process.env.PATH).toBe(pathAfterFirst);
-    });
-    it('skips canonical paths whose env var is unset', () => {
-        delete process.env.ProgramFiles;
-        delete process.env['ProgramFiles(x86)'];
-        delete process.env.LOCALAPPDATA;
-        // Only the hard-coded "C:\\Program Files\\Git\\cmd\\git.exe" default
-        // remains. Make existsSync reject it too -- nothing should resolve.
-        mockedExec.mockImplementation((file) => { throw enoent(file); });
-        mockedExists.mockReturnValue(false);
-        const probe = probeGit();
-        expect(probe.installed).toBe(false);
-    });
-});
-describe('probeGit -- non-Windows hosts skip the fallback', () => {
-    let originalPlatform;
-    beforeEach(() => {
-        resetGitProbeCache();
-        originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
-        Object.defineProperty(process, 'platform', { value: 'darwin', writable: true, configurable: true });
-        mockedExec.mockReset();
-        mockedExists.mockReset();
-    });
-    afterEach(() => {
-        if (originalPlatform)
-            Object.defineProperty(process, 'platform', originalPlatform);
-    });
-    it('does not invoke where.exe on macOS when bare lookup fails', () => {
-        mockedExec.mockImplementation((file) => { throw enoent(file); });
-        mockedExists.mockReturnValue(true);
-        const probe = probeGit();
-        expect(probe.installed).toBe(false);
-        const calledFiles = mockedExec.mock.calls.map((c) => c[0]);
-        expect(calledFiles).toContain('git');
-        expect(calledFiles).not.toContain('where.exe');
-    });
-    it('returns immediately on bare-call success without further probing', () => {
-        mockedExec.mockImplementation((file) => {
-            if (file === 'git')
-                return Buffer.from('git version 2.45.0');
-            throw enoent(file);
-        });
-        mockedExists.mockReturnValue(false);
-        const probe = probeGit();
-        expect(probe.installed).toBe(true);
-        expect(probe.source).toBe('PATH');
-        expect(probe.path).toBe('git');
-        expect(mockedExists).not.toHaveBeenCalled();
-    });
-});
-describe('parseGitVersion', () => {
-    it('extracts a semver-ish number from `git --version` output', () => {
-        expect(parseGitVersion('git version 2.43.0')).toBe('2.43.0');
-        expect(parseGitVersion('git version 2.43.0.windows.1')).toBe('2.43.0');
-        expect(parseGitVersion('git version 2.45')).toBe('2.45');
-    });
-    it('returns null for unparsable input', () => {
-        expect(parseGitVersion(undefined)).toBeNull();
-        expect(parseGitVersion('')).toBeNull();
-        expect(parseGitVersion('not a version')).toBeNull();
-    });
-});
-describe('buildMissingGitMessage with a probe error', () => {
-    it('appends the underlying error message when one is present', () => {
-        const err = new Error('spawn git ENOENT');
-        err.code = 'ENOENT';
-        const msg = buildMissingGitMessage('clone', { installed: false, error: err });
-        expect(msg).toContain('Underlying error: spawn git ENOENT');
-    });
-    it('omits the underlying-error footer when no probe is supplied', () => {
-        const msg = buildMissingGitMessage('clone');
-        expect(msg).not.toContain('Underlying error');
-    });
-});

package/dist/git/__tests__/preflight.test.d.ts

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

package/dist/git/__tests__/preflight.test.js

@@ -1,36 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { probeGit, buildMissingGitMessage } from '../preflight.js';
-describe('probeGit', () => {
-    it('reports installed=true when git is on PATH (CI invariant)', () => {
-        // The CLI test suite already shells out to git in many other tests, so
-        // we treat git as a hard prerequisite for this package's own tests.
-        const probe = probeGit();
-        expect(probe.installed).toBe(true);
-        expect(probe.version).toMatch(/^git version /);
-    });
-});
-describe('buildMissingGitMessage', () => {
-    it('mentions the failing command name', () => {
-        const msg = buildMissingGitMessage('clone');
-        expect(msg).toContain('runwork clone');
-    });
-    it('lists install hints for all three OSes', () => {
-        const msg = buildMissingGitMessage('dev');
-        expect(msg).toMatch(/macOS/);
-        expect(msg).toMatch(/Windows/);
-        expect(msg).toMatch(/Linux/);
-    });
-    it('ends with a verification command', () => {
-        const msg = buildMissingGitMessage('init');
-        expect(msg).toContain('git --version');
-    });
-    it('only includes the Windows-shell-PATH hint when running on Windows', () => {
-        const msg = buildMissingGitMessage('clone');
-        if (process.platform === 'win32') {
-            expect(msg).toMatch(/cached when it opened/);
-        }
-        else {
-            expect(msg).not.toMatch(/cached when it opened/);
-        }
-    });
-});

package/dist/git/__tests__/repo-config.test.d.ts

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

package/dist/git/__tests__/repo-config.test.js

@@ -1,26 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('child_process');
-const mockExecFileSync = (await import('child_process')).execFileSync;
-const { hardenRepoForRestrictedFs } = await import('../repo-config.js');
-describe('git/repo-config hardenRepoForRestrictedFs', () => {
-    beforeEach(() => vi.clearAllMocks());
-    it('disables gc.auto and maintenance.auto in the repo (local scope)', () => {
-        mockExecFileSync.mockReturnValue(Buffer.from(''));
-        hardenRepoForRestrictedFs('/repo');
-        const configCalls = mockExecFileSync.mock.calls
-            .filter((c) => c[0] === 'git' && c[1][0] === 'config')
-            .map((c) => c[1].slice(1));
-        expect(configCalls).toContainEqual(['gc.auto', '0']);
-        expect(configCalls).toContainEqual(['maintenance.auto', 'false']);
-        // Repo scope, not --global.
-        expect(configCalls.every((args) => !args.includes('--global'))).toBe(true);
-        // Run against the given cwd.
-        for (const call of mockExecFileSync.mock.calls) {
-            expect(call[2].cwd).toBe('/repo');
-        }
-    });
-    it('never throws when git config fails (best-effort)', () => {
-        mockExecFileSync.mockImplementation(() => { throw new Error('git unavailable'); });
-        expect(() => hardenRepoForRestrictedFs('/repo')).not.toThrow();
-    });
-});

package/dist/git/__tests__/sync.test.d.ts

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