runwork 0.15.1 → 0.15.2

package/dist/git/__tests__/auto-commit.test.js

@@ -1,431 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { execFileSync } from 'child_process';
-import { mkdtempSync, writeFileSync, readFileSync, rmSync, existsSync, mkdirSync, } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { isIgnored, commitWorkingTree } from '../auto-commit.js';
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = mkdtempSync(join(tmpdir(), `runwork-autocommit-test-${prefix}-`));
-    tempDirs.push(dir);
-    return dir;
-}
-function initGitRepo(dir) {
-    execFileSync('git', ['init', dir]);
-    execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: dir });
-    execFileSync('git', ['config', 'user.name', 'Test'], { cwd: dir });
-}
-function createTestRepo() {
-    const remote = makeTempDir('remote');
-    execFileSync('git', ['init', '--bare', remote]);
-    const local = makeTempDir('local');
-    execFileSync('git', ['init', local]);
-    execFileSync('git', ['remote', 'add', 'runwork', remote], { cwd: local });
-    execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: local });
-    execFileSync('git', ['config', 'user.name', 'Test'], { cwd: local });
-    return { local, remote };
-}
-function commitFile(repoDir, filename, content, message) {
-    const fullPath = join(repoDir, filename);
-    const dir = fullPath.substring(0, fullPath.lastIndexOf('/'));
-    if (dir !== repoDir && !existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(fullPath, content);
-    execFileSync('git', ['add', filename], { cwd: repoDir });
-    execFileSync('git', ['commit', '-m', message], { cwd: repoDir });
-}
-afterEach(() => {
-    for (const dir of tempDirs) {
-        try {
-            rmSync(dir, { recursive: true, force: true });
-        }
-        catch { /* best effort */ }
-    }
-    tempDirs.length = 0;
-});
-// ============================================================
-// isIgnored() unit tests
-// ============================================================
-describe('isIgnored()', () => {
-    it('ignores .git directory', () => {
-        expect(isIgnored('.git')).toBe(true);
-        expect(isIgnored('/path/to/.git')).toBe(true);
-    });
-    it('ignores node_modules directory', () => {
-        expect(isIgnored('node_modules')).toBe(true);
-        expect(isIgnored('/path/to/node_modules')).toBe(true);
-    });
-    it('ignores .runwork directory', () => {
-        expect(isIgnored('.runwork')).toBe(true);
-        expect(isIgnored('/project/.runwork')).toBe(true);
-    });
-    it('ignores .dev.vars file', () => {
-        expect(isIgnored('.dev.vars')).toBe(true);
-        expect(isIgnored('/project/.dev.vars')).toBe(true);
-    });
-    it('ignores .env file (BUG FIX: was missing before)', () => {
-        expect(isIgnored('.env')).toBe(true);
-        expect(isIgnored('/project/.env')).toBe(true);
-    });
-    it('ignores .log extension', () => {
-        expect(isIgnored('app.log')).toBe(true);
-        expect(isIgnored('/var/log/debug.log')).toBe(true);
-    });
-    it('does not ignore normal files', () => {
-        expect(isIgnored('index.ts')).toBe(false);
-        expect(isIgnored('package.json')).toBe(false);
-        expect(isIgnored('vite.config.ts')).toBe(false);
-        expect(isIgnored('/project/src/app.tsx')).toBe(false);
-    });
-    it('does not ignore files that contain skip names as substrings', () => {
-        // ".env.example" has basename ".env.example", not ".env"
-        expect(isIgnored('.env.example')).toBe(false);
-        expect(isIgnored('.env.local')).toBe(false);
-        // ".gitignore" has basename ".gitignore", not ".git"
-        expect(isIgnored('.gitignore')).toBe(false);
-    });
-    it('BUG PROBE: does not ignore files INSIDE node_modules when given full path', () => {
-        // isIgnored uses basename(), so "node_modules/foo/bar.js" -> basename = "bar.js"
-        // This is fine because chokidar calls isIgnored on the directory entry first,
-        // so it never descends into node_modules. But if isIgnored is called with a
-        // full path directly, it would NOT catch files inside node_modules.
-        const fullPath = '/project/node_modules/some-package/index.js';
-        // basename is "index.js" - NOT in SKIP_DIRS
-        expect(isIgnored(fullPath)).toBe(false);
-        // This is acceptable because chokidar checks the directory first.
-        // But it means isIgnored is NOT safe for general-purpose use outside chokidar.
-    });
-    it('does not ignore files without extensions', () => {
-        expect(isIgnored('Makefile')).toBe(false);
-        expect(isIgnored('Dockerfile')).toBe(false);
-        expect(isIgnored('LICENSE')).toBe(false);
-    });
-});
-// ============================================================
-// Bug fix verification: .env file protection
-// ============================================================
-describe('.env file protection (BUG FIX)', () => {
-    it('.env file should NOT be staged by auto-commit git add -u', () => {
-        // Scenario: user has .env tracked in git (mistake), modifies it.
-        // auto-commit does `git add -u` which would stage it.
-        // The chokidar watcher should never fire for .env files.
-        const { local } = createTestRepo();
-        // Commit a .env file (simulating an initial mistake)
-        commitFile(local, '.env', 'SECRET=old', 'init with env');
-        // Modify it
-        writeFileSync(join(local, '.env'), 'SECRET=new_value_leaked');
-        // The isIgnored function should prevent chokidar from watching .env
-        expect(isIgnored('.env')).toBe(true);
-        // But even if chokidar somehow fired, the file should be ignored.
-        // The real protection is that isIgnored('.env') returns true,
-        // so changedFiles never includes it, so it won't be in filesToAdd.
-        // However, `git add -u` (line 152) stages ALL modified tracked files,
-        // including .env if it's tracked. This is a secondary concern —
-        // the primary fix is preventing chokidar from triggering.
-    });
-    it('.dev.vars file is also protected', () => {
-        expect(isIgnored('.dev.vars')).toBe(true);
-    });
-    it('REMAINING RISK: git add -u stages tracked .env even if chokidar ignores it', () => {
-        // This test documents a remaining risk: if .env is already tracked in git
-        // and gets modified outside the watcher, `git add -u` in commitAndPush()
-        // will still stage it. The isIgnored fix only prevents chokidar from
-        // firing events, but git add -u is unconditional.
-        const { local } = createTestRepo();
-        commitFile(local, 'index.ts', 'export {}', 'init');
-        commitFile(local, '.env', 'SECRET=123', 'add env (mistake)');
-        // Modify both files
-        writeFileSync(join(local, 'index.ts'), 'export { hello }');
-        writeFileSync(join(local, '.env'), 'SECRET=leaked_value');
-        // Simulate what commitAndPush does: git add -u
-        execFileSync('git', ['add', '-u'], { cwd: local, stdio: 'pipe' });
-        const staged = execFileSync('git', ['diff', '--cached', '--name-only'], { cwd: local, encoding: 'utf-8' }).trim();
-        // BUG: git add -u stages .env if it's tracked, even though isIgnored
-        // prevents chokidar from watching it. The user's .env modification
-        // from another editor would still be committed on the next auto-commit
-        // cycle triggered by any other file change.
-        expect(staged.split('\n')).toContain('.env');
-        // This is a known risk - the fix prevents most .env commits (via chokidar),
-        // but doesn't prevent `git add -u` from staging tracked .env files.
-    });
-});
-// ============================================================
-// Bug fix verification: unicode filenames in git diff --cached
-// ============================================================
-describe('unicode filename handling in commitAndPush (BUG FIX)', () => {
-    it('git diff --cached with core.quotePath=false returns real filenames', () => {
-        const { local } = createTestRepo();
-        // Create and commit a unicode filename
-        const filename = 'caf\u00e9.txt';
-        commitFile(local, 'init.txt', 'hello', 'init');
-        // Stage a unicode file
-        writeFileSync(join(local, filename), 'content');
-        execFileSync('git', ['add', filename], { cwd: local });
-        // WITHOUT fix: git diff --cached --name-only returns octal-escaped
-        const withoutFix = execFileSync('git', ['diff', '--cached', '--name-only'], { cwd: local, encoding: 'utf-8' }).trim();
-        // WITH fix: git -c core.quotePath=false diff --cached --name-only returns real name
-        const withFix = execFileSync('git', ['-c', 'core.quotePath=false', 'diff', '--cached', '--name-only'], { cwd: local, encoding: 'utf-8' }).trim();
-        // The fixed version should contain the actual unicode character
-        expect(withFix).toContain('caf\u00e9.txt');
-        // The unfixed version may contain octal escaping (depends on git config)
-        // On most systems, git.quotePath defaults to true for non-ASCII
-        if (withoutFix.includes('\\')) {
-            // Confirms the bug existed: without the fix, git returns escaped names
-            expect(withoutFix).not.toContain('caf\u00e9');
-        }
-    });
-    it('staged file count is correct with unicode filenames', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        // Stage multiple files including unicode names
-        const files = ['normal.txt', 'caf\u00e9.txt', '\u00fcber.ts', 'na\u00efve.md'];
-        for (const f of files) {
-            writeFileSync(join(local, f), `content of ${f}`);
-            execFileSync('git', ['add', f], { cwd: local });
-        }
-        const staged = execFileSync('git', ['-c', 'core.quotePath=false', 'diff', '--cached', '--name-only'], { cwd: local, encoding: 'utf-8' }).trim();
-        const stagedFiles = staged.split('\n').filter(Boolean);
-        expect(stagedFiles).toHaveLength(files.length);
-        for (const f of files) {
-            expect(stagedFiles).toContain(f);
-        }
-    });
-});
-// ============================================================
-// Real-life scenario tests
-// ============================================================
-describe('real-life auto-commit scenarios', () => {
-    it('handles rapid file writes without losing changes', () => {
-        // Scenario: IDE save-all writes 10 files in quick succession.
-        // All should be captured for staging.
-        const { local } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        // Rapidly create files (simulating what changedFiles set would collect)
-        const files = Array.from({ length: 10 }, (_, i) => `file-${i}.ts`);
-        for (const f of files) {
-            writeFileSync(join(local, f), `export const x${f.replace(/\W/g, '')} = true;`);
-        }
-        // Stage them all (simulating what commitAndPush does)
-        execFileSync('git', ['add', '--', ...files], { cwd: local, stdio: 'pipe' });
-        const staged = execFileSync('git', ['-c', 'core.quotePath=false', 'diff', '--cached', '--name-only'], { cwd: local, encoding: 'utf-8' }).trim().split('\n').filter(Boolean);
-        expect(staged).toHaveLength(10);
-    });
-    it('handles files deleted between detection and staging', () => {
-        // Scenario: chokidar fires for a temp file that gets deleted
-        // before git add runs. git add throws for non-existent files,
-        // but commitAndPush wraps it in try/catch so it's handled gracefully.
-        const { local } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        const tempFile = join(local, 'temp.txt');
-        writeFileSync(tempFile, 'temporary');
-        // Delete before staging
-        rmSync(tempFile);
-        // git add -- temp.txt DOES throw for non-existent files
-        let threw = false;
-        try {
-            execFileSync('git', ['add', '--', 'temp.txt'], { cwd: local, stdio: 'pipe' });
-        }
-        catch {
-            threw = true;
-        }
-        // Confirmed: git add throws. commitAndPush catches this per batch.
-        expect(threw).toBe(true);
-    });
-    it('batch staging handles more than 50 files correctly', () => {
-        // commitAndPush batches git add into groups of 50.
-        // Verify nothing gets lost at batch boundaries.
-        const { local } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        const fileCount = 120; // 50 + 50 + 20
-        const files = [];
-        for (let i = 0; i < fileCount; i++) {
-            const name = `batch-${String(i).padStart(3, '0')}.ts`;
-            writeFileSync(join(local, name), `export const x = ${i};`);
-            files.push(name);
-        }
-        // Simulate batch staging from commitAndPush
-        const BATCH_SIZE = 50;
-        for (let i = 0; i < files.length; i += BATCH_SIZE) {
-            const batch = files.slice(i, i + BATCH_SIZE);
-            execFileSync('git', ['add', '--', ...batch], { cwd: local, stdio: 'pipe' });
-        }
-        const staged = execFileSync('git', ['-c', 'core.quotePath=false', 'diff', '--cached', '--name-only'], { cwd: local, encoding: 'utf-8' }).trim().split('\n').filter(Boolean);
-        expect(staged).toHaveLength(fileCount);
-    });
-    it('commit message includes ISO timestamp', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        writeFileSync(join(local, 'new.ts'), 'export {}');
-        execFileSync('git', ['add', 'new.ts'], { cwd: local, stdio: 'pipe' });
-        const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
-        execFileSync('git', ['commit', '-m', `dev: updated ${timestamp}`], { cwd: local, stdio: 'pipe' });
-        const log = execFileSync('git', ['log', '-1', '--format=%s'], {
-            cwd: local, encoding: 'utf-8',
-        }).trim();
-        expect(log).toMatch(/^dev: updated \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
-    });
-    it('pull --rebase then push works after remote has new commits', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Simulate remote commit (e.g. DO onStart creating files)
-        const secondary = makeTempDir('secondary');
-        execFileSync('git', ['clone', remote, secondary]);
-        execFileSync('git', ['config', 'user.email', 'server@test.com'], { cwd: secondary });
-        execFileSync('git', ['config', 'user.name', 'Server'], { cwd: secondary });
-        commitFile(secondary, 'server-file.txt', 'from server', 'server: init');
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
-        // Local commit (user edit)
-        commitFile(local, 'user-file.ts', 'export {}', 'dev: user edit');
-        // Simulate commitAndPush: pull --rebase then push
-        execFileSync('git', ['pull', '--rebase', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Both files should exist
-        expect(existsSync(join(local, 'server-file.txt'))).toBe(true);
-        expect(existsSync(join(local, 'user-file.ts'))).toBe(true);
-    });
-    it('merge with --allow-unrelated-histories combines diverged trees', () => {
-        // Scenario: template update on web UI rewrites history.
-        // The merge fallback (used when rebase fails) should combine both trees.
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'local-file.txt', 'local content', 'local init');
-        // Create a completely separate history on the remote
-        const other = makeTempDir('template-update');
-        execFileSync('git', ['init', other]);
-        execFileSync('git', ['config', 'user.email', 'server@test.com'], { cwd: other });
-        execFileSync('git', ['config', 'user.name', 'Server'], { cwd: other });
-        commitFile(other, 'template-file.txt', 'new template', 'template: v2');
-        execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
-        // Fetch remote
-        execFileSync('git', ['fetch', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Merge with unrelated histories
-        execFileSync('git', ['merge', 'runwork/main', '--allow-unrelated-histories', '--no-edit'], { cwd: local, stdio: 'pipe' });
-        // Both files should exist after merge
-        expect(existsSync(join(local, 'local-file.txt'))).toBe(true);
-        expect(existsSync(join(local, 'template-file.txt'))).toBe(true);
-    });
-    it('binary files are excluded from fast sync but included in git', () => {
-        // Scenario: user adds an image file. Fast sync should skip it,
-        // but git should still commit and push it.
-        const { local } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        const binaryExtensions = ['.png', '.jpg', '.woff2', '.pdf', '.wasm'];
-        for (const ext of binaryExtensions) {
-            writeFileSync(join(local, `file${ext}`), Buffer.from([0x00, 0xFF, 0x89, 0x50]));
-        }
-        // All binary files should be stageable by git
-        execFileSync('git', ['add', '.'], { cwd: local, stdio: 'pipe' });
-        const staged = execFileSync('git', ['-c', 'core.quotePath=false', 'diff', '--cached', '--name-only'], { cwd: local, encoding: 'utf-8' }).trim().split('\n').filter(Boolean);
-        for (const ext of binaryExtensions) {
-            expect(staged).toContain(`file${ext}`);
-        }
-    });
-    it('handles .gitignore interaction: ignored files not staged by git add -u', () => {
-        // Scenario: user has .gitignore. Modified ignored files should NOT
-        // be staged by git add -u.
-        const { local } = createTestRepo();
-        writeFileSync(join(local, '.gitignore'), 'dist/\n*.tmp\n');
-        commitFile(local, '.gitignore', readFileSync(join(local, '.gitignore'), 'utf-8'), 'add gitignore');
-        commitFile(local, 'src/app.ts', 'export {}', 'init');
-        // Create ignored files
-        mkdirSync(join(local, 'dist'));
-        writeFileSync(join(local, 'dist', 'bundle.js'), 'compiled');
-        writeFileSync(join(local, 'temp.tmp'), 'temporary');
-        // git add -u should NOT stage ignored files
-        execFileSync('git', ['add', '-u'], { cwd: local, stdio: 'pipe' });
-        const staged = execFileSync('git', ['diff', '--cached', '--name-only'], { cwd: local, encoding: 'utf-8' }).trim();
-        // Nothing should be staged (only gitignored files were modified)
-        expect(staged).toBe('');
-    });
-    it('handles empty working directory after initial commit', () => {
-        // Edge case: all files deleted, nothing to stage
-        const { local } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        execFileSync('git', ['rm', 'init.txt'], { cwd: local, stdio: 'pipe' });
-        execFileSync('git', ['commit', '-m', 'delete all'], { cwd: local, stdio: 'pipe' });
-        // git add -u with nothing to add
-        execFileSync('git', ['add', '-u'], { cwd: local, stdio: 'pipe' });
-        const staged = execFileSync('git', ['diff', '--cached', '--name-only'], { cwd: local, encoding: 'utf-8' }).trim();
-        expect(staged).toBe('');
-    });
-    it('commitWorkingTree stages and commits new untracked files (deploy path)', () => {
-        // Deploy must commit pending working-tree changes even when no dev
-        // session ever ran -- including brand-new untracked files.
-        const { local } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        writeFileSync(join(local, 'new-feature.ts'), 'export const feature = true;');
-        mkdirSync(join(local, 'src'));
-        writeFileSync(join(local, 'src', 'page.tsx'), 'export default () => null;');
-        const result = commitWorkingTree(local, 'deploy: test');
-        expect(result.committed).toBe(true);
-        expect(result.fileCount).toBe(2);
-        const log = execFileSync('git', ['log', '-1', '--format=%s'], { cwd: local, encoding: 'utf-8' }).trim();
-        expect(log).toBe('deploy: test');
-        const status = execFileSync('git', ['status', '--porcelain'], { cwd: local, encoding: 'utf-8' }).trim();
-        expect(status).toBe('');
-    });
-    it('commitWorkingTree stages tracked modifications and deletions', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'keep.ts', 'export const a = 1;', 'init');
-        commitFile(local, 'remove.ts', 'export const b = 2;', 'add remove');
-        writeFileSync(join(local, 'keep.ts'), 'export const a = 99;');
-        rmSync(join(local, 'remove.ts'));
-        const result = commitWorkingTree(local, 'deploy: edits');
-        expect(result.committed).toBe(true);
-        expect(result.fileCount).toBe(2);
-        expect(existsSync(join(local, 'remove.ts'))).toBe(false);
-    });
-    it('commitWorkingTree returns committed=false on a clean tree', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        const result = commitWorkingTree(local, 'deploy: noop');
-        expect(result.committed).toBe(false);
-        expect(result.fileCount).toBe(0);
-        const count = execFileSync('git', ['rev-list', '--count', 'HEAD'], { cwd: local, encoding: 'utf-8' }).trim();
-        expect(count).toBe('1');
-    });
-    it('commitWorkingTree does NOT stage untracked secrets / ignored dirs (matches dev, not git add -A)', () => {
-        // SECURITY: a bare `.env` is not in the runwork-app .gitignore, so a
-        // blanket `git add -A` would commit and push it. commitWorkingTree must
-        // filter untracked files through the CLI ignore matcher, exactly like
-        // the dev watcher, so local secrets never reach the remote.
-        const { local } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        // Real source that SHOULD be committed.
-        writeFileSync(join(local, 'app.ts'), 'export const x = 1;');
-        // Secrets / caches that MUST NOT be committed.
-        writeFileSync(join(local, '.env'), 'SECRET=do_not_leak');
-        writeFileSync(join(local, '.dev.vars'), 'WORKSPACE_API_KEY=do_not_leak');
-        mkdirSync(join(local, '.bun-cache'));
-        writeFileSync(join(local, '.bun-cache', 'pkg.json'), '{}');
-        const result = commitWorkingTree(local, 'deploy: test');
-        expect(result.committed).toBe(true);
-        const tracked = execFileSync('git', ['ls-files'], { cwd: local, encoding: 'utf-8' }).trim().split('\n');
-        expect(tracked).toContain('app.ts');
-        expect(tracked).not.toContain('.env');
-        expect(tracked).not.toContain('.dev.vars');
-        expect(tracked.some((f) => f.startsWith('.bun-cache/'))).toBe(false);
-    });
-    it('push -u sets upstream on first push', () => {
-        // commitAndPush tries `git rev-parse --abbrev-ref @{u}` to check
-        // for upstream. If it fails, it uses `push -u` to set upstream.
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'init.txt', 'hello', 'init');
-        // No upstream configured yet
-        let hasUpstream = true;
-        try {
-            execFileSync('git', ['rev-parse', '--abbrev-ref', '@{u}'], { cwd: local, stdio: 'pipe' });
-        }
-        catch {
-            hasUpstream = false;
-        }
-        expect(hasUpstream).toBe(false);
-        // Push with -u to set upstream
-        execFileSync('git', ['push', '-u', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Now upstream should be set
-        const upstream = execFileSync('git', ['rev-parse', '--abbrev-ref', '@{u}'], { cwd: local, encoding: 'utf-8' }).trim();
-        expect(upstream).toBe('runwork/main');
-    });
-});

package/dist/git/__tests__/classify-sync-error.test.d.ts

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

package/dist/git/__tests__/classify-sync-error.test.js

@@ -1,57 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { classifySyncError, diagnoseSyncError } from '../classify-sync-error.js';
-describe('git/classify-sync-error', () => {
-    describe('classifySyncError()', () => {
-        it('detects a missing/misnamed runwork remote', () => {
-            expect(classifySyncError("fatal: 'runwork' does not appear to be a git repository")).toBe('no-remote');
-            expect(classifySyncError('fatal: No such remote: runwork')).toBe('no-remote');
-        });
-        it('detects authentication failures', () => {
-            expect(classifySyncError('fatal: Authentication failed for https://runwork.ai/...')).toBe('auth');
-            expect(classifySyncError('fatal: could not read Username for https://runwork.ai: terminal prompts disabled')).toBe('auth');
-            expect(classifySyncError("fatal: unable to access '...': The requested URL returned error: 403")).toBe('auth');
-        });
-        it('detects network failures', () => {
-            expect(classifySyncError("fatal: unable to access '...': Could not resolve host: runwork.ai")).toBe('network');
-            expect(classifySyncError('fatal: unable to access: Failed to connect to runwork.ai port 443: Connection timed out')).toBe('network');
-        });
-        it('detects merge/rebase conflicts and the stash-conflict sentinel', () => {
-            expect(classifySyncError('CONFLICT (content): Merge conflict in src/App.tsx')).toBe('conflict');
-            expect(classifySyncError('error: Automatic merge failed')).toBe('conflict');
-            expect(classifySyncError('stash-conflict')).toBe('conflict');
-        });
-        it('falls back to unknown for unrecognized errors and empty input', () => {
-            expect(classifySyncError('some unexpected git failure')).toBe('unknown');
-            expect(classifySyncError(undefined)).toBe('unknown');
-            expect(classifySyncError('')).toBe('unknown');
-        });
-        it('is case-insensitive', () => {
-            expect(classifySyncError('AUTHENTICATION FAILED')).toBe('auth');
-            expect(classifySyncError('could not resolve HOST')).toBe('network');
-        });
-    });
-    describe('diagnoseSyncError()', () => {
-        it('points a no-remote failure at doctor --fix, not network/session', () => {
-            const d = diagnoseSyncError("fatal: 'runwork' does not appear to be a git repository");
-            expect(d.reason).toBe('no-remote');
-            expect(d.suggestions.join(' ')).toContain('runwork doctor --fix');
-            // Must NOT regress to the old misleading "session expired / network" advice.
-            expect(d.diagnosis.toLowerCase()).not.toContain('session expired');
-        });
-        it('points an auth failure at credential-helper remediation', () => {
-            const d = diagnoseSyncError('fatal: Authentication failed');
-            expect(d.reason).toBe('auth');
-            expect(d.suggestions.join(' ')).toContain('runwork doctor --fix');
-        });
-        it('gives stash-conflict a restore-specific message', () => {
-            const d = diagnoseSyncError('stash-conflict');
-            expect(d.reason).toBe('conflict');
-            expect(d.message).toContain('restoring local changes');
-        });
-        it('preserves the raw error in the unknown-case message', () => {
-            const d = diagnoseSyncError('weird git explosion');
-            expect(d.reason).toBe('unknown');
-            expect(d.message).toBe('weird git explosion');
-        });
-    });
-});

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

@@ -1,21 +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.
- */
-export {};