runwork 0.15.0 → 0.15.2

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

@@ -1,405 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { execFileSync } from 'child_process';
-import { mkdtempSync, writeFileSync, readFileSync, rmSync, existsSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { syncWithRemote, hasCommits, hasTrackedChanges } from '../sync.js';
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = mkdtempSync(join(tmpdir(), `runwork-sync-test-${prefix}-`));
-    tempDirs.push(dir);
-    return 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 };
-}
-/** Create a second clone of the same bare remote (for simulating remote-side commits). */
-function cloneAsSecondary(remote) {
-    const secondary = makeTempDir('secondary');
-    execFileSync('git', ['clone', remote, secondary]);
-    execFileSync('git', ['config', 'user.email', 'other@test.com'], { cwd: secondary });
-    execFileSync('git', ['config', 'user.name', 'Other'], { cwd: secondary });
-    return secondary;
-}
-function commitFile(repoDir, filename, content, message) {
-    writeFileSync(join(repoDir, filename), content);
-    execFileSync('git', ['add', filename], { cwd: repoDir });
-    execFileSync('git', ['commit', '-m', message], { cwd: repoDir });
-    return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: repoDir, encoding: 'utf-8' }).trim();
-}
-function getLog(repoDir) {
-    return execFileSync('git', ['log', '--oneline', '--all'], { cwd: repoDir, encoding: 'utf-8' })
-        .trim()
-        .split('\n')
-        .filter(Boolean);
-}
-function getHeadHash(repoDir) {
-    return execFileSync('git', ['rev-parse', 'HEAD'], { cwd: repoDir, encoding: 'utf-8' }).trim();
-}
-afterEach(() => {
-    for (const dir of tempDirs) {
-        try {
-            rmSync(dir, { recursive: true, force: true });
-        }
-        catch { /* best effort */ }
-    }
-    tempDirs.length = 0;
-});
-describe('hasCommits()', () => {
-    it('returns false for repo with no commits', () => {
-        const dir = makeTempDir('empty');
-        execFileSync('git', ['init', dir]);
-        expect(hasCommits(dir)).toBe(false);
-    });
-    it('returns true for repo with commits', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        expect(hasCommits(local)).toBe(true);
-    });
-});
-describe('hasTrackedChanges()', () => {
-    it('returns false for clean working tree', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        expect(hasTrackedChanges(local)).toBe(false);
-    });
-    it('returns true for modified tracked file', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        writeFileSync(join(local, 'a.txt'), 'changed');
-        expect(hasTrackedChanges(local)).toBe(true);
-    });
-    it('returns false when only untracked files exist', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        writeFileSync(join(local, 'untracked.txt'), 'new');
-        expect(hasTrackedChanges(local)).toBe(false);
-    });
-});
-describe('syncWithRemote()', () => {
-    it('returns skipped when there are no local commits', () => {
-        const { local } = createTestRepo();
-        const result = syncWithRemote(local);
-        expect(result).toEqual({ status: 'skipped', pushed: false });
-    });
-    it('syncs when local and remote are already in sync', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('synced');
-        expect(result.pushed).toBe(true);
-    });
-    it('pushes local commits when remote has no new changes', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Add a new local commit
-        commitFile(local, 'b.txt', 'world', 'second');
-        const localHead = getHeadHash(local);
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('synced');
-        expect(result.pushed).toBe(true);
-        // Verify remote has the new commit
-        const remoteHead = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: remote, encoding: 'utf-8' }).trim();
-        expect(remoteHead).toBe(localHead);
-    });
-    it('rebases local on remote when remote has new commits', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Push a commit from another clone to simulate remote changes
-        const secondary = cloneAsSecondary(remote);
-        commitFile(secondary, 'remote-file.txt', 'from-remote', 'remote commit');
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('synced');
-        // Local should now have the remote file
-        expect(existsSync(join(local, 'remote-file.txt'))).toBe(true);
-        expect(readFileSync(join(local, 'remote-file.txt'), 'utf-8')).toBe('from-remote');
-    });
-    it('rebases when both sides have non-conflicting commits', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Remote adds a file
-        const secondary = cloneAsSecondary(remote);
-        commitFile(secondary, 'remote-file.txt', 'remote-content', 'remote commit');
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
-        // Local adds a different file
-        commitFile(local, 'local-file.txt', 'local-content', 'local commit');
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('synced');
-        expect(result.pushed).toBe(true);
-        // Both files should be present
-        expect(readFileSync(join(local, 'remote-file.txt'), 'utf-8')).toBe('remote-content');
-        expect(readFileSync(join(local, 'local-file.txt'), 'utf-8')).toBe('local-content');
-        // Verify remote also has both
-        const secondaryCheck = cloneAsSecondary(remote);
-        expect(existsSync(join(secondaryCheck, 'remote-file.txt'))).toBe(true);
-        expect(existsSync(join(secondaryCheck, 'local-file.txt'))).toBe(true);
-    });
-    it('handles unrelated histories with non-overlapping files via rebase', () => {
-        const { local, remote } = createTestRepo();
-        // Local has its own history
-        commitFile(local, 'local-file.txt', 'local', 'local init');
-        // Create a completely separate history and force-push it to remote
-        const other = makeTempDir('other');
-        execFileSync('git', ['init', other]);
-        execFileSync('git', ['config', 'user.email', 'other@test.com'], { cwd: other });
-        execFileSync('git', ['config', 'user.name', 'Other'], { cwd: other });
-        commitFile(other, 'remote-only.txt', 'remote', 'remote init');
-        execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
-        const result = syncWithRemote(local);
-        // Modern git can rebase non-conflicting unrelated histories
-        expect(['synced', 'merged']).toContain(result.status);
-        // Both files should be present regardless of strategy used
-        expect(existsSync(join(local, 'local-file.txt'))).toBe(true);
-        expect(existsSync(join(local, 'remote-only.txt'))).toBe(true);
-    });
-    it('auto-resolves conflicting unrelated histories by accepting remote', () => {
-        const { local, remote } = createTestRepo();
-        // Local modifies a file
-        commitFile(local, 'shared.txt', 'local-line-1\nlocal-line-2\n', 'local init');
-        // Remote has completely different history touching the same file
-        const other = makeTempDir('other');
-        execFileSync('git', ['init', other]);
-        execFileSync('git', ['config', 'user.email', 'other@test.com'], { cwd: other });
-        execFileSync('git', ['config', 'user.name', 'Other'], { cwd: other });
-        commitFile(other, 'shared.txt', 'remote-line-1\nremote-line-2\n', 'remote init');
-        execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
-        const result = syncWithRemote(local);
-        // Conflicts auto-resolved with -X theirs (remote wins for first sync)
-        expect(result.status).toBe('merged');
-        // Remote version should win
-        expect(readFileSync(join(local, 'shared.txt'), 'utf-8')).toBe('remote-line-1\nremote-line-2\n');
-    });
-    it('stashes and restores dirty working tree during sync', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Remote adds a commit
-        const secondary = cloneAsSecondary(remote);
-        commitFile(secondary, 'remote-file.txt', 'remote', 'remote commit');
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
-        // Make local dirty (modify a tracked file without committing)
-        writeFileSync(join(local, 'a.txt'), 'dirty-change');
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('synced');
-        // Dirty change should be preserved
-        expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('dirty-change');
-        // Remote file should also be present
-        expect(existsSync(join(local, 'remote-file.txt'))).toBe(true);
-    });
-    it('reports stash conflict when stash pop fails', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'shared.txt', 'original', 'init');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Remote modifies the same file
-        const secondary = cloneAsSecondary(remote);
-        writeFileSync(join(secondary, 'shared.txt'), 'remote-version');
-        execFileSync('git', ['add', 'shared.txt'], { cwd: secondary });
-        execFileSync('git', ['commit', '-m', 'remote change to shared'], { cwd: secondary });
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
-        // Local has uncommitted changes to the same file
-        writeFileSync(join(local, 'shared.txt'), 'local-dirty-version');
-        const result = syncWithRemote(local);
-        expect(result.error).toBe('stash-conflict');
-        expect(result.pushed).toBe(false);
-    });
-    it('handles fetch failure gracefully (unreachable remote)', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        // Point remote to a non-existent path
-        const badPath = join(tmpdir(), 'nonexistent-repo-' + Date.now());
-        execFileSync('git', ['remote', 'set-url', 'runwork', badPath], { cwd: local });
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('sync-failed');
-        expect(result.pushed).toBe(false);
-        // Local repo should be untouched
-        expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('hello');
-    });
-    it('removes conflicting untracked files before rebase', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Remote adds a new file via secondary clone
-        const secondary = cloneAsSecondary(remote);
-        commitFile(secondary, 'skeleton.txt', 'from-remote', 'add skeleton');
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
-        // Local has the same file as untracked (simulating template download)
-        writeFileSync(join(local, 'skeleton.txt'), 'local-untracked-version');
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('synced');
-        // The file should now contain the remote version (committed)
-        expect(readFileSync(join(local, 'skeleton.txt'), 'utf-8')).toBe('from-remote');
-    });
-    it('preserves local state when fetch fails with dirty tree', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        // Make working tree dirty
-        writeFileSync(join(local, 'a.txt'), 'dirty');
-        // Point remote to bad path
-        const badPath = join(tmpdir(), 'nonexistent-repo-' + Date.now());
-        execFileSync('git', ['remote', 'set-url', 'runwork', badPath], { cwd: local });
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('sync-failed');
-        // Dirty changes should be restored from stash
-        expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('dirty');
-    });
-});
-// ============================================================
-// EDGE CASE TESTS - probing for real bugs
-// ============================================================
-describe('hasTrackedChanges() edge cases', () => {
-    it('returns true for staged deletions (git rm)', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        // Stage a deletion
-        execFileSync('git', ['rm', 'a.txt'], { cwd: local, stdio: 'pipe' });
-        // git status --porcelain shows "D  a.txt" which does not start with "??"
-        expect(hasTrackedChanges(local)).toBe(true);
-    });
-    it('returns true for staged new file (git add of new file)', () => {
-        const { local } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        // Create and stage a new file (status: "A  new.txt")
-        writeFileSync(join(local, 'new.txt'), 'new content');
-        execFileSync('git', ['add', 'new.txt'], { cwd: local, stdio: 'pipe' });
-        expect(hasTrackedChanges(local)).toBe(true);
-    });
-});
-describe('syncWithRemote() edge cases', () => {
-    it('stash/pop works correctly when only staged deletions exist', () => {
-        // Edge case: hasTrackedChanges returns true for staged deletions,
-        // but does git stash push actually stash a staged deletion?
-        // If stash doesn't capture it, stash pop could fail or restore wrong state.
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        commitFile(local, 'b.txt', 'world', 'second');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Remote adds a new file
-        const secondary = cloneAsSecondary(remote);
-        commitFile(secondary, 'remote-file.txt', 'remote', 'remote commit');
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
-        // Stage a deletion locally (without committing)
-        execFileSync('git', ['rm', 'b.txt'], { cwd: local, stdio: 'pipe' });
-        expect(hasTrackedChanges(local)).toBe(true);
-        expect(existsSync(join(local, 'b.txt'))).toBe(false);
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('synced');
-        // After sync, the staged deletion should be restored
-        // (stash pop should bring back the staged rm state)
-        expect(existsSync(join(local, 'b.txt'))).toBe(false);
-        // Verify the deletion is still staged
-        const status = execFileSync('git', ['status', '--porcelain'], {
-            cwd: local, encoding: 'utf-8',
-        }).trim();
-        expect(status).toContain('b.txt');
-    });
-    it('handles sync when remote branch main does not exist yet (empty bare repo)', () => {
-        // User creates local repo and commits, but never pushed to remote.
-        // Remote is empty. fetch runwork main should fail.
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        // Do NOT push -- remote has no 'main' branch
-        const result = syncWithRemote(local);
-        // fetch should fail because remote has no main branch
-        expect(result.status).toBe('sync-failed');
-        // But local repo should be intact
-        expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('hello');
-    });
-    it('leaves repo clean after auto-resolving conflicting unrelated histories', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'shared.txt', 'local version\n', 'local init');
-        // Create conflicting remote history
-        const other = makeTempDir('other');
-        execFileSync('git', ['init', other]);
-        execFileSync('git', ['config', 'user.email', 'other@test.com'], { cwd: other });
-        execFileSync('git', ['config', 'user.name', 'Other'], { cwd: other });
-        commitFile(other, 'shared.txt', 'remote version\n', 'remote init');
-        execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
-        const result = syncWithRemote(local);
-        // Auto-resolved with -X theirs
-        expect(result.status).toBe('merged');
-        // Repo should NOT be in a rebase or merge state
-        expect(existsSync(join(local, '.git', 'MERGE_HEAD'))).toBe(false);
-        expect(existsSync(join(local, '.git', 'rebase-merge'))).toBe(false);
-        expect(existsSync(join(local, '.git', 'rebase-apply'))).toBe(false);
-        // Remote version wins
-        expect(readFileSync(join(local, 'shared.txt'), 'utf-8')).toBe('remote version\n');
-    });
-    it('handles merge conflict during rebase on related histories (same file edited both sides)', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'shared.txt', 'original content\n', 'init');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Remote modifies shared.txt
-        const secondary = cloneAsSecondary(remote);
-        writeFileSync(join(secondary, 'shared.txt'), 'remote edit line 1\nremote edit line 2\n');
-        execFileSync('git', ['add', 'shared.txt'], { cwd: secondary });
-        execFileSync('git', ['commit', '-m', 'remote edit'], { cwd: secondary });
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
-        // Local also modifies shared.txt (same area -> conflict)
-        writeFileSync(join(local, 'shared.txt'), 'local edit line 1\nlocal edit line 2\n');
-        execFileSync('git', ['add', 'shared.txt'], { cwd: local });
-        execFileSync('git', ['commit', '-m', 'local edit'], { cwd: local });
-        const result = syncWithRemote(local);
-        // Rebase should fail due to conflict, merge fallback should also have conflicts
-        // OR merge with --allow-unrelated-histories might succeed (unlikely for related histories)
-        // The key assertion: repo must NOT be left in broken state
-        expect(existsSync(join(local, '.git', 'MERGE_HEAD'))).toBe(false);
-        expect(existsSync(join(local, '.git', 'rebase-merge'))).toBe(false);
-        // Either merged or sync-failed, but never left in limbo
-        expect(['synced', 'merged', 'sync-failed']).toContain(result.status);
-    });
-    it('stash pop after sync-failed still restores dirty state', () => {
-        // If sync fails (fetch fails), dirty state should still be restored.
-        // But what if the stash was created and then the repo state changed
-        // (e.g., aborted rebase left things in weird state)?
-        const { local } = createTestRepo();
-        commitFile(local, 'a.txt', 'committed', 'init');
-        // Make dirty
-        writeFileSync(join(local, 'a.txt'), 'uncommitted change');
-        // Point to bad remote
-        const badPath = join(tmpdir(), 'nonexistent-' + Date.now());
-        execFileSync('git', ['remote', 'set-url', 'runwork', badPath], { cwd: local });
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('sync-failed');
-        // The stash should have been popped successfully
-        expect(result.error).not.toBe('stash-conflict');
-        expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('uncommitted change');
-        // Stash list should be empty (stash was popped)
-        const stashList = execFileSync('git', ['stash', 'list'], {
-            cwd: local, encoding: 'utf-8',
-        }).trim();
-        expect(stashList).toBe('');
-    });
-    it('does not leave orphan stash entries on successful sync', () => {
-        const { local, remote } = createTestRepo();
-        commitFile(local, 'a.txt', 'hello', 'init');
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd: local, stdio: 'pipe' });
-        // Remote adds a file
-        const secondary = cloneAsSecondary(remote);
-        commitFile(secondary, 'remote.txt', 'remote', 'remote commit');
-        execFileSync('git', ['push', 'origin', 'main'], { cwd: secondary, stdio: 'pipe' });
-        // Make local dirty
-        writeFileSync(join(local, 'a.txt'), 'dirty');
-        const result = syncWithRemote(local);
-        expect(result.status).toBe('synced');
-        // Stash should be empty - no orphan stash entries
-        const stashList = execFileSync('git', ['stash', 'list'], {
-            cwd: local, encoding: 'utf-8',
-        }).trim();
-        expect(stashList).toBe('');
-    });
-});

package/dist/git/auto-commit.d.ts

@@ -1,35 +0,0 @@
-import type { ApiClient } from '../api/client.js';
-/**
- * Basename-level ignore predicate using the static defaults only.
- * Exposed for unit testing of the static defaults; the runtime watcher uses
- * a richer matcher built from `.gitignore` (see watchAndAutoCommit).
- */
-export declare function isIgnored(filePath: string): boolean;
-export declare function watchAndAutoCommit(directory: string, client: ApiClient, appId: string, callbacks?: {
-    onFileChange?: (relPath: string, pendingCount: number) => void;
-    onFastSync?: (count: number) => void;
-    onGitPush?: (count: number) => void;
-}): Promise<void>;
-/**
- * Stage and commit the current working tree in a single shot, staging exactly
- * what the dev watcher would: tracked modifications/deletions (`git add -u`)
- * plus untracked files that the CLI ignore matcher does NOT exclude.
- *
- * It deliberately does NOT use `git add -A`. A blanket add honors only
- * `.gitignore`, which in the runwork-app template excludes `.env.*` but not a
- * bare `.env` (vibe-apps write both `.dev.vars` and `.env` locally) — so
- * `git add -A` would commit and push local secrets. The CLI ignore matcher
- * (the same one the dev watcher uses) excludes `.env`, `.dev.vars`,
- * `.bun-cache`, `.runwork`, and `*.log`, keeping deploy's staging in parity
- * with dev.
- *
- * Used by `runwork deploy`, which must commit pending working-tree changes
- * even when no dev session ever ran.
- *
- * Returns the number of files committed (0 when nothing was staged).
- */
-export declare function commitWorkingTree(cwd: string, message: string): {
-    committed: boolean;
-    fileCount: number;
-};
-export declare function stopAutoCommit(): Promise<void>;