runwork 0.15.0 → 0.15.2

package/dist/git/preflight.js

@@ -1,276 +0,0 @@
-import { execFileSync } from '../utils/subprocess.js';
-import { existsSync } from 'fs';
-import { win32 as winPath } from 'path';
-import { homedir } from 'os';
-const VERSION_REGEX = /(\d+\.\d+(?:\.\d+)?)/;
-function tryRun(bin) {
-    try {
-        const out = execFileSync(bin, ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
-        return { ok: true, version: out.toString('utf-8').trim() };
-    }
-    catch (err) {
-        return { ok: false, error: err };
-    }
-}
-function whereGit() {
-    if (process.platform !== 'win32')
-        return null;
-    try {
-        // No `encoding: 'utf-8'` on purpose: keep the return as a Buffer to
-        // match tryRun()'s shape. We toString() ourselves so test mocks can
-        // return Buffers uniformly.
-        const buf = execFileSync('where.exe', ['git'], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
-        });
-        const out = buf.toString('utf-8');
-        // `where.exe git` may print multiple matches (cmd shim, exe shim).
-        // Prefer git.exe -- the bare shim is a .cmd that's harder to invoke
-        // reliably from spawn() and that mismatch is exactly what we're trying
-        // to work around.
-        const lines = out.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
-        const exe = lines.find(line => /\.exe$/i.test(line));
-        if (exe && existsSync(exe))
-            return exe;
-        const fallback = lines.find(line => existsSync(line));
-        return fallback ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Query Git for Windows' registry keys for an InstallPath.
- *
- * The official Git for Windows installer always writes
- * `HKLM\SOFTWARE\GitForWindows\InstallPath` (system installs) or
- * `HKCU\Software\GitForWindows\InstallPath` (per-user installs). When that
- * value points at e.g. `C:\Program Files\Git`, the binary lives at
- * `<value>\cmd\git.exe`. Portable / non-installer Gits (MinGit, Scoop,
- * GitHub Desktop's bundled git) won't appear here -- they're covered by
- * canonicalGitCandidates().
- */
-function registryGit() {
-    if (process.platform !== 'win32')
-        return null;
-    const queries = [
-        ['HKLM\\SOFTWARE\\GitForWindows', '/v', 'InstallPath'],
-        ['HKCU\\Software\\GitForWindows', '/v', 'InstallPath'],
-    ];
-    for (const args of queries) {
-        try {
-            const buf = execFileSync('reg.exe', ['query', ...args], {
-                stdio: ['ignore', 'pipe', 'pipe'],
-                windowsHide: true,
-            });
-            const out = buf.toString('utf-8');
-            // Output shape:
-            //   HKEY_LOCAL_MACHINE\SOFTWARE\GitForWindows
-            //       InstallPath    REG_SZ    C:\Program Files\Git
-            const match = out.match(/InstallPath\s+REG_SZ\s+(.+)/i);
-            if (!match)
-                continue;
-            const installRoot = match[1].trim();
-            const gitExe = winPath.join(installRoot, 'cmd', 'git.exe');
-            if (existsSync(gitExe))
-                return gitExe;
-        }
-        catch {
-            // reg.exe missing or key not present -- next query.
-        }
-    }
-    return null;
-}
-function canonicalGitCandidates() {
-    if (process.platform !== 'win32')
-        return [];
-    const paths = [];
-    const push = (...parts) => {
-        if (parts.every((part) => typeof part === 'string' && part.length > 0)) {
-            // Use winPath.join (not the bare `join` from 'path') because the path
-            // module's separator is locked at module-load time. On macOS test
-            // hosts running these tests with process.platform spoofed to 'win32',
-            // bare join would mix '\' and '/' separators and miss real Windows
-            // file system paths.
-            paths.push(winPath.join(...parts));
-        }
-    };
-    const home = homedir();
-    // Standard installer locations. `Git\cmd\git.exe` is the public entry
-    // point (a small shim that sets up PATH internally then runs the real
-    // git from `Git\mingw64\bin`). Bun's spawn copes with .exe just fine,
-    // so the shim works as long as we call it by absolute path.
-    push(process.env.ProgramFiles, 'Git', 'cmd', 'git.exe');
-    push(process.env['ProgramFiles(x86)'], 'Git', 'cmd', 'git.exe');
-    push(process.env.LOCALAPPDATA, 'Programs', 'Git', 'cmd', 'git.exe');
-    // Portable / per-user installs that don't register in HKLM:
-    //   - ~/.runwork/tools/mingit, ~/.runwork/tools/git -- our own namespace.
-    //     Other tools (e.g. Codex CLI) have been observed dropping a portable
-    //     MinGit there; if anything lives in our directory we should respect
-    //     it, even when we didn't put it there ourselves.
-    //   - Scoop -- ~/scoop/apps/git/current/cmd/git.exe.
-    //   - GitHub Desktop's bundled git lives under a versioned path that's
-    //     awkward to enumerate without a glob; skipped intentionally.
-    if (home) {
-        push(home, '.runwork', 'tools', 'mingit', 'cmd', 'git.exe');
-        push(home, '.runwork', 'tools', 'git', 'cmd', 'git.exe');
-        push(home, '.runwork', 'tools', 'PortableGit', 'cmd', 'git.exe');
-        push(home, 'scoop', 'apps', 'git', 'current', 'cmd', 'git.exe');
-    }
-    // Hard-coded defaults in case the env vars are missing (e.g. bizarre
-    // sandbox where %ProgramFiles% isn't propagated).
-    paths.push('C:\\Program Files\\Git\\cmd\\git.exe');
-    paths.push('C:\\Program Files (x86)\\Git\\cmd\\git.exe');
-    // De-dup while preserving order.
-    return [...new Set(paths)];
-}
-function prependToPath(dir) {
-    // Hard-coded ';' instead of `path.delimiter`: this helper is only called
-    // from the Windows-only fallback branch of probeGit(), but the path
-    // module's `delimiter` is determined by the *real* host OS at module
-    // load time -- so unit tests that flip `process.platform` to 'win32' on
-    // a macOS host would otherwise see ':' and fail to detect a duplicate
-    // entry. PATH on Windows always uses ';'.
-    const PATH_DELIM = ';';
-    const current = process.env.PATH ?? '';
-    const parts = current.split(PATH_DELIM);
-    if (parts.includes(dir))
-        return;
-    process.env.PATH = `${dir}${PATH_DELIM}${current}`;
-    // Windows historically reads `Path` (any case). Node normalizes via
-    // process.env, but the Bun-on-Windows path lookup we're working around
-    // here has surprised us before, so make the casing redundant.
-    if (process.env.Path !== undefined) {
-        process.env.Path = process.env.PATH;
-    }
-}
-let cachedProbe;
-/**
- * Probe whether `git` is callable from this process.
- *
- * Strategy:
- *   1. Try a bare `git --version` -- the common path on macOS, Linux, and
- *      most Windows installs.
- *   2. On Windows, fall back to `where.exe git` (uses the same PATH +
- *      PATHEXT rules cmd.exe applies, which are more permissive than
- *      Bun's spawn lookup in standalone-compiled binaries).
- *   3. On Windows, finally probe canonical install paths under
- *      %ProgramFiles%, %ProgramFiles(x86)%, %LOCALAPPDATA%\Programs.
- *
- * When step 2 or 3 succeeds, we prepend the resolved directory to
- * process.env.PATH so the ~50 other call sites that do
- * `execFileSync('git', ...)` automatically benefit, without rewriting
- * each one. Result is cached for the lifetime of the process.
- */
-export function probeGit() {
-    if (cachedProbe)
-        return cachedProbe;
-    // 1. Bare lookup.
-    const bare = tryRun('git');
-    if (bare.ok) {
-        cachedProbe = { installed: true, version: bare.version, path: 'git', source: 'PATH' };
-        return cachedProbe;
-    }
-    if (process.platform === 'win32') {
-        // 2. where.exe -- uses the same PATH+PATHEXT rules cmd.exe applies.
-        const whereResult = whereGit();
-        if (whereResult) {
-            const verify = tryRun(whereResult);
-            if (verify.ok) {
-                prependToPath(winPath.dirname(whereResult));
-                cachedProbe = { installed: true, version: verify.version, path: whereResult, source: 'where' };
-                return cachedProbe;
-            }
-        }
-        // 3. Registry -- the official Git for Windows installer always writes
-        //    HKLM\SOFTWARE\GitForWindows\InstallPath (or the HKCU equivalent
-        //    for per-user installs), so this catches "git is installed but
-        //    something has stripped both PATH and any chance of where.exe
-        //    finding it" cases (e.g. sandboxed agent shells).
-        const registryResult = registryGit();
-        if (registryResult) {
-            const verify = tryRun(registryResult);
-            if (verify.ok) {
-                prependToPath(winPath.dirname(registryResult));
-                cachedProbe = { installed: true, version: verify.version, path: registryResult, source: 'registry' };
-                return cachedProbe;
-            }
-        }
-        // 4. Canonical paths -- standard installer dirs plus our own
-        //    ~/.runwork/tools/{mingit,git,PortableGit} namespace and Scoop's
-        //    install location, for portable / non-installer Gits the registry
-        //    won't know about.
-        for (const candidate of canonicalGitCandidates()) {
-            if (!existsSync(candidate))
-                continue;
-            const verify = tryRun(candidate);
-            if (verify.ok) {
-                prependToPath(winPath.dirname(candidate));
-                cachedProbe = { installed: true, version: verify.version, path: candidate, source: 'canonical' };
-                return cachedProbe;
-            }
-        }
-    }
-    cachedProbe = { installed: false, error: bare.error };
-    return cachedProbe;
-}
-/**
- * Reset the cached probe result. Exposed for tests and for `runwork doctor`
- * when it wants to re-check after a guided install.
- */
-export function resetGitProbeCache() {
-    cachedProbe = undefined;
-}
-/**
- * Extract a short numeric version (e.g. "2.43.0") from a `git --version`
- * output line. Returns null if no number could be parsed.
- */
-export function parseGitVersion(versionLine) {
-    if (!versionLine)
-        return null;
-    const match = versionLine.match(VERSION_REGEX);
-    return match ? match[1] : null;
-}
-/**
- * Build a beginner-friendly message explaining how to recover from a missing
- * git binary. Includes a Windows-specific hint because the most common
- * scenario there is "winget install Git.Git just succeeded but this shell's
- * PATH was cached at launch" -- restarting the shell fixes it without a
- * second install attempt.
- *
- * If a probe error is supplied, the underlying message is appended so users
- * can see *why* detection failed (ENOENT vs EACCES vs something else).
- */
-export function buildMissingGitMessage(commandName, probe) {
-    const lines = [
-        `Git is required to run \`runwork ${commandName}\`, but it was not found on PATH.`,
-        '',
-        'Install Git, then re-run this command:',
-        '  - macOS:   brew install git    (or: xcode-select --install)',
-        '  - Windows: winget install --id Git.Git -e',
-        '  - Linux:   sudo apt-get install -y git    (or your distro\'s equivalent)',
-    ];
-    if (process.platform === 'win32') {
-        lines.push('', 'If you just installed Git, this shell\'s PATH was cached when it opened', 'and does not yet include Git. Close this PowerShell / Command Prompt', 'window, open a fresh one, and re-run the command.');
-    }
-    lines.push('', 'Verify the install with: git --version');
-    if (probe?.error?.message) {
-        // Surface the underlying error for diagnostics so users (and we, in bug
-        // reports) can see whether this was ENOENT, EACCES, a sandbox PATH
-        // strip, etc. -- not just "not found".
-        lines.push('', `Underlying error: ${probe.error.message}`);
-    }
-    return lines.join('\n');
-}
-/**
- * Convenience wrapper for command entry points: probe git, and if it's
- * missing, print the beginner-friendly message and exit with code 1.
- * Returns void on success so callers can early-return on failure.
- */
-export function requireGit(commandName) {
-    const probe = probeGit();
-    if (probe.installed)
-        return;
-    console.error(buildMissingGitMessage(commandName, probe));
-    process.exit(1);
-}

package/dist/git/remote.d.ts

@@ -1,37 +0,0 @@
-/**
- * The git remote name runwork uses for all sync/push operations. The sync
- * loop (git/sync.ts) references this remote by name, so clone/dev/deploy must
- * guarantee it exists and points at the app's canonical URL before syncing.
- */
-export declare const RUNWORK_REMOTE = "runwork";
-export type EnsureRemoteResult = {
-    action: 'noop';
-} | {
-    action: 'updated';
-} | {
-    action: 'added';
-    reusedFrom?: string;
-};
-/**
- * Normalize a git remote URL for equality comparison. Strips a trailing
- * `.git`, trailing slashes, and userinfo; lower-cases the host (case-
- * insensitive) while preserving the path (case-sensitive). Falls back to a
- * lower-cased trim for scp-style / non-URL remotes.
- */
-export declare function normalizeRemoteUrl(raw: string): string;
-/** Map of remote name -> fetch URL, parsed from `git remote -v`. */
-export declare function listRemotes(cwd: string): Record<string, string>;
-/**
- * Ensure a `runwork` remote exists and points at the app's canonical git URL,
- * so the sync loop's `runwork`-named git calls succeed regardless of how the
- * repo was obtained. A plain `git clone <url>` names the remote `origin`,
- * which previously made `runwork dev`/`deploy` fail with
- * `fatal: 'runwork' does not appear to be a git repository`.
- *
- * We don't require the remote to literally be named `runwork`: if another
- * remote (e.g. `origin`) already points at the canonical URL, we recognize it
- * (reported via `reusedFrom`) and still register the `runwork` alias so the
- * hardcoded sync path keeps working. Idempotent: a no-op when `runwork`
- * already points at the canonical URL.
- */
-export declare function ensureRunworkRemote(cwd: string, canonicalUrl: string): EnsureRemoteResult;

package/dist/git/remote.js

@@ -1,75 +0,0 @@
-import { execFileSync } from '../utils/subprocess.js';
-/**
- * The git remote name runwork uses for all sync/push operations. The sync
- * loop (git/sync.ts) references this remote by name, so clone/dev/deploy must
- * guarantee it exists and points at the app's canonical URL before syncing.
- */
-export const RUNWORK_REMOTE = 'runwork';
-//                                               existing remote, e.g. `origin`, already at this URL)
-/**
- * Normalize a git remote URL for equality comparison. Strips a trailing
- * `.git`, trailing slashes, and userinfo; lower-cases the host (case-
- * insensitive) while preserving the path (case-sensitive). Falls back to a
- * lower-cased trim for scp-style / non-URL remotes.
- */
-export function normalizeRemoteUrl(raw) {
-    const trimmed = raw.trim().replace(/\.git$/, '').replace(/\/+$/, '');
-    try {
-        const u = new URL(trimmed);
-        const host = u.host.toLowerCase();
-        const path = u.pathname.replace(/\/+$/, '');
-        return `${u.protocol}//${host}${path}`;
-    }
-    catch {
-        return trimmed.toLowerCase();
-    }
-}
-/** Map of remote name -> fetch URL, parsed from `git remote -v`. */
-export function listRemotes(cwd) {
-    const remotes = {};
-    let output;
-    try {
-        output = execFileSync('git', ['remote', '-v'], { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString();
-    }
-    catch {
-        return remotes; // not a git repo, or git unavailable
-    }
-    for (const line of output.split(/\r?\n/)) {
-        // Format: `<name>\t<url> (fetch)` / `<name>\t<url> (push)`
-        const match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)$/);
-        if (match && match[3] === 'fetch') {
-            remotes[match[1]] = match[2];
-        }
-    }
-    return remotes;
-}
-/**
- * Ensure a `runwork` remote exists and points at the app's canonical git URL,
- * so the sync loop's `runwork`-named git calls succeed regardless of how the
- * repo was obtained. A plain `git clone <url>` names the remote `origin`,
- * which previously made `runwork dev`/`deploy` fail with
- * `fatal: 'runwork' does not appear to be a git repository`.
- *
- * We don't require the remote to literally be named `runwork`: if another
- * remote (e.g. `origin`) already points at the canonical URL, we recognize it
- * (reported via `reusedFrom`) and still register the `runwork` alias so the
- * hardcoded sync path keeps working. Idempotent: a no-op when `runwork`
- * already points at the canonical URL.
- */
-export function ensureRunworkRemote(cwd, canonicalUrl) {
-    const remotes = listRemotes(cwd);
-    const target = normalizeRemoteUrl(canonicalUrl);
-    const existing = remotes[RUNWORK_REMOTE];
-    if (existing && normalizeRemoteUrl(existing) === target) {
-        return { action: 'noop' };
-    }
-    if (existing) {
-        execFileSync('git', ['remote', 'set-url', RUNWORK_REMOTE, canonicalUrl], { cwd, stdio: 'pipe' });
-        return { action: 'updated' };
-    }
-    // `runwork` is missing. Note if any other remote already points at the same
-    // URL (the manual `git clone` case, where it's typically `origin`).
-    const reusedFrom = Object.entries(remotes).find(([, url]) => normalizeRemoteUrl(url) === target)?.[0];
-    execFileSync('git', ['remote', 'add', RUNWORK_REMOTE, canonicalUrl], { cwd, stdio: 'pipe' });
-    return reusedFrom ? { action: 'added', reusedFrom } : { action: 'added' };
-}

package/dist/git/repo-config.d.ts

@@ -1,8 +0,0 @@
-/**
- * Disable git's background gc/maintenance for the repo at `cwd`. This is set
- * locally (repo scope), is harmless on normal filesystems -- these app repos
- * are small and centrally managed -- and avoids the pack-unlink failures that
- * restricted mounts produce. Applied cross-platform with no FS detection, so
- * it never risks a false positive (notably on Windows). Best-effort.
- */
-export declare function hardenRepoForRestrictedFs(cwd: string): void;

package/dist/git/repo-config.js

@@ -1,29 +0,0 @@
-import { execFileSync } from '../utils/subprocess.js';
-/**
- * Git config keys we disable on a freshly cloned app repo, with values.
- * Background gc/maintenance rewrite pack files, which on restricted
- * filesystems (some AI-agent "outputs" mounts disallow certain unlinks) fail
- * with `unable to unlink '.git/objects/pack/...': Operation not permitted`,
- * leaving git state unreliable (friction log #9).
- */
-const HARDENING = [
-    ['gc.auto', '0'],
-    ['maintenance.auto', 'false'],
-];
-/**
- * Disable git's background gc/maintenance for the repo at `cwd`. This is set
- * locally (repo scope), is harmless on normal filesystems -- these app repos
- * are small and centrally managed -- and avoids the pack-unlink failures that
- * restricted mounts produce. Applied cross-platform with no FS detection, so
- * it never risks a false positive (notably on Windows). Best-effort.
- */
-export function hardenRepoForRestrictedFs(cwd) {
-    for (const [key, value] of HARDENING) {
-        try {
-            execFileSync('git', ['config', key, value], { cwd, stdio: 'pipe' });
-        }
-        catch {
-            // Best-effort: failing to set a hardening config must not fail a clone.
-        }
-    }
-}

package/dist/git/sync.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,159 +0,0 @@
-import { execFileSync } from '../utils/subprocess.js';
-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
-    }
-}
-function extractGitError(err) {
-    if (err && typeof err === 'object') {
-        const obj = err;
-        // execFileSync errors have stderr and stdout as Buffer or string
-        const stderr = bufToStr(obj.stderr);
-        const stdout = bufToStr(obj.stdout);
-        // Prefer stderr (git's error output), fall back to stdout (merge conflict details)
-        if (stderr)
-            return stderr;
-        if (stdout)
-            return stdout;
-    }
-    if (err instanceof Error)
-        return err.message;
-    return String(err);
-}
-function bufToStr(val) {
-    if (!val)
-        return '';
-    if (typeof val === 'string')
-        return val.trim();
-    if (Buffer.isBuffer(val))
-        return val.toString('utf-8').trim();
-    return '';
-}
-/**
- * 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';
-    let syncError;
-    try {
-        execFileSync('git', ['fetch', 'runwork', 'main'], { cwd, stdio: 'pipe' });
-        removeConflictingUntrackedFiles(cwd);
-        try {
-            execFileSync('git', ['rebase', 'runwork/main'], { cwd, stdio: 'pipe' });
-        }
-        catch (rebaseErr) {
-            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 {
-                // Merge conflicts (common with unrelated histories / first sync).
-                // Abort and retry accepting the remote's version for all conflicts.
-                // This is safe because: user edits were committed before sync,
-                // and local template files are ephemeral (re-downloaded each session).
-                try {
-                    execFileSync('git', ['merge', '--abort'], { cwd, stdio: 'pipe' });
-                }
-                catch { /* no merge in progress */ }
-                try {
-                    execFileSync('git', ['merge', 'runwork/main', '--allow-unrelated-histories', '--no-edit', '-X', 'theirs'], { cwd, stdio: 'pipe' });
-                    status = 'merged';
-                }
-                catch (mergeErr) {
-                    try {
-                        execFileSync('git', ['merge', '--abort'], { cwd, stdio: 'pipe' });
-                    }
-                    catch { /* no merge in progress */ }
-                    status = 'sync-failed';
-                    syncError = extractGitError(mergeErr);
-                }
-            }
-        }
-    }
-    catch (fetchErr) {
-        status = 'sync-failed';
-        syncError = extractGitError(fetchErr);
-    }
-    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: syncError };
-    }
-    let pushed = false;
-    try {
-        // `HEAD:main` so the push works regardless of local branch name
-        // (older Git defaults to `master`, some users keep custom defaults).
-        execFileSync('git', ['push', 'runwork', 'HEAD:main'], { cwd, stdio: 'pipe' });
-        pushed = true;
-    }
-    catch {
-        // push failed — continue with current state
-    }
-    return { status, pushed };
-}

package/dist/health/__tests__/checks.test.d.ts

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