runwork 0.5.1 → 0.6.0

package/dist/health/__tests__/checks.test.js

@@ -0,0 +1,223 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+vi.mock('fs', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, existsSync: vi.fn(() => true) };
+});
+vi.mock('child_process', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, execFileSync: vi.fn() };
+});
+import { existsSync } from 'fs';
+import { execFileSync } from 'child_process';
+const mockedExistsSync = vi.mocked(existsSync);
+const mockedExecFileSync = vi.mocked(execFileSync);
+beforeEach(() => {
+    vi.clearAllMocks();
+    vi.restoreAllMocks();
+    vi.spyOn(console, 'log').mockImplementation(() => { });
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+    mockedExistsSync.mockReturnValue(true);
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+// ── Helpers ──────────────────────────────────────────────────────────
+function makeCtx(overrides = {}) {
+    return {
+        credentials: { apiKey: 'key', email: 'user@test.com', baseUrl: 'https://runwork.ai' },
+        client: null,
+        config: null,
+        cwd: '/test/dir',
+        ...overrides,
+    };
+}
+function makeConfig(overrides = {}) {
+    return {
+        workspaceId: 'ws-1',
+        workspaceName: 'Test WS',
+        appId: 'app-1',
+        appName: 'Test App',
+        ...overrides,
+    };
+}
+// ── 1. System Dependencies ───────────────────────────────────────────
+describe('checkSystemDeps', () => {
+    it('passes with modern git', async () => {
+        mockedExecFileSync.mockReturnValue(Buffer.from('git version 2.43.0'));
+        const { checkSystemDeps } = await import('../checks.js');
+        const result = await checkSystemDeps();
+        expect(result.status).toBe('pass');
+        expect(result.message).toContain('2.43.0');
+    });
+    it('warns with old git', async () => {
+        mockedExecFileSync.mockReturnValue(Buffer.from('git version 2.15.0'));
+        const { checkSystemDeps } = await import('../checks.js');
+        const result = await checkSystemDeps();
+        expect(result.status).toBe('warn');
+        expect(result.message).toContain('old');
+    });
+    it('fails when git not found', async () => {
+        mockedExecFileSync.mockImplementation(() => { throw new Error('not found'); });
+        const { checkSystemDeps } = await import('../checks.js');
+        const result = await checkSystemDeps();
+        expect(result.status).toBe('fail');
+        expect(result.fix).toBeDefined();
+    });
+});
+// ── 3 & 4. Auth + Network ───────────────────────────────────────────
+describe('checkAuthAndNetwork', () => {
+    it('fails auth when no credentials', async () => {
+        const { checkAuthAndNetwork } = await import('../checks.js');
+        const ctx = makeCtx({ credentials: null, client: null });
+        const { auth, network } = await checkAuthAndNetwork(ctx);
+        expect(auth.status).toBe('fail');
+        expect(auth.fix).toContain('login');
+        expect(network.status).toBe('skip');
+    });
+    it('passes when API responds', async () => {
+        const { checkAuthAndNetwork } = await import('../checks.js');
+        const mockClient = {
+            listWorkspaces: vi.fn().mockResolvedValue([{ id: 'ws-1', name: 'WS' }]),
+        };
+        const ctx = makeCtx({ client: mockClient });
+        const { auth, network } = await checkAuthAndNetwork(ctx);
+        expect(auth.status).toBe('pass');
+        expect(auth.message).toContain('user@test.com');
+        expect(network.status).toBe('pass');
+    });
+    it('distinguishes auth error from network error', async () => {
+        const { checkAuthAndNetwork } = await import('../checks.js');
+        const mockClient = {
+            listWorkspaces: vi.fn().mockRejectedValue(new Error('API error 401: Unauthorized')),
+        };
+        const ctx = makeCtx({ client: mockClient });
+        const { auth, network } = await checkAuthAndNetwork(ctx);
+        expect(auth.status).toBe('fail');
+        expect(network.status).toBe('pass');
+    });
+    it('fails network on connection error', async () => {
+        const { checkAuthAndNetwork } = await import('../checks.js');
+        const mockClient = {
+            listWorkspaces: vi.fn().mockRejectedValue(new Error('fetch failed')),
+        };
+        const ctx = makeCtx({ client: mockClient });
+        const { auth, network } = await checkAuthAndNetwork(ctx);
+        expect(auth.status).toBe('skip');
+        expect(network.status).toBe('fail');
+    });
+});
+// ── 5. Project Config ────────────────────────────────────────────────
+describe('checkProjectConfig', () => {
+    it('passes with valid config', async () => {
+        const { checkProjectConfig } = await import('../checks.js');
+        mockedExistsSync.mockReturnValue(true);
+        const ctx = makeCtx({ config: makeConfig() });
+        const result = await checkProjectConfig(ctx);
+        expect(result.status).toBe('pass');
+        expect(result.message).toContain('Test App');
+        expect(result.message).toContain('Test WS');
+    });
+    it('fails with malformed config (null)', async () => {
+        const { checkProjectConfig } = await import('../checks.js');
+        mockedExistsSync.mockReturnValue(true);
+        const ctx = makeCtx({ config: null });
+        const result = await checkProjectConfig(ctx);
+        expect(result.status).toBe('fail');
+        expect(result.message).toContain('malformed');
+    });
+    it('passes outside project when default workspace set', async () => {
+        const { checkProjectConfig } = await import('../checks.js');
+        mockedExistsSync.mockReturnValue(false);
+        const creds = {
+            apiKey: 'key',
+            email: 'user@test.com',
+            baseUrl: 'https://runwork.ai',
+            defaultWorkspaceId: 'ws-1',
+            defaultWorkspaceName: 'My WS',
+        };
+        const ctx = makeCtx({ credentials: creds, config: null });
+        const result = await checkProjectConfig(ctx);
+        expect(result.status).toBe('pass');
+        expect(result.message).toContain('My WS');
+    });
+    it('warns outside project when no default workspace', async () => {
+        const { checkProjectConfig } = await import('../checks.js');
+        mockedExistsSync.mockReturnValue(false);
+        const ctx = makeCtx({ config: null });
+        const result = await checkProjectConfig(ctx);
+        expect(result.status).toBe('warn');
+        expect(result.fix).toBeDefined();
+    });
+});
+// ── 6. App Exists ────────────────────────────────────────────────────
+describe('checkAppExists', () => {
+    it('skips when no config or client', async () => {
+        const { checkAppExists } = await import('../checks.js');
+        const ctx = makeCtx({ config: null });
+        const result = await checkAppExists(ctx);
+        expect(result.status).toBe('skip');
+    });
+    it('passes when app found on server', async () => {
+        const { checkAppExists } = await import('../checks.js');
+        const mockClient = {
+            getApp: vi.fn().mockResolvedValue({ id: 'app-1', name: 'Test' }),
+        };
+        const ctx = makeCtx({ config: makeConfig(), client: mockClient });
+        const result = await checkAppExists(ctx);
+        expect(result.status).toBe('pass');
+    });
+    it('fails when app not found', async () => {
+        const { checkAppExists } = await import('../checks.js');
+        const mockClient = {
+            getApp: vi.fn().mockRejectedValue(new Error('404')),
+        };
+        const ctx = makeCtx({ config: makeConfig(), client: mockClient });
+        const result = await checkAppExists(ctx);
+        expect(result.status).toBe('fail');
+        expect(result.message).toContain('not found');
+    });
+});
+// ── 7. Git Remote ────────────────────────────────────────────────────
+describe('checkGitRemote', () => {
+    it('skips when no project config', async () => {
+        const { checkGitRemote } = await import('../checks.js');
+        const ctx = makeCtx({ config: null });
+        const result = await checkGitRemote(ctx);
+        expect(result.status).toBe('skip');
+    });
+    it('fails when not a git repo', async () => {
+        const { checkGitRemote } = await import('../checks.js');
+        mockedExistsSync.mockReturnValue(false);
+        const ctx = makeCtx({ config: makeConfig() });
+        const result = await checkGitRemote(ctx);
+        expect(result.status).toBe('fail');
+        expect(result.message).toContain('not a git repository');
+    });
+    it('passes when remote configured correctly', async () => {
+        const { checkGitRemote } = await import('../checks.js');
+        mockedExistsSync.mockReturnValue(true);
+        mockedExecFileSync.mockReturnValue(Buffer.from('https://runwork.ai/git/ws-1/app-1'));
+        const ctx = makeCtx({ config: makeConfig() });
+        const result = await checkGitRemote(ctx);
+        expect(result.status).toBe('pass');
+    });
+    it('fails when remote not configured', async () => {
+        const { checkGitRemote } = await import('../checks.js');
+        mockedExistsSync.mockReturnValue(true);
+        mockedExecFileSync.mockImplementation(() => { throw new Error('No such remote'); });
+        const ctx = makeCtx({ config: makeConfig() });
+        const result = await checkGitRemote(ctx);
+        expect(result.status).toBe('fail');
+        expect(result.fix).toContain('git remote add');
+    });
+});
+// ── 8. Agent Setup ───────────────────────────────────────────────────
+describe('checkAgentSetup', () => {
+    it('fails when setup never run', async () => {
+        const { checkAgentSetup } = await import('../checks.js');
+        mockedExistsSync.mockReturnValue(false);
+        const result = await checkAgentSetup();
+        expect(result.status).toBe('fail');
+        expect(result.fix).toContain('runwork setup');
+    });
+});

package/dist/health/checks.d.ts

@@ -0,0 +1,20 @@
+import { ApiClient } from '../api/client.js';
+import type { RunworkConfig, Credentials } from '../types.js';
+import type { CheckResult } from './types.js';
+export interface DoctorContext {
+    credentials: Credentials | null;
+    client: ApiClient | null;
+    config: RunworkConfig | null;
+    cwd: string;
+}
+export declare function buildContext(): DoctorContext;
+export declare function checkSystemDeps(): Promise<CheckResult>;
+export declare function checkCliVersion(): Promise<CheckResult>;
+export declare function checkAuthAndNetwork(ctx: DoctorContext): Promise<{
+    auth: CheckResult;
+    network: CheckResult;
+}>;
+export declare function checkProjectConfig(ctx: DoctorContext): Promise<CheckResult>;
+export declare function checkAppExists(ctx: DoctorContext): Promise<CheckResult>;
+export declare function checkGitRemote(ctx: DoctorContext): Promise<CheckResult>;
+export declare function checkAgentSetup(): Promise<CheckResult>;

package/dist/health/checks.js

@@ -0,0 +1,392 @@
+import { execFileSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } 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';
+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() {
+    try {
+        const output = execFileSync('git', ['--version'], { stdio: 'pipe' }).toString().trim();
+        const match = output.match(/(\d+\.\d+(?:\.\d+)?)/);
+        const version = match ? match[1] : 'unknown';
+        if (match) {
+            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)` };
+            }
+        }
+        return { name: 'system-deps', status: 'pass', message: `git ${version}` };
+    }
+    catch {
+        return {
+            name: 'system-deps',
+            status: 'fail',
+            message: 'git not found in PATH',
+            fix: 'Install git: https://git-scm.com/downloads',
+        };
+    }
+}
+// ── 2. CLI version ───────────────────────────────────────────────────
+export async function checkCliVersion() {
+    try {
+        const response = await fetch('https://api.github.com/repos/runwork-ai/cli/releases/latest');
+        if (!response.ok) {
+            return { name: 'cli-version', status: 'skip', message: `${VERSION} (could not check for updates)` };
+        }
+        const data = await response.json();
+        const latest = data.tag_name?.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',
+        };
+    }
+    catch {
+        return { name: 'cli-version', status: 'skip', message: `${VERSION} (could not check for updates)` };
+    }
+}
+// ── 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}` },
+        };
+    }
+}
+// ── 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: `git remote add runwork ${expectedUrl}`,
+        };
+    }
+}
+// ── 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/runner.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorReport } from './types.js';
+export declare function runAllChecks(): Promise<DoctorReport>;

package/dist/health/runner.js

@@ -0,0 +1,26 @@
+import { buildContext, checkSystemDeps, checkCliVersion, checkAuthAndNetwork, checkProjectConfig, checkAppExists, checkGitRemote, checkAgentSetup, } from './checks.js';
+export async function runAllChecks() {
+    const ctx = buildContext();
+    const checks = [];
+    // 1. System deps
+    checks.push(await checkSystemDeps());
+    // 2. CLI version
+    checks.push(await checkCliVersion());
+    // 3 & 4. Auth + Network (combined call)
+    const { auth, network } = await checkAuthAndNetwork(ctx);
+    checks.push(auth);
+    checks.push(network);
+    // 5. Project config
+    checks.push(await checkProjectConfig(ctx));
+    // 6. App exists
+    checks.push(await checkAppExists(ctx));
+    // 7. Git remote
+    checks.push(await checkGitRemote(ctx));
+    // 8. Agent setup
+    checks.push(await checkAgentSetup());
+    // Overall status: worst of all checks
+    const hasFailure = checks.some(c => c.status === 'fail');
+    const hasWarning = checks.some(c => c.status === 'warn');
+    const status = hasFailure ? 'fail' : hasWarning ? 'warn' : 'pass';
+    return { status, checks };
+}

package/dist/health/types.d.ts

@@ -0,0 +1,12 @@
+export type CheckStatus = 'pass' | 'warn' | 'fail' | 'skip';
+export interface CheckResult {
+    name: string;
+    status: CheckStatus;
+    message: string;
+    fix?: string;
+    details?: string[];
+}
+export interface DoctorReport {
+    status: CheckStatus;
+    checks: CheckResult[];
+}

package/dist/health/types.js

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