runwork 0.15.0 → 0.15.2

package/dist/git/__tests__/credential-helper-e2e.test.js

@@ -1,195 +0,0 @@
-/**
- * End-to-end auth test.
- *
- * Spins up a tiny HTTP server that mimics the runwork.ai git endpoint's
- * auth contract (HTTP Basic, any username, password = API key) and runs a
- * real `git ls-remote` against it through a credential-helper script. This
- * verifies the entire chain we depend on:
- *
- *   git -> credential.<origin>.helper -> our helper script -> our helper's
- *   protocol output -> git constructs Basic auth -> server accepts it.
- *
- * Catches the class of bugs we've burned hours on (Pass 1's PATH issues,
- * Pass 2's "logged in but no helper registered") *before* a user hits them.
- *
- * Note: this test exercises the contract our credential helper depends on,
- * not the helper function itself -- credentials.test.ts already covers
- * `handleGitCredentialRequest()` in isolation. Together they prove that
- * (a) the helper produces the right protocol output and (b) git+server
- * accept that output as Basic auth.
- */
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { mkdtempSync, writeFileSync, rmSync, chmodSync, existsSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { createServer } from 'http';
-import { probeGit } from '../preflight.js';
-const execFileAsync = promisify(execFile);
-const EXPECTED_API_KEY = 'test-api-key-abcd1234';
-/**
- * Minimal HTTP server that:
- *   - Returns 401 + WWW-Authenticate when no Basic auth is supplied
- *   - Returns 401 when password (the API key) is wrong; username is ignored
- *   - Returns 200 + a valid empty-refs pkt-line response when auth is correct
- *
- * The pkt-line response is the smallest valid output for `info/refs?
- * service=git-upload-pack` -- the service announcement plus a flush packet.
- * That's enough for `git ls-remote` to terminate successfully.
- */
-function createBasicAuthGitServer(attempts) {
-    return new Promise((resolve) => {
-        const server = createServer((req, res) => {
-            const authHeader = req.headers['authorization'];
-            if (!authHeader || !authHeader.startsWith('Basic ')) {
-                attempts.push({ hasAuthHeader: false });
-                res.writeHead(401, {
-                    'WWW-Authenticate': 'Basic realm="Test"',
-                    'Content-Type': 'text/plain',
-                });
-                res.end('Authentication required');
-                return;
-            }
-            const decoded = Buffer.from(authHeader.slice(6), 'base64').toString('utf-8');
-            const colonIdx = decoded.indexOf(':');
-            const username = colonIdx >= 0 ? decoded.slice(0, colonIdx) : decoded;
-            const password = colonIdx >= 0 ? decoded.slice(colonIdx + 1) : '';
-            attempts.push({ hasAuthHeader: true, username, password });
-            if (password !== EXPECTED_API_KEY) {
-                res.writeHead(401, {
-                    'WWW-Authenticate': 'Basic realm="Test"',
-                    'Content-Type': 'text/plain',
-                });
-                res.end('Invalid API key');
-                return;
-            }
-            // Minimal valid info/refs response for git-upload-pack with no refs.
-            // Shape:
-            //   001e# service=git-upload-pack\n
-            //   0000
-            //   0000   (no refs)
-            const service = '# service=git-upload-pack\n';
-            const pktServiceLength = (service.length + 4).toString(16).padStart(4, '0');
-            const flush = '0000';
-            const body = `${pktServiceLength}${service}${flush}${flush}`;
-            res.writeHead(200, {
-                'Content-Type': 'application/x-git-upload-pack-advertisement',
-                'Cache-Control': 'no-cache',
-            });
-            res.end(body);
-        });
-        server.listen(0, '127.0.0.1', () => resolve(server));
-    });
-}
-/**
- * Write a credential helper script into `dir` and return its path. The
- * script ignores stdin (test fixtures don't need to honour git's
- * action/host inputs) and prints the test's API key. Bash on macOS/Linux
- * and Git Bash on Windows both run the resulting `!"<path>"` invocation
- * the same way.
- */
-function writeHelperScript(dir, apiKey) {
-    const scriptPath = join(dir, 'fake-helper.sh');
-    const body = [
-        '#!/usr/bin/env bash',
-        '# Test fixture: emits the git credential helper "get" protocol output',
-        '# with a hardcoded API key. The "get" arg is the only one git invokes',
-        '# during a fetch; "store"/"erase" are no-ops.',
-        'if [ "$1" != "get" ]; then exit 0; fi',
-        '# Drain stdin so git\'s pipe doesn\'t stall.',
-        'cat > /dev/null',
-        'echo "username=runwork"',
-        `echo "password=${apiKey}"`,
-        '',
-    ].join('\n');
-    writeFileSync(scriptPath, body, { mode: 0o755 });
-    // chmod is no-op on Windows but won't error.
-    chmodSync(scriptPath, 0o755);
-    return scriptPath;
-}
-describe('git credential helper e2e (Basic auth contract)', () => {
-    const gitProbe = probeGit();
-    const skipReason = !gitProbe.installed ? 'git not installed' : null;
-    let tmpDir;
-    let homeDir;
-    let xdgConfigHome;
-    let scriptPath;
-    let server;
-    let serverUrl;
-    let attempts = [];
-    beforeAll(async () => {
-        if (skipReason)
-            return;
-        tmpDir = mkdtempSync(join(tmpdir(), 'runwork-helper-e2e-'));
-        homeDir = join(tmpDir, 'home');
-        xdgConfigHome = join(homeDir, '.config');
-        // git -c gc.auto=0 needs ~/.gitconfig to exist when GIT_CONFIG_GLOBAL is
-        // pointed at a path that doesn't yet exist; pre-create the dir and
-        // empty file.
-        const gitConfigGlobal = join(homeDir, '.gitconfig');
-        require('fs').mkdirSync(homeDir, { recursive: true });
-        writeFileSync(gitConfigGlobal, '');
-        scriptPath = writeHelperScript(tmpDir, EXPECTED_API_KEY);
-        server = await createBasicAuthGitServer(attempts);
-        const addr = server.address();
-        serverUrl = `http://127.0.0.1:${addr.port}`;
-        // Register the credential helper globally in the isolated git config.
-        // We use the unscoped `credential.helper` (not `credential.<url>.helper`)
-        // because (a) the test config is fully isolated so we don't risk
-        // bleeding into other host auth flows and (b) git's URL matching for
-        // scoped helpers has subtleties that aren't what we're testing here --
-        // we're testing the helper *contract*, not git's URL matcher.
-        const gitBin = gitProbe.path ?? 'git';
-        await execFileAsync(gitBin, [
-            'config', '--file', gitConfigGlobal,
-            'credential.helper', `!"${scriptPath}"`,
-        ]);
-    });
-    afterAll(() => {
-        if (server)
-            server.close();
-        if (tmpDir && existsSync(tmpDir))
-            rmSync(tmpDir, { recursive: true, force: true });
-    });
-    it.skipIf(skipReason)('git ls-remote authenticates via the credential helper end-to-end', async () => {
-        const gitBin = gitProbe.path ?? 'git';
-        // Use GIT_CONFIG_GLOBAL to isolate from the user's real ~/.gitconfig
-        // (which may have an auth helper registered for some other host).
-        const env = {
-            ...process.env,
-            GIT_CONFIG_GLOBAL: join(homeDir, '.gitconfig'),
-            GIT_CONFIG_SYSTEM: '/dev/null',
-            XDG_CONFIG_HOME: xdgConfigHome,
-            HOME: homeDir,
-            // Force git to never prompt -- if the helper fails, we want the
-            // command to exit non-zero, not hang.
-            GIT_TERMINAL_PROMPT: '0',
-        };
-        const path = '/test-workspace/test-app';
-        const url = `${serverUrl}${path}`;
-        // ls-remote against the fake server. Should exit 0 (server accepted
-        // auth and returned a valid -- empty -- ref advertisement).
-        const result = await execFileAsync(gitBin, ['ls-remote', url], { env });
-        expect(result.stdout).toBe('');
-        // No refs in the test response, so stdout is empty.
-        // Verify the server actually saw a Basic-auth attempt with our key.
-        const successAttempt = attempts.find((a) => a.hasAuthHeader && a.password === EXPECTED_API_KEY);
-        expect(successAttempt).toBeDefined();
-        expect(successAttempt.username).toBe('runwork');
-    }, 20_000);
-    it.skipIf(skipReason)('server rejects requests with no auth (sanity: contract is enforced)', async () => {
-        // Direct fetch with no Authorization header should 401.
-        const response = await fetch(`${serverUrl}/whatever`);
-        expect(response.status).toBe(401);
-        expect(response.headers.get('www-authenticate')).toContain('Basic');
-    });
-    it.skipIf(skipReason)('server rejects requests with the wrong API key (sanity: contract is enforced)', async () => {
-        const response = await fetch(`${serverUrl}/whatever`, {
-            headers: {
-                authorization: `Basic ${Buffer.from('runwork:wrong-key').toString('base64')}`,
-            },
-        });
-        expect(response.status).toBe(401);
-    });
-});

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

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

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

@@ -1,141 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('child_process');
-vi.mock('../../auth/store.js', () => ({
-    getCredentials: vi.fn(),
-}));
-const mockExecFileSync = (await import('child_process')).execFileSync;
-const { getCredentials: mockGetCredentials } = await import('../../auth/store.js');
-const { configureGitCredentials, removeGitCredentials, handleGitCredentialRequest, buildHelperValue, } = await import('../credentials.js');
-describe('git/credentials', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('buildHelperValue()', () => {
-        it('wraps the execPath in quotes and prefixes with !', () => {
-            expect(buildHelperValue('/usr/local/bin/runwork')).toBe('!"/usr/local/bin/runwork" git-credential-helper');
-        });
-        it('normalises Windows backslashes to forward slashes for .gitconfig safety', () => {
-            expect(buildHelperValue('C:\\Users\\test\\.runwork\\bin\\runwork.exe')).toBe('!"C:/Users/test/.runwork/bin/runwork.exe" git-credential-helper');
-        });
-        it('survives spaces in install paths via quoting', () => {
-            expect(buildHelperValue('C:\\Program Files\\Runwork\\runwork.exe')).toBe('!"C:/Program Files/Runwork/runwork.exe" git-credential-helper');
-        });
-    });
-    describe('configureGitCredentials()', () => {
-        it('registers the helper using process.execPath, not bare "runwork"', async () => {
-            await configureGitCredentials('https://runwork.ai/api/git/ws/app');
-            // Don't pin process.execPath itself (varies per machine), but
-            // assert the value follows the absolute-path shape so PATH-relative
-            // regressions are caught.
-            const call = mockExecFileSync.mock.calls.find((c) => c[0] === 'git' && c[1]?.includes('--global'));
-            expect(call).toBeDefined();
-            const args = call[1];
-            expect(args).toContain('config');
-            expect(args).toContain('--global');
-            expect(args).toContain('credential.https://runwork.ai.helper');
-            const helperValue = args[args.length - 1];
-            expect(helperValue).toMatch(/^!"[^"]+" git-credential-helper$/);
-            expect(helperValue).not.toBe('!runwork git-credential-helper');
-            // The path inside the quotes should be process.execPath, normalised.
-            expect(helperValue).toContain(process.execPath.replace(/\\/g, '/'));
-        });
-        it('extracts origin from full URL', async () => {
-            await configureGitCredentials('https://custom.runwork.dev/api/git/ws-1/app-1');
-            const call = mockExecFileSync.mock.calls[0];
-            const args = call[1];
-            expect(args[2]).toBe('credential.https://custom.runwork.dev.helper');
-        });
-        it('handles URL with port', async () => {
-            await configureGitCredentials('https://localhost:8787/api/git/ws/app');
-            const call = mockExecFileSync.mock.calls[0];
-            const args = call[1];
-            expect(args[2]).toBe('credential.https://localhost:8787.helper');
-        });
-    });
-    describe('removeGitCredentials()', () => {
-        it('calls git config --unset', async () => {
-            await removeGitCredentials('https://runwork.ai');
-            expect(mockExecFileSync).toHaveBeenCalledWith('git', [
-                'config',
-                '--global',
-                '--unset',
-                'credential.https://runwork.ai.helper',
-            ], { stdio: 'pipe', windowsHide: true });
-        });
-        it('ignores errors silently', async () => {
-            mockExecFileSync.mockImplementation(() => {
-                throw new Error('config key not found');
-            });
-            // Should not throw
-            await expect(removeGitCredentials('https://runwork.ai')).resolves.toBeUndefined();
-        });
-    });
-    describe('handleGitCredentialRequest()', () => {
-        it('ignores non-get actions (store)', async () => {
-            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-            await handleGitCredentialRequest('store');
-            expect(writeSpy).not.toHaveBeenCalled();
-            writeSpy.mockRestore();
-        });
-        it('ignores non-get actions (erase)', async () => {
-            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-            await handleGitCredentialRequest('erase');
-            expect(writeSpy).not.toHaveBeenCalled();
-            writeSpy.mockRestore();
-        });
-        it('exits with code 1 when no credentials stored', async () => {
-            vi.mocked(mockGetCredentials).mockReturnValue(null);
-            // Mock stdin to provide input then end
-            const mockStdin = {
-                setEncoding: vi.fn(),
-                on: vi.fn((event, cb) => {
-                    if (event === 'data')
-                        cb('protocol=https\nhost=runwork.ai\n');
-                    if (event === 'end')
-                        cb();
-                }),
-                readableEnded: false,
-            };
-            const originalStdin = process.stdin;
-            Object.defineProperty(process, 'stdin', { value: mockStdin, writable: true });
-            const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
-                throw new Error('process.exit');
-            }));
-            await expect(handleGitCredentialRequest('get')).rejects.toThrow('process.exit');
-            expect(exitSpy).toHaveBeenCalledWith(1);
-            exitSpy.mockRestore();
-            Object.defineProperty(process, 'stdin', { value: originalStdin, writable: true });
-        });
-        it('outputs correct credential format when credentials exist', async () => {
-            vi.mocked(mockGetCredentials).mockReturnValue({
-                apiKey: 'my-api-key',
-                email: 'test@example.com',
-                baseUrl: 'https://runwork.ai',
-            });
-            const mockStdin = {
-                setEncoding: vi.fn(),
-                on: vi.fn((event, cb) => {
-                    if (event === 'data')
-                        cb('protocol=https\nhost=runwork.ai\n');
-                    if (event === 'end')
-                        cb();
-                }),
-                readableEnded: false,
-            };
-            const originalStdin = process.stdin;
-            Object.defineProperty(process, 'stdin', { value: mockStdin, writable: true });
-            const writes = [];
-            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation((data) => {
-                writes.push(data.toString());
-                return true;
-            });
-            await handleGitCredentialRequest('get');
-            expect(writes).toContain('protocol=https\n');
-            expect(writes).toContain('host=runwork.ai\n');
-            expect(writes).toContain('username=runwork\n');
-            expect(writes).toContain('password=my-api-key\n');
-            writeSpy.mockRestore();
-            Object.defineProperty(process, 'stdin', { value: originalStdin, writable: true });
-        });
-    });
-});

package/dist/git/__tests__/deploy-guard.test.d.ts

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

package/dist/git/__tests__/deploy-guard.test.js

@@ -1,61 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { isDirtyOrAhead, shouldWarnBeforeDeploy, } from '../deploy-guard.js';
-import { SESSION_FILE_SCHEMA_VERSION, } from '../../dev/session.js';
-function makeSessionFile(overrides = {}) {
-    return {
-        version: SESSION_FILE_SCHEMA_VERSION,
-        pid: process.pid,
-        sessionId: 'sess_test',
-        appId: 'test-app',
-        previewUrl: 'https://test.preview.runwork.dev',
-        startedAt: 1_700_000_000_000,
-        bootTime: 1_600_000_000_000,
-        cliVersion: '0.10.2',
-        mode: 'foreground',
-        ...overrides,
-    };
-}
-const noSession = { state: 'none' };
-const aliveSyncing = { state: 'alive', file: makeSessionFile({ noSync: false }) };
-const aliveNoSync = { state: 'alive', file: makeSessionFile({ noSync: true }) };
-const aliveLegacy = { state: 'alive', file: makeSessionFile() }; // noSync undefined
-const staleSession = { state: 'stale', reason: 'pid-dead', file: makeSessionFile() };
-const dirty = { dirty: true, ahead: false };
-const ahead = { dirty: false, ahead: true };
-const clean = { dirty: false, ahead: false };
-describe('isDirtyOrAhead()', () => {
-    it('is true when dirty', () => {
-        expect(isDirtyOrAhead(dirty)).toBe(true);
-    });
-    it('is true when ahead', () => {
-        expect(isDirtyOrAhead(ahead)).toBe(true);
-    });
-    it('is false when clean and not ahead', () => {
-        expect(isDirtyOrAhead(clean)).toBe(false);
-    });
-});
-describe('shouldWarnBeforeDeploy()', () => {
-    it('warns: dirty tree + no session', () => {
-        expect(shouldWarnBeforeDeploy(dirty, noSession)).toBe(true);
-    });
-    it('does not warn: dirty tree + active auto-syncing session', () => {
-        expect(shouldWarnBeforeDeploy(dirty, aliveSyncing)).toBe(false);
-    });
-    it('does not warn: dirty tree + active legacy session (noSync undefined treated as syncing)', () => {
-        expect(shouldWarnBeforeDeploy(dirty, aliveLegacy)).toBe(false);
-    });
-    it('warns: dirty tree + active no-sync session', () => {
-        expect(shouldWarnBeforeDeploy(dirty, aliveNoSync)).toBe(true);
-    });
-    it('warns: ahead tree + no session', () => {
-        expect(shouldWarnBeforeDeploy(ahead, noSession)).toBe(true);
-    });
-    it('warns: dirty tree + stale session (watcher not actually running)', () => {
-        expect(shouldWarnBeforeDeploy(dirty, staleSession)).toBe(true);
-    });
-    it('does not warn: clean + not ahead, regardless of session', () => {
-        expect(shouldWarnBeforeDeploy(clean, noSession)).toBe(false);
-        expect(shouldWarnBeforeDeploy(clean, aliveSyncing)).toBe(false);
-        expect(shouldWarnBeforeDeploy(clean, aliveNoSync)).toBe(false);
-    });
-});

package/dist/git/__tests__/ensure-git-credential-helper.test.d.ts

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

package/dist/git/__tests__/ensure-git-credential-helper.test.js

@@ -1,133 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('child_process');
-vi.mock('fs', () => ({
-    existsSync: vi.fn(),
-}));
-vi.mock('../../auth/store.js', () => ({
-    getCredentials: vi.fn(),
-}));
-const mockExecFileSync = (await import('child_process')).execFileSync;
-const { existsSync: mockExistsSync } = await import('fs');
-const { lookupCredentialHelper, helperBinaryStatus, ensureGitCredentialHelper, } = await import('../credentials.js');
-/** Build a `git config --get-regexp` stdout block from full config lines. */
-function gitConfigOutput(...lines) {
-    return Buffer.from(lines.join('\n') + '\n');
-}
-/** True when a recorded execFileSync call wrote a credential helper config. */
-function isHelperWrite(call) {
-    const args = call[1];
-    return call[0] === 'git'
-        && Array.isArray(args)
-        && args.includes('--global')
-        && args.some(a => /^credential\..*\.helper$/.test(a))
-        && !args.includes('--get-regexp')
-        && !args.includes('--unset');
-}
-describe('git/credentials lazy-ensure', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('lookupCredentialHelper()', () => {
-        it('returns "none" when git has no matching entries (get-regexp exits non-zero)', () => {
-            mockExecFileSync.mockImplementation(() => {
-                throw new Error('exit 1'); // git config --get-regexp: no match
-            });
-            expect(lookupCredentialHelper('https://runwork.ai')).toEqual({ status: 'none' });
-        });
-        it('returns "unscoped" when entries exist but none match the origin', () => {
-            mockExecFileSync.mockReturnValue(gitConfigOutput('credential.https://runwork-staging.example.com.helper !runwork git-credential-helper'));
-            expect(lookupCredentialHelper('https://runwork.ai')).toEqual({
-                status: 'unscoped',
-                otherCount: 1,
-            });
-        });
-        it('returns "registered" with the helper value when a scoped entry exists', () => {
-            mockExecFileSync.mockReturnValue(gitConfigOutput('credential.https://runwork.ai.helper !"/usr/local/bin/runwork" git-credential-helper'));
-            expect(lookupCredentialHelper('https://runwork.ai')).toEqual({
-                status: 'registered',
-                value: '!"/usr/local/bin/runwork" git-credential-helper',
-            });
-        });
-        it('matches the correct origin among multiple entries', () => {
-            mockExecFileSync.mockReturnValue(gitConfigOutput('credential.https://runwork-staging.example.com.helper !runwork git-credential-helper', 'credential.https://runwork.ai.helper !"/usr/local/bin/runwork" git-credential-helper'));
-            const result = lookupCredentialHelper('https://runwork.ai');
-            expect(result.status).toBe('registered');
-        });
-    });
-    describe('helperBinaryStatus()', () => {
-        it('trusts PATH-relative helper values (no on-disk check)', () => {
-            expect(helperBinaryStatus('!runwork git-credential-helper')).toEqual({ ok: true, path: null });
-            expect(mockExistsSync).not.toHaveBeenCalled();
-        });
-        it('reports ok when an absolute-path binary exists', () => {
-            vi.mocked(mockExistsSync).mockReturnValue(true);
-            expect(helperBinaryStatus('!"/usr/local/bin/runwork" git-credential-helper')).toEqual({
-                ok: true,
-                path: '/usr/local/bin/runwork',
-            });
-        });
-        it('reports not-ok with the path when an absolute-path binary is missing', () => {
-            vi.mocked(mockExistsSync).mockReturnValue(false);
-            expect(helperBinaryStatus('!"/old/path/runwork" git-credential-helper')).toEqual({
-                ok: false,
-                path: '/old/path/runwork',
-            });
-        });
-        it('handles Windows absolute paths', () => {
-            vi.mocked(mockExistsSync).mockReturnValue(true);
-            const result = helperBinaryStatus('!"C:/Users/test/.runwork/bin/runwork.exe" git-credential-helper');
-            expect(result.ok).toBe(true);
-            expect(result.path).toBe('C:/Users/test/.runwork/bin/runwork.exe');
-        });
-    });
-    describe('ensureGitCredentialHelper()', () => {
-        it('is a no-op when a valid scoped helper is already registered', async () => {
-            mockExecFileSync.mockImplementation((_file, args) => {
-                if (args.includes('--get-regexp')) {
-                    return gitConfigOutput('credential.https://runwork.ai.helper !runwork git-credential-helper');
-                }
-                return Buffer.from('');
-            });
-            await ensureGitCredentialHelper('https://runwork.ai/api/git/ws/app');
-            // No registration write should have happened.
-            expect(mockExecFileSync.mock.calls.some(isHelperWrite)).toBe(false);
-        });
-        it('registers the helper when none is present (the get_cli_setup path)', async () => {
-            mockExecFileSync.mockImplementation((_file, args) => {
-                if (args.includes('--get-regexp')) {
-                    throw new Error('exit 1'); // nothing registered yet
-                }
-                return Buffer.from('');
-            });
-            await ensureGitCredentialHelper('https://runwork.ai/api/git/ws/app');
-            const write = mockExecFileSync.mock.calls.find(isHelperWrite);
-            expect(write).toBeDefined();
-            expect(write[1]).toContain('credential.https://runwork.ai.helper');
-        });
-        it('registers when entries exist but none are scoped to this origin', async () => {
-            mockExecFileSync.mockImplementation((_file, args) => {
-                if (args.includes('--get-regexp')) {
-                    return gitConfigOutput('credential.https://other.example.com.helper !runwork git-credential-helper');
-                }
-                return Buffer.from('');
-            });
-            await ensureGitCredentialHelper('https://runwork.ai');
-            expect(mockExecFileSync.mock.calls.some(isHelperWrite)).toBe(true);
-        });
-        it('repairs a stale helper that points at a missing binary', async () => {
-            vi.mocked(mockExistsSync).mockReturnValue(false);
-            mockExecFileSync.mockImplementation((_file, args) => {
-                if (args.includes('--get-regexp')) {
-                    return gitConfigOutput('credential.https://runwork.ai.helper !"/old/path/runwork" git-credential-helper');
-                }
-                return Buffer.from('');
-            });
-            await ensureGitCredentialHelper('https://runwork.ai');
-            expect(mockExecFileSync.mock.calls.some(isHelperWrite)).toBe(true);
-        });
-        it('is a no-op for an unparseable baseUrl', async () => {
-            await ensureGitCredentialHelper('not a url');
-            expect(mockExecFileSync).not.toHaveBeenCalled();
-        });
-    });
-});

package/dist/git/__tests__/ensure-runwork-remote.test.d.ts

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

package/dist/git/__tests__/ensure-runwork-remote.test.js

@@ -1,109 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('child_process');
-const mockExecFileSync = (await import('child_process')).execFileSync;
-const { normalizeRemoteUrl, listRemotes, ensureRunworkRemote, } = await import('../remote.js');
-/** Build `git remote -v` stdout from name->url pairs (fetch + push lines). */
-function remoteVerbose(pairs) {
-    const lines = [];
-    for (const [name, url] of Object.entries(pairs)) {
-        lines.push(`${name}\t${url} (fetch)`);
-        lines.push(`${name}\t${url} (push)`);
-    }
-    return Buffer.from(lines.join('\n') + '\n');
-}
-/**
- * Drive ensureRunworkRemote/listRemotes against a fixed `git remote -v`
- * result, recording any set-url/add mutations.
- */
-function withRemotes(pairs) {
-    const setUrl = [];
-    const add = [];
-    mockExecFileSync.mockImplementation((_file, args) => {
-        if (args[0] === 'remote' && args[1] === '-v') {
-            return remoteVerbose(pairs);
-        }
-        if (args[0] === 'remote' && args[1] === 'set-url') {
-            setUrl.push(args);
-            return Buffer.from('');
-        }
-        if (args[0] === 'remote' && args[1] === 'add') {
-            add.push(args);
-            return Buffer.from('');
-        }
-        return Buffer.from('');
-    });
-    return { setUrl, add };
-}
-const CANONICAL = 'https://runwork.ai/api/git/ws/app';
-describe('git/remote', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('normalizeRemoteUrl()', () => {
-        it('strips a trailing .git', () => {
-            expect(normalizeRemoteUrl('https://runwork.ai/api/git/ws/app.git')).toBe(CANONICAL);
-        });
-        it('strips trailing slashes and lower-cases the host (path preserved)', () => {
-            expect(normalizeRemoteUrl('https://RunWork.ai/api/git/ws/app/')).toBe(CANONICAL);
-        });
-        it('drops userinfo so embedded creds do not break equality', () => {
-            expect(normalizeRemoteUrl('https://x-access-token:KEY@runwork.ai/api/git/ws/app')).toBe(CANONICAL);
-        });
-        it('falls back to a lower-cased trim for scp-style remotes', () => {
-            expect(normalizeRemoteUrl('git@GitHub.com:Foo/Bar.git')).toBe('git@github.com:foo/bar');
-        });
-    });
-    describe('listRemotes()', () => {
-        it('parses name -> fetch URL, ignoring push duplicates', () => {
-            withRemotes({ origin: 'https://example.com/a', runwork: CANONICAL });
-            expect(listRemotes('/repo')).toEqual({
-                origin: 'https://example.com/a',
-                runwork: CANONICAL,
-            });
-        });
-        it('returns {} when git fails (not a repo)', () => {
-            mockExecFileSync.mockImplementation(() => { throw new Error('not a git repo'); });
-            expect(listRemotes('/repo')).toEqual({});
-        });
-    });
-    describe('ensureRunworkRemote()', () => {
-        it('is a no-op when runwork already points at the canonical URL', () => {
-            const { setUrl, add } = withRemotes({ runwork: CANONICAL });
-            expect(ensureRunworkRemote('/repo', CANONICAL)).toEqual({ action: 'noop' });
-            expect(setUrl).toHaveLength(0);
-            expect(add).toHaveLength(0);
-        });
-        it('treats a .git-suffixed existing runwork remote as a match (no rewrite)', () => {
-            const { setUrl, add } = withRemotes({ runwork: `${CANONICAL}.git` });
-            expect(ensureRunworkRemote('/repo', CANONICAL)).toEqual({ action: 'noop' });
-            expect(setUrl).toHaveLength(0);
-            expect(add).toHaveLength(0);
-        });
-        it('repoints an existing runwork remote that points elsewhere', () => {
-            const { setUrl, add } = withRemotes({ runwork: 'https://runwork.ai/api/git/OLD/app' });
-            expect(ensureRunworkRemote('/repo', CANONICAL)).toEqual({ action: 'updated' });
-            expect(setUrl).toHaveLength(1);
-            expect(setUrl[0]).toEqual(['remote', 'set-url', 'runwork', CANONICAL]);
-            expect(add).toHaveLength(0);
-        });
-        it('adds the runwork remote when missing (clean repo)', () => {
-            const { setUrl, add } = withRemotes({});
-            expect(ensureRunworkRemote('/repo', CANONICAL)).toEqual({ action: 'added' });
-            expect(add).toHaveLength(1);
-            expect(add[0]).toEqual(['remote', 'add', 'runwork', CANONICAL]);
-            expect(setUrl).toHaveLength(0);
-        });
-        it('recognizes a matching origin (manual git clone) via reusedFrom and still adds the runwork alias', () => {
-            const { setUrl, add } = withRemotes({ origin: CANONICAL });
-            expect(ensureRunworkRemote('/repo', CANONICAL)).toEqual({ action: 'added', reusedFrom: 'origin' });
-            expect(add).toHaveLength(1);
-            expect(add[0]).toEqual(['remote', 'add', 'runwork', CANONICAL]);
-            expect(setUrl).toHaveLength(0);
-        });
-        it('does not set reusedFrom when no existing remote matches', () => {
-            withRemotes({ origin: 'https://github.com/someone/fork' });
-            const result = ensureRunworkRemote('/repo', CANONICAL);
-            expect(result).toEqual({ action: 'added' });
-        });
-    });
-});

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

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