runwork 0.6.2 → 0.8.2

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.6.2";
+export declare const VERSION = "0.8.2";

package/dist/generated/version.js

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

package/dist/health/__tests__/cli-distribution-checks.test.d.ts

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

package/dist/health/__tests__/cli-distribution-checks.test.js

@@ -0,0 +1,199 @@
+/**
+ * Tests for the first-party distribution checks added to runwork doctor.
+ *
+ * These checks rely on fetch() to hit https://runwork.ai/cli/latest.json.
+ * We stub globalThis.fetch to redirect those calls to a local HTTP server
+ * so the suite has no outbound network dependency.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createServer } from 'node:http';
+import { checkCliVersion, checkCliArtifactReachable, checkCliInstallLocation, } from '../checks.js';
+function startServer() {
+    return new Promise((resolvePromise) => {
+        let currentManifest = null;
+        let manifestStatus = 200;
+        const artifactStatuses = new Map();
+        const server = createServer((req, res) => {
+            const url = req.url ?? '/';
+            if (url === '/cli/latest.json') {
+                if (currentManifest === null) {
+                    res.writeHead(manifestStatus, { 'Content-Type': 'application/json' });
+                    res.end('{"error": "not available"}');
+                    return;
+                }
+                res.writeHead(manifestStatus, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify(currentManifest));
+                return;
+            }
+            // Artifact route: /cli/releases/<version>/<artifact>
+            const releaseMatch = url.match(/^\/cli\/releases\/[^/]+\/runwork-([^/]+)\.(tar\.gz|zip)$/);
+            if (releaseMatch) {
+                const key = releaseMatch[1];
+                const status = artifactStatuses.get(key) ?? 200;
+                res.writeHead(status, { 'Content-Type': 'application/octet-stream' });
+                res.end('');
+                return;
+            }
+            res.writeHead(404);
+            res.end('not found');
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (addr && typeof addr === 'object') {
+                const port = addr.port;
+                resolvePromise({
+                    url: `http://127.0.0.1:${port}`,
+                    stop: () => new Promise((stop) => server.close(() => stop())),
+                    setManifest(m, s = 200) {
+                        currentManifest = m;
+                        manifestStatus = s;
+                    },
+                    setArtifactStatus(key, s) {
+                        artifactStatuses.set(key, s);
+                    },
+                });
+            }
+        });
+    });
+}
+/**
+ * Redirect fetch calls to https://runwork.ai/... at the real test server.
+ * Returns a restore function.
+ */
+function redirectFetch(baseUrl) {
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = ((input, init) => {
+        const href = typeof input === 'string' ? input : input.toString();
+        if (href.startsWith('https://runwork.ai')) {
+            const redirected = href.replace('https://runwork.ai', baseUrl);
+            return realFetch(redirected, init);
+        }
+        return realFetch(input, init);
+    });
+    return () => {
+        globalThis.fetch = realFetch;
+    };
+}
+describe('checkCliVersion (runwork.ai backed)', () => {
+    let server;
+    let restoreFetch;
+    beforeEach(async () => {
+        server = await startServer();
+        restoreFetch = redirectFetch(server.url);
+    });
+    afterEach(async () => {
+        restoreFetch();
+        await server.stop();
+    });
+    it('skips with an explicit unreachable message when the manifest 404s', async () => {
+        server.setManifest(null, 404);
+        const result = await checkCliVersion();
+        expect(result.status).toBe('skip');
+        expect(result.message).toContain('unreachable');
+    });
+    it('passes when manifest version matches current VERSION', async () => {
+        // We cannot read VERSION here without depending on the generated file
+        // at test time; instead, serve "0.0.0" and expect the test to compare.
+        // To make this deterministic, we fetch the current VERSION from the
+        // module under test via a side channel. See the runner for the value.
+        const { VERSION } = await import('../../generated/version.js');
+        server.setManifest({ version: VERSION });
+        const result = await checkCliVersion();
+        expect(result.status).toBe('pass');
+        expect(result.message).toContain(VERSION);
+    });
+    it('warns when the manifest has a newer version', async () => {
+        server.setManifest({ version: '99.99.99' });
+        const result = await checkCliVersion();
+        expect(result.status).toBe('warn');
+        expect(result.message).toContain('99.99.99');
+        expect(result.fix).toBe('runwork upgrade');
+    });
+    it('skips when the manifest has no version field', async () => {
+        server.setManifest({ name: 'runwork' });
+        const result = await checkCliVersion();
+        expect(result.status).toBe('skip');
+    });
+});
+describe('checkCliArtifactReachable', () => {
+    let server;
+    let restoreFetch;
+    beforeEach(async () => {
+        server = await startServer();
+        restoreFetch = redirectFetch(server.url);
+    });
+    afterEach(async () => {
+        restoreFetch();
+        await server.stop();
+    });
+    function platformKey() {
+        const os = process.platform === 'darwin' ? 'darwin' : process.platform === 'linux' ? 'linux' : 'windows';
+        const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+        return `${os}-${arch}`;
+    }
+    it('fails when the manifest is unreachable', async () => {
+        server.setManifest(null, 500);
+        const result = await checkCliArtifactReachable();
+        expect(result.status).toBe('fail');
+        expect(result.message).toContain('unreachable');
+    });
+    it('fails when the manifest has no artifact for the host platform', async () => {
+        server.setManifest({
+            version: '99.99.99',
+            artifacts: {
+                'unknown-unknown': { path: '/cli/releases/99.99.99/runwork-unknown-unknown.tar.gz', sha256: 'deadbeef' },
+            },
+        });
+        const result = await checkCliArtifactReachable();
+        expect(result.status).toBe('fail');
+        expect(result.message).toMatch(/no artifact for/);
+    });
+    it('passes when the artifact HEAD returns 200', async () => {
+        const key = platformKey();
+        const ext = key === 'windows-x64' ? 'zip' : 'tar.gz';
+        server.setManifest({
+            version: '99.99.99',
+            artifacts: {
+                [key]: {
+                    path: `/cli/releases/99.99.99/runwork-${key}.${ext}`,
+                    sha256: 'deadbeef',
+                },
+            },
+        });
+        server.setArtifactStatus(key, 200);
+        const result = await checkCliArtifactReachable();
+        expect(result.status).toBe('pass');
+        expect(result.message).toContain(key);
+    });
+    it('fails when the artifact HEAD returns a non-2xx status', async () => {
+        const key = platformKey();
+        const ext = key === 'windows-x64' ? 'zip' : 'tar.gz';
+        server.setManifest({
+            version: '99.99.99',
+            artifacts: {
+                [key]: {
+                    path: `/cli/releases/99.99.99/runwork-${key}.${ext}`,
+                    sha256: 'deadbeef',
+                },
+            },
+        });
+        server.setArtifactStatus(key, 404);
+        const result = await checkCliArtifactReachable();
+        expect(result.status).toBe('fail');
+        expect(result.message).toContain('404');
+    });
+});
+describe('checkCliInstallLocation', () => {
+    const originalExecPath = process.execPath;
+    const originalArgv1 = process.argv[1];
+    afterEach(() => {
+        Object.defineProperty(process, 'execPath', { value: originalExecPath, writable: true });
+        process.argv[1] = originalArgv1;
+    });
+    it('warns when process does not run from the canonical ~/.runwork/bin/runwork', async () => {
+        Object.defineProperty(process, 'execPath', { value: '/usr/local/bin/node', writable: true });
+        process.argv[1] = '/opt/homebrew/bin/runwork';
+        const result = await checkCliInstallLocation();
+        expect(result.status).toBe('warn');
+    });
+});

package/dist/health/checks.d.ts

@@ -10,6 +10,8 @@ export interface DoctorContext {
 export declare function buildContext(): DoctorContext;
 export declare function checkSystemDeps(): Promise<CheckResult>;
 export declare function checkCliVersion(): Promise<CheckResult>;
+export declare function checkCliArtifactReachable(): Promise<CheckResult>;
+export declare function checkCliInstallLocation(): Promise<CheckResult>;
 export declare function checkAuthAndNetwork(ctx: DoctorContext): Promise<{
     auth: CheckResult;
     network: CheckResult;

package/dist/health/checks.js

@@ -1,11 +1,37 @@
 import { execFileSync } from 'child_process';
 import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
+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';
+// 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 fetch(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;
@@ -46,29 +72,116 @@ export async function checkSystemDeps() {
 }
 // ── 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 fetch('https://api.github.com/repos/runwork-ai/cli/releases/latest');
+        const response = await fetch(artifactUrl, { method: 'HEAD' });
         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-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-version',
-            status: 'warn',
-            message: `${VERSION} (${latest} available)`,
-            fix: 'runwork upgrade',
+            name: 'cli-artifact',
+            status: 'fail',
+            message: `${artifactUrl} unreachable: ${msg}`,
         };
     }
-    catch {
-        return { name: 'cli-version', status: 'skip', message: `${VERSION} (could not check for updates)` };
+}
+// ── 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) {

package/dist/health/runner.js

@@ -1,11 +1,15 @@
-import { buildContext, checkSystemDeps, checkCliVersion, checkAuthAndNetwork, checkProjectConfig, checkAppExists, checkGitRemote, checkAgentSetup, } from './checks.js';
+import { buildContext, checkSystemDeps, checkCliVersion, checkCliArtifactReachable, checkCliInstallLocation, 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
+    // 2. CLI version (runwork.ai/cli/latest.json)
     checks.push(await checkCliVersion());
+    // 2a. CLI artifact reachability for this host platform
+    checks.push(await checkCliArtifactReachable());
+    // 2b. Canonical install location
+    checks.push(await checkCliInstallLocation());
     // 3 & 4. Auth + Network (combined call)
     const { auth, network } = await checkAuthAndNetwork(ctx);
     checks.push(auth);

package/dist/index.js

@@ -22,6 +22,8 @@ import { agentsCommand } from './commands/agents.js';
 import { mcpCommand } from './commands/mcp.js';
 import { setupCommand } from './commands/setup.js';
 import { syncCommand } from './commands/sync.js';
+import { buildPluginCommand } from './commands/build-plugin.js';
+import { uninstallCommand } from './commands/uninstall.js';
 import { appsCommand } from './commands/apps.js';
 import { doctorCommand } from './commands/doctor.js';
 import { handleGitCredentialRequest } from './git/credentials.js';
@@ -58,6 +60,8 @@ program.addCommand(agentsCommand);
 program.addCommand(mcpCommand);
 program.addCommand(setupCommand);
 program.addCommand(syncCommand);
+program.addCommand(buildPluginCommand);
+program.addCommand(uninstallCommand);
 program.addCommand(appsCommand);
 program.addCommand(doctorCommand);
 program.addHelpText('after', '\nFor AI agents: run "runwork info --json" to discover app context and available commands.');

package/dist/sync/executor.d.ts

@@ -6,6 +6,8 @@ interface ExecutorContext {
     workspaceId: string;
     adapters: AgentAdapter[];
     scopes: Array<'project' | 'user'>;
+    /** True when MCP servers are configured; app-sourced skills are skipped since MCP provides them */
+    hasMcp?: boolean;
 }
 /**
  * Execute the resolved sync plan: pull remote skills, push local skills,

package/dist/sync/executor.js

@@ -1,3 +1,4 @@
+import { toSlug } from '../agents/types.js';
 import { contentHash } from './hash.js';
 /**
  * Execute the resolved sync plan: pull remote skills, push local skills,
@@ -10,7 +11,7 @@ export async function executeSyncPlan(plan, resolvedConflicts, ctx) {
         if (!action.remoteContent)
             continue;
         const hash = contentHash(action.remoteContent);
-        writeSkillToAgents(action.name, action.remoteContent, ctx);
+        writeSkillToAgents(action.name, action.remoteContent, action.source, ctx);
         newHashes[action.name] = {
             localHash: hash,
             remoteHash: hash,
@@ -54,7 +55,7 @@ export async function executeSyncPlan(plan, resolvedConflicts, ctx) {
             console.log(`  Pushed (conflict resolved): ${action.name}`);
         }
         else if (resolution === 'remote' && action.remoteContent) {
-            writeSkillToAgents(action.name, action.remoteContent, ctx);
+            writeSkillToAgents(action.name, action.remoteContent, action.source, ctx);
             const hash = contentHash(action.remoteContent);
             newHashes[action.name] = { localHash: hash, remoteHash: hash, source: 'external', remoteId: action.remoteId };
             console.log(`  Pulled (conflict resolved): ${action.name}`);
@@ -70,14 +71,17 @@ export async function executeSyncPlan(plan, resolvedConflicts, ctx) {
     }
     return newHashes;
 }
-function writeSkillToAgents(name, content, ctx) {
+function writeSkillToAgents(name, content, source, ctx) {
     const skillFile = {
         name,
-        filename: name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
+        filename: toSlug(name),
         content,
         description: extractDescription(content),
     };
     for (const adapter of ctx.adapters) {
+        // Skip app-sourced skills for adapters where MCP already provides them as skill_* tools
+        if (source === 'app' && ctx.hasMcp && adapter.mcpProvidesSkills)
+            continue;
         for (const scope of ctx.scopes) {
             if (!adapter.supportsSkills())
                 continue;

package/dist/types.d.ts

@@ -130,6 +130,8 @@ export interface SetupState {
     lastSyncAt: string;
     mcpServers: string[];
     skills: string[];
+    /** Kebab-case filenames of synced skills (used for safe cleanup) */
+    skillFilenames?: string[];
     skillHashes?: Record<string, {
         localHash: string;
         remoteHash: string;

package/dist/ui/banner.js

@@ -1,5 +1,14 @@
-import { basename } from 'path';
+import { homedir } from 'os';
 import { bold, cyan, dim, green } from './colors.js';
+/** Format an absolute path for display, collapsing $HOME to ~. */
+function prettyPath(dir) {
+    const home = homedir();
+    if (dir === home)
+        return '~';
+    if (dir.startsWith(home + '/'))
+        return '~' + dir.slice(home.length);
+    return dir;
+}
 export const SUPPORTED_AGENTS = [
     { id: 'claude-code', name: 'Claude Code', command: 'cd {dir} && claude' },
     { id: 'cursor', name: 'Cursor', command: 'cursor {dir}' },
@@ -55,16 +64,16 @@ export async function runAgentWizard(directory, configuredAgents) {
         console.log(getAgentGuidance(directory));
         return;
     }
-    const slug = basename(directory) || directory;
+    const displayDir = prettyPath(directory);
     // If we already know which agents are configured, skip the prompt
     if (configuredAgents && configuredAgents.length > 0) {
         const knownAgent = SUPPORTED_AGENTS.find(a => configuredAgents.includes(a.id));
         if (knownAgent) {
-            const agentCmd = knownAgent.command.replace(/{dir}/g, slug);
+            const agentCmd = knownAgent.command.replace(/{dir}/g, displayDir);
             console.log('');
             console.log(bold('Get started:'));
             console.log('');
-            console.log(`  ${dim('1.')} cd ${slug} && runwork dev`);
+            console.log(`  ${dim('1.')} cd ${displayDir} && runwork dev`);
             if (knownAgent.id === 'claude-desktop') {
                 console.log(`  ${dim('2.')} ${agentCmd}`);
             }
@@ -90,11 +99,11 @@ export async function runAgentWizard(directory, configuredAgents) {
     const agent = SUPPORTED_AGENTS.find(a => a.id === result);
     if (!agent)
         return;
-    const agentCmd = agent.command.replace(/{dir}/g, slug);
+    const agentCmd = agent.command.replace(/{dir}/g, displayDir);
     console.log('');
     console.log(bold('Get started:'));
     console.log('');
-    console.log(`  ${dim('1.')} cd ${slug} && runwork dev`);
+    console.log(`  ${dim('1.')} cd ${displayDir} && runwork dev`);
     if (agent.id === 'claude-desktop') {
         console.log(`  ${dim('2.')} ${agentCmd}`);
         console.log('');