runwork 0.2.4 → 0.2.5

package/dist/commands/dev.js

@@ -1,10 +1,11 @@
 import { Command } from 'commander';
 import { execFileSync } from 'child_process';
-import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { watchAndAutoCommit, stopAutoCommit } from '../git/auto-commit.js';
+import { syncWithRemote } from '../git/sync.js';
 import { startLogTailer } from '../logs/tailer.js';
 import { populateTypes } from '../types-manager.js';
 import { loadManifest, generateManifest, saveManifest, detectUserEdits } from '../template/manifest.js';
@@ -28,25 +29,6 @@ function readConfig() {
     }
     return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
 }
-function hasCommits() {
-    try {
-        execFileSync('git', ['rev-parse', 'HEAD'], { stdio: 'pipe' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function hasTrackedChanges() {
-    try {
-        // Only check tracked files (modified/deleted/staged) - not untracked (??) files
-        const output = execFileSync('git', ['status', '--porcelain'], { encoding: 'utf-8' });
-        return output.trim().split('\n').some(line => line.length > 0 && !line.startsWith('??'));
-    }
-    catch {
-        return false;
-    }
-}
 export const devCommand = new Command('dev')
     .description('Start local development server with live sync')
     .option('--no-logs', 'Disable automatic log tailing')
@@ -103,60 +85,28 @@ export const devCommand = new Command('dev')
     // Fetch SKILL.md (best-effort, after session so DO registries are available)
     await populateSkill(cwd, client, config.appId);
     // Sync AFTER starting session so we pick up any commits the DO created
-    if (hasCommits()) {
-        console.log('Syncing with Runwork...');
-        const dirty = hasTrackedChanges();
-        if (dirty) {
-            execFileSync('git', ['stash', 'push', '-m', 'runwork-dev-sync'], { stdio: 'inherit' });
-        }
-        try {
-            // Fetch first, then remove untracked skeleton files that conflict
-            // with the remote before rebasing. 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.
-            execFileSync('git', ['fetch', 'runwork', 'main'], { stdio: 'inherit' });
-            try {
-                const remoteFiles = execFileSync('git', ['ls-tree', '-r', '--name-only', 'runwork/main'], { encoding: 'utf-8' }).trim().split('\n');
-                const untrackedOutput = execFileSync('git', ['ls-files', '--others', '--exclude-standard'], { 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 */ }
-            execFileSync('git', ['rebase', 'runwork/main'], { stdio: 'inherit' });
-        }
-        catch {
-            try {
-                execFileSync('git', ['rebase', '--abort'], { stdio: 'pipe' });
-            }
-            catch { /* no rebase in progress */ }
-            console.warn('Pull failed (remote may not have commits yet). Continuing...');
-        }
-        if (dirty) {
-            try {
-                execFileSync('git', ['stash', 'pop'], { stdio: 'inherit' });
-            }
-            catch {
+    console.log('Syncing with Runwork...');
+    const syncResult = syncWithRemote(cwd);
+    switch (syncResult.status) {
+        case 'skipped':
+            console.log('No commits yet. Skipping sync.');
+            break;
+        case 'synced':
+            console.log('Synced with Runwork.');
+            break;
+        case 'merged':
+            console.log('Merged with Runwork (histories diverged).');
+            break;
+        case 'sync-failed':
+            if (syncResult.error === 'stash-conflict') {
                 console.error('Merge conflicts detected after stash pop. Resolve conflicts and restart.');
                 process.exit(1);
             }
-        }
-        // Push local changes
-        try {
-            execFileSync('git', ['push', 'runwork', 'main'], { stdio: 'inherit' });
-        }
-        catch {
-            console.warn('Push failed. Continuing with current state...');
-        }
+            console.warn('Pull failed (remote may not have commits yet). Continuing...');
+            break;
     }
-    else {
-        console.log('No commits yet. Skipping sync.');
+    if (!syncResult.pushed && syncResult.status !== 'skipped' && syncResult.status !== 'sync-failed') {
+        console.warn('Push failed. Continuing with current state...');
     }
     // Declare logTailer before cleanup so cleanup can reference it
     let logTailer;

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.4";
+export declare const VERSION = "0.2.5";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-types.ts -- do not edit
-export const VERSION = "0.2.4";
+export const VERSION = "0.2.5";

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

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

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

@@ -0,0 +1,373 @@
+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 } 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('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__/manifest.test.d.ts

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