runwork 0.15.0 → 0.15.2

package/dist/health/checks.js

@@ -1,636 +0,0 @@
-import { execFileSync } from '../utils/subprocess.js';
-import { existsSync, readFileSync } from 'fs';
-import { join, sep } from 'path';
-import { homedir, platform as osPlatform, arch as osArch } from 'os';
-import { VERSION } from '../generated/version.js';
-import { getCredentials } from '../auth/store.js';
-import { ApiClient } from '../api/client.js';
-import { detectAgents, getAdapterBySlug } from '../agents/detect.js';
-import { httpFetch } from '../utils/http.js';
-import { probeGit, parseGitVersion } from '../git/preflight.js';
-import { lookupCredentialHelper, helperBinaryStatus } from '../git/credentials.js';
-import { getDeploySummary } from '../deploy/deploy-state.js';
-// First-party distribution endpoints. Defaults match the plan, can be
-// overridden via RUNWORK_DOWNLOAD_BASE_URL for staging or debugging.
-const BASE_URL = process.env.RUNWORK_DOWNLOAD_BASE_URL || 'https://runwork.ai';
-const LATEST_JSON_URL = `${BASE_URL}/cli/latest.json`;
-function detectPlatform() {
-    const rawOs = osPlatform();
-    const rawArch = osArch();
-    const os = rawOs === 'darwin' ? 'darwin' : rawOs === 'linux' ? 'linux' : rawOs === 'win32' ? 'windows' : null;
-    const arch = rawArch === 'x64' ? 'x64' : rawArch === 'arm64' ? 'arm64' : null;
-    return {
-        os,
-        arch,
-        key: os && arch ? `${os}-${arch}` : null,
-    };
-}
-async function fetchReleaseManifest() {
-    try {
-        const response = await httpFetch(LATEST_JSON_URL, { cache: 'no-store' });
-        if (!response.ok)
-            return null;
-        return await response.json();
-    }
-    catch {
-        return null;
-    }
-}
-export function buildContext() {
-    const credentials = getCredentials();
-    const client = credentials ? new ApiClient(credentials) : null;
-    let config = null;
-    const configPath = join(process.cwd(), '.runwork.json');
-    if (existsSync(configPath)) {
-        try {
-            config = JSON.parse(readFileSync(configPath, 'utf-8'));
-        }
-        catch {
-            // will be reported as a failure in checkProjectConfig
-        }
-    }
-    return { credentials, client, config, cwd: process.cwd() };
-}
-// ── 1. System dependencies ───────────────────────────────────────────
-export async function checkSystemDeps() {
-    // Delegate to probeGit() so doctor agrees with the preflight gate used by
-    // `runwork clone`/`init`/`dev`. probeGit also has Windows fallback paths
-    // (`where.exe`, canonical install dirs) that the previous bare execFileSync
-    // missed when Bun's standalone-binary spawn lookup failed despite git
-    // being installed.
-    const probe = probeGit();
-    if (!probe.installed) {
-        const detail = probe.error?.message ? ` (${probe.error.message})` : '';
-        return {
-            name: 'system-deps',
-            status: 'fail',
-            message: `git not found in PATH${detail}`,
-            fix: 'Install git: https://git-scm.com/downloads',
-        };
-    }
-    const version = parseGitVersion(probe.version) ?? 'unknown';
-    // Show how we found it on Windows fallback paths so the user can see
-    // whether their PATH is wired up or we needed a rescue.
-    const sourceSuffix = probe.source === 'where' ? ` (resolved via where.exe at ${probe.path})`
-        : probe.source === 'registry' ? ` (resolved via Git for Windows registry at ${probe.path})`
-            : probe.source === 'canonical' ? ` (resolved via canonical install path ${probe.path})`
-                : '';
-    if (version !== 'unknown') {
-        const [major, minor] = version.split('.').map(Number);
-        if (major < 2 || (major === 2 && minor < 20)) {
-            return {
-                name: 'system-deps',
-                status: 'warn',
-                message: `git ${version} (old -- consider upgrading)${sourceSuffix}`,
-            };
-        }
-    }
-    return { name: 'system-deps', status: 'pass', message: `git ${version}${sourceSuffix}` };
-}
-// ── 2. CLI version ───────────────────────────────────────────────────
-export async function checkCliVersion() {
-    const manifest = await fetchReleaseManifest();
-    if (!manifest) {
-        return {
-            name: 'cli-version',
-            status: 'skip',
-            message: `${VERSION} (${LATEST_JSON_URL} unreachable)`,
-        };
-    }
-    const latest = manifest.version?.replace(/^v/, '') || null;
-    if (!latest) {
-        return { name: 'cli-version', status: 'skip', message: `${VERSION} (could not parse latest)` };
-    }
-    if (latest === VERSION) {
-        return { name: 'cli-version', status: 'pass', message: `${VERSION} (latest)` };
-    }
-    return {
-        name: 'cli-version',
-        status: 'warn',
-        message: `${VERSION} (${latest} available)`,
-        fix: 'runwork upgrade',
-    };
-}
-// ── 2a. CLI artifact reachability for this host ──────────────────────
-export async function checkCliArtifactReachable() {
-    const platform = detectPlatform();
-    if (!platform.key) {
-        return {
-            name: 'cli-artifact',
-            status: 'skip',
-            message: `unsupported host (${osPlatform()}/${osArch()})`,
-        };
-    }
-    const manifest = await fetchReleaseManifest();
-    if (!manifest) {
-        return {
-            name: 'cli-artifact',
-            status: 'fail',
-            message: `${LATEST_JSON_URL} unreachable`,
-            fix: 'check network / outbound access to runwork.ai',
-        };
-    }
-    const entry = manifest.artifacts?.[platform.key];
-    if (!entry?.path) {
-        return {
-            name: 'cli-artifact',
-            status: 'fail',
-            message: `manifest has no artifact for ${platform.key}`,
-        };
-    }
-    const artifactUrl = `${BASE_URL}${entry.path}`;
-    try {
-        const response = await httpFetch(artifactUrl, { method: 'HEAD' });
-        if (!response.ok) {
-            return {
-                name: 'cli-artifact',
-                status: 'fail',
-                message: `${artifactUrl} returned HTTP ${response.status}`,
-            };
-        }
-        return { name: 'cli-artifact', status: 'pass', message: `${platform.key} reachable` };
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-            name: 'cli-artifact',
-            status: 'fail',
-            message: `${artifactUrl} unreachable: ${msg}`,
-        };
-    }
-}
-// ── 2b. Canonical install location ───────────────────────────────────
-export async function checkCliInstallLocation() {
-    const isWindows = osPlatform() === 'win32';
-    const home = homedir();
-    const canonicalDir = join(home, '.runwork', 'bin');
-    const canonicalBinary = isWindows
-        ? join(canonicalDir, 'runwork.exe')
-        : join(canonicalDir, 'runwork');
-    // process.execPath points at the running binary in a compiled bun binary;
-    // in npm/node mode it points at node, so also consider argv[1].
-    const candidates = [process.execPath, process.argv[1] || ''].filter(Boolean);
-    const runsFromCanonical = candidates.some((p) => normalizePath(p) === normalizePath(canonicalBinary));
-    if (runsFromCanonical) {
-        return {
-            name: 'cli-install-location',
-            status: 'pass',
-            message: `canonical (${canonicalBinary})`,
-        };
-    }
-    // Second best: canonical binary exists but the user is running a different copy.
-    if (existsSync(canonicalBinary)) {
-        return {
-            name: 'cli-install-location',
-            status: 'warn',
-            message: `running from ${candidates[0] || '(unknown)'}, canonical binary also exists at ${canonicalBinary}`,
-            fix: `use the canonical binary by ensuring ${canonicalDir} comes first on PATH, or uninstall the duplicate`,
-        };
-    }
-    // Third case: no canonical binary. That is normal for a system-managed install (brew, npm, etc).
-    return {
-        name: 'cli-install-location',
-        status: 'warn',
-        message: `not at canonical location (running from ${candidates[0] || '(unknown)'})`,
-        fix: `reinstall with the first-party installer to unify with the desktop app: curl -fsSL ${BASE_URL}/install.sh | sh`,
-    };
-}
-function normalizePath(p) {
-    // Collapse trailing separators and case-normalise on Windows.
-    const trimmed = p.replace(new RegExp(`[${sep === '\\' ? '\\\\' : sep}]+$`), '');
-    return osPlatform() === 'win32' ? trimmed.toLowerCase() : trimmed;
-}
-// ── 3 & 4. Authentication + Network (combined) ──────────────────────
-export async function checkAuthAndNetwork(ctx) {
-    if (!ctx.credentials) {
-        return {
-            auth: { name: 'auth', status: 'fail', message: 'not logged in', fix: 'runwork login' },
-            network: { name: 'network', status: 'skip', message: 'skipped (no credentials)' },
-        };
-    }
-    const start = Date.now();
-    try {
-        const workspaces = await ctx.client.listWorkspaces();
-        const elapsed = Date.now() - start;
-        const email = ctx.credentials.email || 'authenticated';
-        const wsCount = workspaces.length;
-        const auth = {
-            name: 'auth',
-            status: 'pass',
-            message: `${email} (${wsCount} workspace${wsCount !== 1 ? 's' : ''})`,
-        };
-        const network = elapsed > 3000
-            ? { name: 'network', status: 'warn', message: `API reachable (${elapsed}ms -- slow)` }
-            : { name: 'network', status: 'pass', message: `API reachable (${elapsed}ms)` };
-        return { auth, network };
-    }
-    catch (err) {
-        const elapsed = Date.now() - start;
-        const message = err instanceof Error ? err.message : String(err);
-        // Distinguish auth error from network error
-        if (message.includes('401') || message.includes('403') || message.includes('Unauthorized')) {
-            return {
-                auth: { name: 'auth', status: 'fail', message: 'token rejected by server', fix: 'runwork login' },
-                network: { name: 'network', status: 'pass', message: `API reachable (${elapsed}ms)` },
-            };
-        }
-        return {
-            auth: { name: 'auth', status: 'skip', message: 'could not verify (network error)' },
-            network: { name: 'network', status: 'fail', message: `API unreachable: ${message}` },
-        };
-    }
-}
-// ── 4a. Git credential helper registration ──────────────────────────
-/**
- * Verify that git's credential helper for the runwork origin is registered
- * and that the binary it points at exists on disk. Catches the very common
- * "logged in with an older CLI before configureGitCredentials shipped"
- * state, where the user has credentials but git falls back to the system
- * credential manager (Git Credential Manager popup on Windows, etc.) when
- * trying to clone or push -- producing confusing UX with no obvious fix.
- *
- * The check is scoped to the *user's* logged-in baseUrl when available, so
- * it doesn't false-fail on staging deployments that point at a different
- * origin.
- */
-export async function checkGitCredentialHelper(ctx) {
-    if (!ctx.credentials) {
-        return {
-            name: 'git-credential-helper',
-            status: 'skip',
-            message: 'skipped (not logged in)',
-        };
-    }
-    // Make sure git itself is callable before we try to read its config --
-    // probeGit() prepends the resolved git directory to PATH for us when it
-    // resolves via fallback, so this also smooths the way for the
-    // execFileSync('git', ...) call below.
-    const git = probeGit();
-    if (!git.installed) {
-        return {
-            name: 'git-credential-helper',
-            status: 'skip',
-            message: 'skipped (git not installed)',
-        };
-    }
-    let origin;
-    try {
-        origin = new URL(ctx.credentials.baseUrl).origin;
-    }
-    catch {
-        return {
-            name: 'git-credential-helper',
-            status: 'fail',
-            message: `cannot parse baseUrl from credentials: ${ctx.credentials.baseUrl}`,
-            fix: 'runwork login',
-        };
-    }
-    // The scoped lookup (get-regexp + origin match) is shared with the
-    // lazy-ensure path in git/credentials.ts so the two can't drift. We only
-    // need to map its result onto doctor's richer status messages here.
-    const lookup = lookupCredentialHelper(origin);
-    if (lookup.status === 'none') {
-        return {
-            name: 'git-credential-helper',
-            status: 'fail',
-            message: `no credential helper registered for ${origin}`,
-            fix: 'runwork doctor --fix',
-        };
-    }
-    if (lookup.status === 'unscoped') {
-        return {
-            name: 'git-credential-helper',
-            status: 'fail',
-            message: `no credential helper registered for ${origin} (found ${lookup.otherCount} other runwork helper entries)`,
-            fix: 'runwork doctor --fix',
-        };
-    }
-    // Helper values starting with `!` are shell commands. Common shapes:
-    //   `!runwork git-credential-helper`                 (PATH-relative)
-    //   `!"/abs/path/to/runwork" git-credential-helper`  (post-Pass-2 hardening, POSIX)
-    //   `!"C:/.../runwork.exe" git-credential-helper`    (post-Pass-2 hardening, Windows)
-    // helperBinaryStatus() validates only absolute-path entries on disk; it
-    // trusts PATH-relative entries to resolve at git-invocation time.
-    const binary = helperBinaryStatus(lookup.value);
-    if (!binary.ok && binary.path) {
-        return {
-            name: 'git-credential-helper',
-            status: 'fail',
-            message: `helper registered but binary not found at ${binary.path}`,
-            fix: 'runwork doctor --fix (re-registers with the current binary path)',
-        };
-    }
-    return {
-        name: 'git-credential-helper',
-        status: 'pass',
-        message: `registered for ${origin}`,
-    };
-}
-// ── 5. Project config ────────────────────────────────────────────────
-export async function checkProjectConfig(ctx) {
-    const configPath = join(ctx.cwd, '.runwork.json');
-    if (!existsSync(configPath)) {
-        // Outside project dir -- check default workspace
-        if (!ctx.credentials) {
-            return { name: 'project-config', status: 'skip', message: 'no project (not logged in)' };
-        }
-        if (ctx.credentials.defaultWorkspaceId) {
-            const wsName = ctx.credentials.defaultWorkspaceName || ctx.credentials.defaultWorkspaceId;
-            return { name: 'project-config', status: 'pass', message: `no project dir (default workspace: ${wsName})` };
-        }
-        return {
-            name: 'project-config',
-            status: 'warn',
-            message: 'no project dir, no default workspace',
-            fix: 'runwork init <name> or runwork clone <app>',
-        };
-    }
-    // Inside project dir
-    if (!ctx.config) {
-        return {
-            name: 'project-config',
-            status: 'fail',
-            message: '.runwork.json is malformed',
-            fix: 'delete and re-run runwork init or runwork clone',
-        };
-    }
-    if (!ctx.config.workspaceId || !ctx.config.appId) {
-        return {
-            name: 'project-config',
-            status: 'fail',
-            message: '.runwork.json missing workspaceId or appId',
-        };
-    }
-    const wsName = ctx.config.workspaceName || ctx.config.workspaceId;
-    const appName = ctx.config.appName || ctx.config.appId;
-    return { name: 'project-config', status: 'pass', message: `${appName} (ws: ${wsName})` };
-}
-// ── 6. App exists on server ──────────────────────────────────────────
-export async function checkAppExists(ctx) {
-    if (!ctx.config?.appId || !ctx.client) {
-        return { name: 'app-exists', status: 'skip', message: 'skipped (no project or no auth)' };
-    }
-    try {
-        const app = await ctx.client.getApp(ctx.config.appId);
-        if (app) {
-            return { name: 'app-exists', status: 'pass', message: 'confirmed on server' };
-        }
-        return {
-            name: 'app-exists',
-            status: 'fail',
-            message: `app ${ctx.config.appId} not found on server`,
-            fix: 'app may have been deleted -- re-create with runwork init',
-        };
-    }
-    catch {
-        return {
-            name: 'app-exists',
-            status: 'fail',
-            message: `app ${ctx.config.appId} not found on server`,
-            fix: 'app may have been deleted -- re-create with runwork init',
-        };
-    }
-}
-// ── 7. Git remote ────────────────────────────────────────────────────
-export async function checkGitRemote(ctx) {
-    if (!ctx.config) {
-        return { name: 'git-remote', status: 'skip', message: 'skipped (no project)' };
-    }
-    // Check if we're in a git repo
-    if (!existsSync(join(ctx.cwd, '.git'))) {
-        return {
-            name: 'git-remote',
-            status: 'fail',
-            message: 'not a git repository',
-            fix: 'git init',
-        };
-    }
-    try {
-        const remoteUrl = execFileSync('git', ['remote', 'get-url', 'runwork'], {
-            cwd: ctx.cwd,
-            stdio: 'pipe',
-        }).toString().trim();
-        // Check if URL looks right (should contain workspace and app IDs)
-        if (ctx.config.workspaceId && !remoteUrl.includes(ctx.config.workspaceId)) {
-            return {
-                name: 'git-remote',
-                status: 'warn',
-                message: `remote "runwork" URL may be stale: ${remoteUrl}`,
-            };
-        }
-        return { name: 'git-remote', status: 'pass', message: `remote configured` };
-    }
-    catch {
-        const baseUrl = ctx.credentials?.baseUrl || 'https://runwork.ai';
-        const expectedUrl = `${baseUrl}/git/${ctx.config.workspaceId}/${ctx.config.appId}`;
-        return {
-            name: 'git-remote',
-            status: 'fail',
-            message: 'remote "runwork" not configured',
-            fix: `runwork doctor --fix (or: git remote add runwork ${expectedUrl})`,
-        };
-    }
-}
-// ── 7a. Deploy freshness ─────────────────────────────────────────────
-/**
- * Compare the current local HEAD against the last deploy recorded from this
- * machine (`.runwork/last-deploy.json`). Surfaces "you have undeployed
- * commits" so a deploy can be verified at a glance (friction log #8). Silent
- * (skip) outside a project or before the first local deploy.
- */
-export async function checkDeployFreshness(ctx) {
-    if (!ctx.config) {
-        return { name: 'deploy-freshness', status: 'skip', message: 'skipped (no project)' };
-    }
-    const summary = getDeploySummary(ctx.cwd);
-    if (!summary.deployedShortSha) {
-        return { name: 'deploy-freshness', status: 'skip', message: 'no deploy recorded from this machine' };
-    }
-    if (summary.inSync === true) {
-        return { name: 'deploy-freshness', status: 'pass', message: `local HEAD matches last deploy (${summary.deployedShortSha})` };
-    }
-    if (summary.inSync === false) {
-        return {
-            name: 'deploy-freshness',
-            status: 'warn',
-            message: `local (${summary.localShortSha}) has commits not in the last deploy (${summary.deployedShortSha})`,
-            fix: 'runwork deploy',
-        };
-    }
-    return { name: 'deploy-freshness', status: 'skip', message: 'local HEAD unknown' };
-}
-// ── 8. Agent setup ───────────────────────────────────────────────────
-function loadSetupState() {
-    // Try project-level first, then user-level
-    const projectPath = join(process.cwd(), '.runwork', 'setup.json');
-    const userPath = join(homedir(), '.runwork', 'setup.json');
-    for (const p of [projectPath, userPath]) {
-        if (existsSync(p)) {
-            try {
-                return JSON.parse(readFileSync(p, 'utf-8'));
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    return null;
-}
-export async function checkAgentSetup() {
-    const state = loadSetupState();
-    if (!state) {
-        return {
-            name: 'agent-setup',
-            status: 'fail',
-            message: 'setup has never been run',
-            fix: 'runwork setup',
-        };
-    }
-    const details = [];
-    let worstStatus = 'pass';
-    const upgrade = (s) => {
-        if (s === 'fail' || (s === 'warn' && worstStatus === 'pass'))
-            worstStatus = s;
-    };
-    // Sub-check: sync freshness
-    const syncAge = Date.now() - new Date(state.lastSyncAt).getTime();
-    const syncDays = Math.floor(syncAge / (1000 * 60 * 60 * 24));
-    if (syncDays > 30) {
-        details.push(`last synced ${syncDays} days ago (stale)`);
-        upgrade('fail');
-    }
-    else if (syncDays > 7) {
-        details.push(`last synced ${syncDays} days ago`);
-        upgrade('warn');
-    }
-    else {
-        details.push(`last synced ${syncDays === 0 ? 'today' : `${syncDays}d ago`}`);
-    }
-    // Sub-check: configured agents still detected
-    const detected = await detectAgents();
-    const detectedSlugs = new Set(detected.map(a => a.slug));
-    const missingAgents = state.configuredAgents.filter(s => !detectedSlugs.has(s));
-    if (missingAgents.length > 0) {
-        details.push(`${missingAgents.length} agent(s) no longer detected: ${missingAgents.join(', ')}`);
-        upgrade('warn');
-    }
-    else {
-        details.push(`${state.configuredAgents.length} agent(s) configured`);
-    }
-    // Sub-check: MCP servers present in agent configs
-    // We check the first configured agent that supports MCP
-    let mcpChecked = false;
-    for (const slug of state.configuredAgents) {
-        const adapter = getAdapterBySlug(slug);
-        if (!adapter || !adapter.supportsMcpScope('user'))
-            continue;
-        // Check if MCP config file exists and contains our entries
-        const mcpConfigPath = getMcpConfigPath(slug, 'user');
-        if (mcpConfigPath && existsSync(mcpConfigPath)) {
-            try {
-                const content = readFileSync(mcpConfigPath, 'utf-8');
-                const missingMcp = state.mcpServers.filter(name => !content.includes(name));
-                if (missingMcp.length > 0) {
-                    details.push(`${missingMcp.length} MCP server(s) missing from ${slug} config`);
-                    upgrade('warn');
-                }
-                else {
-                    details.push(`${state.mcpServers.length} MCP server(s) configured`);
-                }
-                mcpChecked = true;
-                break;
-            }
-            catch {
-                // can't read config, skip
-            }
-        }
-    }
-    if (!mcpChecked && state.mcpServers.length > 0) {
-        details.push('could not verify MCP servers');
-        upgrade('warn');
-    }
-    // Sub-check: skills present
-    let skillsChecked = false;
-    for (const slug of state.configuredAgents) {
-        const skillsDir = getSkillsDir(slug, 'user');
-        if (!skillsDir)
-            continue;
-        const missingSkills = state.skills.filter(name => {
-            const skillPath = join(skillsDir, name, 'SKILL.md');
-            return !existsSync(skillPath);
-        });
-        if (missingSkills.length > 0) {
-            details.push(`${missingSkills.length} skill(s) missing from ${slug}`);
-            upgrade('warn');
-        }
-        else if (state.skills.length > 0) {
-            details.push(`${state.skills.length} skill(s) installed`);
-        }
-        skillsChecked = true;
-        break;
-    }
-    if (!skillsChecked && state.skills.length > 0) {
-        details.push('could not verify skills');
-        upgrade('warn');
-    }
-    // Build summary message
-    const summary = worstStatus === 'pass'
-        ? details[0]
-        : details.filter(d => !d.startsWith(`${state.configuredAgents.length} agent`) &&
-            !d.startsWith(`${state.mcpServers.length} MCP`) &&
-            !d.startsWith(`${state.skills.length} skill`)).join('; ') || details[0];
-    return {
-        name: 'agent-setup',
-        status: worstStatus,
-        message: summary,
-        details,
-        ...(worstStatus !== 'pass' ? { fix: 'runwork sync' } : {}),
-    };
-}
-// ── Helpers for agent config paths ───────────────────────────────────
-function getMcpConfigPath(slug, scope) {
-    const home = homedir();
-    switch (slug) {
-        case 'claude-code':
-            return scope === 'project'
-                ? join(process.cwd(), '.mcp.json')
-                : join(home, '.claude', 'settings.json');
-        case 'cursor':
-            return scope === 'project'
-                ? join(process.cwd(), '.cursor', 'mcp.json')
-                : join(home, '.cursor', 'mcp.json');
-        case 'windsurf':
-            return scope === 'project'
-                ? join(process.cwd(), '.windsurf', 'mcp.json')
-                : join(home, '.windsurf', 'mcp.json');
-        case 'codex':
-            return scope === 'user'
-                ? join(home, '.codex', 'mcp.json')
-                : null;
-        case 'gemini':
-            return scope === 'user'
-                ? join(home, '.gemini', 'settings.json')
-                : null;
-        default:
-            return null;
-    }
-}
-function getSkillsDir(slug, scope) {
-    const home = homedir();
-    switch (slug) {
-        case 'claude-code':
-            return scope === 'project'
-                ? join(process.cwd(), '.claude', 'skills')
-                : join(home, '.claude', 'skills');
-        case 'codex':
-            return scope === 'project'
-                ? join(process.cwd(), '.codex', 'skills')
-                : join(home, '.codex', 'skills');
-        case 'gemini':
-            return scope === 'project'
-                ? join(process.cwd(), '.gemini', 'skills')
-                : join(home, '.gemini', 'skills');
-        default:
-            return null;
-    }
-}

package/dist/health/fix.d.ts

@@ -1,22 +0,0 @@
-import type { DoctorContext } from './checks.js';
-/** Check names `runwork doctor --fix` knows how to auto-remediate. */
-export declare const FIXABLE_CHECKS: readonly string[];
-export interface FixOutcome {
-    /** The check name this outcome corresponds to. */
-    name: string;
-    /** Whether a remediation was actually applied (false = couldn't, with a reason). */
-    applied: boolean;
-    /** Human-readable description of what was done, or why it couldn't be. */
-    message: string;
-}
-/**
- * Apply auto-remediations for the failing checks doctor knows how to fix.
- * Only acts on `failingNames` that are in FIXABLE_CHECKS; everything else is
- * left for the user (with the `fix` hint each check already carries).
- *
- * - git-credential-helper -> register the runwork git helper for the logged-in
- *   origin (the B1 ensure-path), so headless-auth'd sessions can use git.
- * - git-remote -> point the `runwork` remote at the app's canonical URL (the
- *   B2 ensure-path), using the correct `/api/git/...` URL from the API client.
- */
-export declare function applyDoctorFixes(ctx: DoctorContext, failingNames: string[]): Promise<FixOutcome[]>;