runwork 0.2.0 → 0.2.5

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

@@ -0,0 +1,403 @@
+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('reports sync-failed when both rebase and merge have conflicts', () => {
+        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);
+        // Both rebase and merge will fail on conflicting unrelated histories
+        expect(result.status).toBe('sync-failed');
+    });
+    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 (not in rebase/merge state) after sync-failed', () => {
+        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);
+        expect(result.status).toBe('sync-failed');
+        // 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);
+        // Working tree should be clean (original file intact)
+        const fileContent = readFileSync(join(local, 'shared.txt'), 'utf-8');
+        expect(fileContent).toBe('local 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,3 +1,4 @@
 import type { ApiClient } from '../api/client.js';
+export declare function isIgnored(filePath: string): boolean;
 export declare function watchAndAutoCommit(directory: string, client: ApiClient, appId: string): Promise<void>;
 export declare function stopAutoCommit(): Promise<void>;

package/dist/git/auto-commit.js

@@ -12,7 +12,7 @@ const pendingFastSync = new Map();
 // Track files the user actually touched during this session (for git)
 const changedFiles = new Set();
 const SKIP_DIRS = new Set(['node_modules', '.git', '.runwork']);
-const SKIP_FILES = new Set(['.dev.vars']);
+const SKIP_FILES = new Set(['.dev.vars', '.env']);
 const SKIP_EXTENSIONS = new Set(['.log']);
 // Binary extensions to skip in fast sync (git handles them fine)
 const BINARY_EXTENSIONS = new Set([
@@ -22,7 +22,7 @@ const BINARY_EXTENSIONS = new Set([
     '.zip', '.tar', '.gz', '.br',
     '.pdf', '.wasm',
 ]);
-function isIgnored(filePath) {
+export function isIgnored(filePath) {
     const name = basename(filePath);
     if (SKIP_DIRS.has(name))
         return true;
@@ -153,7 +153,7 @@ function commitAndPush() {
             }
         }
         // Check if anything was actually staged
-        const staged = execFileSync('git', ['diff', '--cached', '--name-only'], { encoding: 'utf-8' });
+        const staged = execFileSync('git', ['-c', 'core.quotePath=false', 'diff', '--cached', '--name-only'], { encoding: 'utf-8' });
         if (!staged.trim())
             return;
         const stagedFiles = staged.trim().split('\n').filter(Boolean);
@@ -169,8 +169,18 @@ function commitAndPush() {
                 execFileSync('git', ['rebase', '--abort'], { stdio: 'pipe' });
             }
             catch { /* no rebase in progress */ }
-            console.warn('Auto-sync: rebase failed, skipping push. Run `git pull --rebase runwork main` manually.');
-            return;
+            // Rebase fails when histories diverged (e.g. template update). Fall back to merge.
+            try {
+                execFileSync('git', ['merge', 'runwork/main', '--allow-unrelated-histories', '--no-edit'], { stdio: 'pipe' });
+            }
+            catch {
+                try {
+                    execFileSync('git', ['merge', '--abort'], { stdio: 'pipe' });
+                }
+                catch { /* no merge in progress */ }
+                console.warn('Auto-sync: merge failed, skipping push. Run `git pull --rebase runwork main` manually.');
+                return;
+            }
         }
         try {
             execFileSync('git', ['rev-parse', '--abbrev-ref', '@{u}'], { stdio: 'pipe' });

package/dist/git/sync.d.ts

@@ -0,0 +1,15 @@
+export interface SyncResult {
+    status: 'synced' | 'merged' | 'sync-failed' | 'skipped';
+    pushed: boolean;
+    error?: string;
+}
+export declare function hasCommits(cwd: string): boolean;
+export declare function hasTrackedChanges(cwd: string): boolean;
+/**
+ * Sync local repository with the runwork remote.
+ *
+ * Strategy: fetch, then attempt rebase. If rebase fails (e.g. diverged
+ * histories after a template update), fall back to merge with
+ * --allow-unrelated-histories. Stash/pop around dirty working trees.
+ */
+export declare function syncWithRemote(cwd: string): SyncResult;

package/dist/git/sync.js

@@ -0,0 +1,116 @@
+import { execFileSync } from 'child_process';
+import { unlinkSync } from 'fs';
+import { join } from 'path';
+export function hasCommits(cwd) {
+    try {
+        execFileSync('git', ['rev-parse', 'HEAD'], { cwd, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function hasTrackedChanges(cwd) {
+    try {
+        const output = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf-8' });
+        return output.trim().split('\n').some(line => line.length > 0 && !line.startsWith('??'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove untracked local files that exist on the remote.
+ * Skeleton files are ephemeral (re-downloaded each session) so the
+ * server's versions take precedence. User-edited files are already
+ * tracked/committed at this point and won't be affected.
+ */
+function removeConflictingUntrackedFiles(cwd) {
+    try {
+        const remoteFiles = execFileSync('git', ['ls-tree', '-r', '--name-only', 'runwork/main'], {
+            cwd,
+            encoding: 'utf-8',
+        }).trim().split('\n');
+        const untrackedOutput = execFileSync('git', ['ls-files', '--others', '--exclude-standard'], {
+            cwd,
+            encoding: 'utf-8',
+        }).trim();
+        const untracked = new Set(untrackedOutput.split('\n').filter(Boolean));
+        for (const file of remoteFiles) {
+            if (untracked.has(file)) {
+                try {
+                    unlinkSync(join(cwd, file));
+                }
+                catch { /* already gone */ }
+            }
+        }
+    }
+    catch {
+        // best effort
+    }
+}
+/**
+ * Sync local repository with the runwork remote.
+ *
+ * Strategy: fetch, then attempt rebase. If rebase fails (e.g. diverged
+ * histories after a template update), fall back to merge with
+ * --allow-unrelated-histories. Stash/pop around dirty working trees.
+ */
+export function syncWithRemote(cwd) {
+    if (!hasCommits(cwd)) {
+        return { status: 'skipped', pushed: false };
+    }
+    const dirty = hasTrackedChanges(cwd);
+    if (dirty) {
+        execFileSync('git', ['stash', 'push', '-m', 'runwork-dev-sync'], { cwd, stdio: 'pipe' });
+    }
+    let status = 'synced';
+    try {
+        execFileSync('git', ['fetch', 'runwork', 'main'], { cwd, stdio: 'pipe' });
+        removeConflictingUntrackedFiles(cwd);
+        try {
+            execFileSync('git', ['rebase', 'runwork/main'], { cwd, stdio: 'pipe' });
+        }
+        catch {
+            try {
+                execFileSync('git', ['rebase', '--abort'], { cwd, stdio: 'pipe' });
+            }
+            catch { /* no rebase in progress */ }
+            try {
+                execFileSync('git', ['merge', 'runwork/main', '--allow-unrelated-histories', '--no-edit'], { cwd, stdio: 'pipe' });
+                status = 'merged';
+            }
+            catch {
+                try {
+                    execFileSync('git', ['merge', '--abort'], { cwd, stdio: 'pipe' });
+                }
+                catch { /* no merge in progress */ }
+                status = 'sync-failed';
+            }
+        }
+    }
+    catch {
+        // fetch failed — remote may be unreachable or have no commits
+        status = 'sync-failed';
+    }
+    if (dirty) {
+        try {
+            execFileSync('git', ['stash', 'pop'], { cwd, stdio: 'pipe' });
+        }
+        catch {
+            return { status, pushed: false, error: 'stash-conflict' };
+        }
+    }
+    if (status === 'sync-failed') {
+        return { status, pushed: false, error: 'Pull failed (remote may not have commits yet)' };
+    }
+    let pushed = false;
+    try {
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd, stdio: 'pipe' });
+        pushed = true;
+    }
+    catch {
+        // push failed — continue with current state
+    }
+    return { status, pushed };
+}

package/dist/index.js

@@ -5,7 +5,9 @@ import { cloneCommand } from './commands/clone.js';
 import { devCommand } from './commands/dev.js';
 import { deployCommand } from './commands/deploy.js';
 import { logsCommand } from './commands/logs.js';
+import { upgradeCommand } from './commands/upgrade.js';
 import { logoutCommand } from './commands/logout.js';
+import { integrationsCommand } from './commands/integrations.js';
 import { handleGitCredentialRequest } from './git/credentials.js';
 import { VERSION } from './generated/version.js';
 const program = new Command();
@@ -19,7 +21,9 @@ program.addCommand(cloneCommand);
 program.addCommand(devCommand);
 program.addCommand(deployCommand);
 program.addCommand(logsCommand);
+program.addCommand(upgradeCommand);
 program.addCommand(logoutCommand);
+program.addCommand(integrationsCommand);
 const credentialHelper = program
     .command('git-credential-helper', { hidden: true })
     .argument('<action>', 'Credential action (get/store/erase)')

package/dist/logs/tailer.js

@@ -22,7 +22,6 @@ export function startLogTailer(options) {
     }
     let lastStdoutLength = 0;
     let lastStderrLength = 0;
-    let lastEventTimestamp;
     let seenEventIds = new Set();
     let stopped = false;
     let timer;
@@ -81,13 +80,10 @@ export function startLogTailer(options) {
                 // Events are returned newest-first; process in chronological order
                 const sorted = [...result.events].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
                 for (const event of sorted) {
-                    // Skip events we've already seen (by ID, or by timestamp for older events)
+                    // Skip events we've already seen by ID
                     if (seenEventIds.has(event.id)) {
                         continue;
                     }
-                    if (lastEventTimestamp && event.timestamp < lastEventTimestamp) {
-                        continue;
-                    }
                     let detail = event.summary || event.content || event.type;
                     // Include structured metadata when available
                     if (event.metadata) {
@@ -105,12 +101,10 @@ export function startLogTailer(options) {
                     writeLine(formatLogLine('EVENT', `${event.type}: ${detail}`));
                     seenEventIds.add(event.id);
                 }
-                // Update cursor to the latest event timestamp and prune old IDs
-                const latest = sorted[sorted.length - 1];
-                if (latest && (!lastEventTimestamp || latest.timestamp > lastEventTimestamp)) {
-                    // Clear IDs from previous timestamps since we won't see them again
-                    seenEventIds = new Set(sorted.filter(e => e.timestamp === latest.timestamp).map(e => e.id));
-                    lastEventTimestamp = latest.timestamp;
+                // Cap the set size to prevent unbounded growth (keep last 200 IDs)
+                if (seenEventIds.size > 200) {
+                    const ids = Array.from(seenEventIds);
+                    seenEventIds = new Set(ids.slice(ids.length - 200));
                 }
             }
         }