runwork 0.6.1 → 0.8.2

package/dist/commands/sync.js

@@ -5,7 +5,8 @@ import { homedir } from 'os';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { getAdapterBySlug } from '../agents/detect.js';
-import { RUNWORK_MCP_PREFIX } from '../agents/types.js';
+import { RUNWORK_MCP_PREFIX, RUNWORK_WORKSPACE_MCP_NAME } from '../agents/types.js';
+import { collectTelemetryEvents, printTelemetryVerbose, summarizeTelemetryForDryRun, } from './sync-telemetry.js';
 import { generateIntroSkill, generateInstructionHint, buildAppSkillDescription } from '../agents/intro-skill.js';
 import { computeSyncPlan } from '../sync/change-detect.js';
 import { printSyncSummary, resolveConflict, resolveConflictNonInteractive } from '../sync/conflict-ui.js';
@@ -119,7 +120,7 @@ export async function syncFromState(state, statePath, credentials, opts) {
         description: `Runwork MCP server: ${s.name}. Provides tools for interacting with this workspace resource.`,
     }));
     mcpEntries.push({
-        name: `${RUNWORK_MCP_PREFIX}Workspace Tools`,
+        name: RUNWORK_WORKSPACE_MCP_NAME,
         url: `${baseUrl}/api/workspaces/${state.workspaceId}/mcp`,
         transport: 'streamable-http',
         headers: { Authorization: `Bearer ${credentials.apiKey}` },
@@ -158,8 +159,35 @@ export async function syncFromState(state, statePath, credentials, opts) {
     else {
         console.log('  All skills up to date.');
     }
-    if (opts.dryRun)
+    // Build adapters early so telemetry collection works in both dry-run and real paths
+    const adapters = [];
+    for (const slug of state.configuredAgents) {
+        const adapter = getAdapterBySlug(slug);
+        if (adapter)
+            adapters.push(adapter);
+    }
+    if (opts.dryRun) {
+        try {
+            const telemetry = await collectTelemetryEvents({
+                adapters,
+                state,
+                syncedSkillsCount: remoteSkills.length,
+                syncedMcpServersCount: mcpEntries.length,
+                teamInstructionsApplied: false,
+                agentConfigsApplied: 0,
+            });
+            if (opts.verbose) {
+                printTelemetryVerbose(telemetry);
+            }
+            else {
+                console.log(`\n  ${summarizeTelemetryForDryRun(telemetry)}`);
+            }
+        }
+        catch {
+            // Telemetry preview is best-effort
+        }
         return;
+    }
     // Resolve conflicts
     const resolvedConflicts = new Map();
     for (const conflict of plan.conflicts) {
@@ -176,13 +204,6 @@ export async function syncFromState(state, statePath, credentials, opts) {
             }
         }
     }
-    // Build adapters
-    const adapters = [];
-    for (const slug of state.configuredAgents) {
-        const adapter = getAdapterBySlug(slug);
-        if (adapter)
-            adapters.push(adapter);
-    }
     const scopes = state.scope === 'both' ? ['project', 'user'] : [state.scope];
     if (adapters.length > 0) {
         console.log(`  Syncing to: ${adapters.map(a => a.name).join(', ')}`);
@@ -193,6 +214,7 @@ export async function syncFromState(state, statePath, credentials, opts) {
         workspaceId: state.workspaceId,
         adapters,
         scopes,
+        hasMcp: mcpEntries.length > 0,
     });
     // Write intro skill, MCP configs, instruction hints (pull-only)
     const introSkill = generateIntroSkill({
@@ -230,9 +252,16 @@ export async function syncFromState(state, statePath, credentials, opts) {
     for (const adapter of adapters) {
         for (const scope of scopes) {
             try {
-                // Write skills: for project scope, filter to only the current app's skill
+                // Write skills: for project scope, filter to only the current app's skill.
+                // When MCP servers are configured for this adapter, skip app-sourced skills
+                // since the MCP server already exposes them as skill_* tools. Writing both
+                // causes duplicate entries in the agent's skill listing.
                 if (adapter.supportsSkills()) {
+                    const skipAppSkills = adapter.mcpProvidesSkills && mcpEntries.length > 0;
                     const scopeSkills = remoteSkills.filter(s => {
+                        // App-sourced skills are already available via MCP skill_* tools
+                        if (skipAppSkills && s.source === 'app')
+                            return false;
                         if (scope === 'project' && s.source === 'app' && projectAppSkillFilter) {
                             const filename = s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
                             return filename === projectAppSkillFilter;
@@ -243,7 +272,9 @@ export async function syncFromState(state, statePath, credentials, opts) {
                             name: s.name,
                             filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
                             content: s.content,
-                            description: buildAppSkillDescription(s.name, registries) || `${s.name} skill`,
+                            description: s.source === 'app'
+                                ? (buildAppSkillDescription(s.name, registries) || `${s.name} - Runwork workspace application`)
+                                : `${s.name} - Runwork workspace skill`,
                         }))];
                     await adapter.writeSkills(allSkillFiles, scope);
                 }
@@ -316,10 +347,33 @@ export async function syncFromState(state, statePath, credentials, opts) {
     catch {
         // Team config pull is non-fatal
     }
+    // Ensure sandbox network access for agents that run in sandboxed environments (e.g. Cursor)
+    const networkDomains = ['runwork.ai', '*.runwork.ai'];
+    try {
+        const baseHost = new URL(baseUrl).hostname;
+        if (baseHost !== 'runwork.ai' && !baseHost.endsWith('.runwork.ai')) {
+            networkDomains.push(baseHost, `*.${baseHost}`);
+        }
+    }
+    catch { /* use defaults */ }
+    for (const adapter of adapters) {
+        if (!adapter.writeAgentConfig)
+            continue;
+        try {
+            await adapter.writeAgentConfig({ networkAllowlist: networkDomains }, 'user');
+        }
+        catch {
+            // Best-effort
+        }
+    }
     // Update state
     state.lastSyncAt = new Date().toISOString();
     state.mcpServers = mcpEntries.map(e => e.name);
     state.skills = remoteSkills.map(s => s.name);
+    state.skillFilenames = [
+        'runwork', // intro skill is always synced
+        ...remoteSkills.map(s => s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-')),
+    ];
     // Merge hashes: keep existing for skips, update for everything else
     const mergedHashes = { ...(state.skillHashes || {}) };
     for (const [name, hash] of Object.entries(newHashes)) {
@@ -333,112 +387,22 @@ export async function syncFromState(state, statePath, credentials, opts) {
     writeFileSync(statePath, JSON.stringify(state, null, 2));
     // Report telemetry (non-fatal)
     try {
-        const now = new Date().toISOString();
-        const previouslyReported = new Set(state.reportedAgentSlugs ?? []);
-        const telemetryEvents = [];
-        // Only report newly detected agents (not already reported in previous syncs)
-        const newAgents = [];
-        for (const slug of state.configuredAgents) {
-            if (!previouslyReported.has(slug)) {
-                telemetryEvents.push({
-                    eventType: 'local_agent.detected',
-                    agentSlug: slug,
-                    metadata: { installed: true },
-                    timestamp: now,
-                });
-                newAgents.push(slug);
-            }
-        }
-        // Collect passive usage stats from each agent
-        for (const adapter of adapters) {
-            try {
-                const stats = await adapter.readUsageStats?.(state.lastSyncAt ?? null);
-                if (stats && stats.hasNewActivity) {
-                    telemetryEvents.push({
-                        eventType: 'local_agent.usage',
-                        agentSlug: adapter.slug,
-                        metadata: {
-                            sessionCount: stats.sessionCount,
-                            messageCount: stats.messageCount,
-                            toolCallCount: stats.toolCallCount,
-                            tokensUsed: stats.tokensUsed,
-                            aiLinesAdded: stats.aiLinesAdded,
-                            aiLinesRemoved: stats.aiLinesRemoved,
-                            lastActiveAt: stats.lastActiveAt,
-                            modelsUsed: stats.modelsUsed,
-                            mcpToolCount: stats.mcpToolCount,
-                            ...stats.extra,
-                        },
-                        timestamp: now,
-                    });
-                }
-            }
-            catch {
-                // Usage stats collection is best-effort
-            }
-        }
-        // Collect skill usage stats
-        for (const adapter of adapters) {
-            try {
-                const skillUsage = await adapter.readSkillUsage?.(state.lastSyncAt ?? null);
-                if (skillUsage && skillUsage.length > 0) {
-                    for (const entry of skillUsage) {
-                        telemetryEvents.push({
-                            eventType: 'local_agent.skill_used',
-                            agentSlug: adapter.slug,
-                            metadata: {
-                                skillName: entry.skillName,
-                                count: entry.count,
-                                lastUsedAt: entry.lastUsedAt,
-                            },
-                            timestamp: now,
-                        });
-                    }
-                }
-            }
-            catch {
-                // Skill usage collection is best-effort
-            }
-        }
-        // Report agent health once per day (version, platform)
-        const lastHealthReport = state.lastHealthReportAt ? new Date(state.lastHealthReportAt) : null;
-        const shouldReportHealth = !lastHealthReport ||
-            (Date.now() - lastHealthReport.getTime()) > 24 * 60 * 60 * 1000;
-        if (shouldReportHealth) {
-            for (const adapter of adapters) {
-                try {
-                    const version = await adapter.readVersion?.();
-                    telemetryEvents.push({
-                        eventType: 'local_agent.health',
-                        agentSlug: adapter.slug,
-                        metadata: {
-                            version,
-                            installed: true,
-                            platform: process.platform,
-                            arch: process.arch,
-                        },
-                        timestamp: now,
-                    });
-                }
-                catch {
-                    // Health reporting is best-effort
-                }
-            }
-            state.lastHealthReportAt = now;
-        }
-        telemetryEvents.push({
-            eventType: 'local_agent.sync_completed',
-            metadata: {
-                syncedSkills: remoteSkills.length,
-                syncedMcpServers: mcpEntries.length,
-                teamInstructionsApplied,
-                agentConfigsApplied,
-            },
-            timestamp: now,
+        const telemetry = await collectTelemetryEvents({
+            adapters,
+            state,
+            syncedSkillsCount: remoteSkills.length,
+            syncedMcpServersCount: mcpEntries.length,
+            teamInstructionsApplied,
+            agentConfigsApplied,
         });
-        await client.reportTelemetry(state.workspaceId, telemetryEvents);
-        // Track which agents have been reported so we don't spam on future syncs
-        state.reportedAgentSlugs = [...new Set([...previouslyReported, ...newAgents])];
+        if (opts.verbose)
+            printTelemetryVerbose(telemetry);
+        await client.reportTelemetry(state.workspaceId, telemetry.events);
+        if (telemetry.healthReported)
+            state.lastHealthReportAt = new Date().toISOString();
+        state.reportedAgentSlugs = [
+            ...new Set([...(state.reportedAgentSlugs ?? []), ...telemetry.newlyReportedAgents]),
+        ];
         writeFileSync(statePath, JSON.stringify(state, null, 2));
     }
     catch {
@@ -447,7 +411,8 @@ export async function syncFromState(state, statePath, credentials, opts) {
 }
 export const syncCommand = new Command('sync')
     .description('Sync skills bidirectionally and refresh MCP configs from workspace')
-    .option('--dry-run', 'Show what would change without doing anything')
+    .option('--dry-run', 'Show what would change without doing anything (includes telemetry preview)')
+    .option('-v, --verbose', 'Print per-adapter stats and the telemetry envelope')
     .option('--pull-only', 'Only pull remote changes, never push local edits')
     .option('--prefer <side>', 'Auto-resolve conflicts: "local" or "remote" (implies --yes)')
     .option('-y, --yes', 'Non-interactive mode (default: prefer remote for conflicts)')
@@ -458,6 +423,7 @@ export const syncCommand = new Command('sync')
         pullOnly: !!opts.pullOnly,
         yes: !!opts.yes || !!opts.prefer,
         prefer: opts.prefer,
+        verbose: !!opts.verbose,
     };
     const projectStatePath = join(process.cwd(), '.runwork', 'setup.json');
     const userStatePath = join(homedir(), '.runwork', 'setup.json');

package/dist/commands/uninstall.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const uninstallCommand: Command;

package/dist/commands/uninstall.js

@@ -0,0 +1,145 @@
+import { Command } from 'commander';
+import { existsSync, readFileSync, rmSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getAdapterBySlug } from '../agents/detect.js';
+import { promptConfirm } from '../utils/prompt.js';
+function loadSetupState(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export const uninstallCommand = new Command('uninstall')
+    .description('Remove all Runwork configuration from local agents (MCP servers, skills, instructions)')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--keep-auth', 'Keep authentication credentials (only remove agent configs)')
+    .action(async (opts) => {
+    const projectStatePath = join(process.cwd(), '.runwork', 'setup.json');
+    const userStatePath = join(homedir(), '.runwork', 'setup.json');
+    const projectState = loadSetupState(projectStatePath);
+    const userState = loadSetupState(userStatePath);
+    if (!projectState && !userState) {
+        console.error('No setup state found. Nothing to uninstall.');
+        process.exit(0);
+    }
+    // Collect all configured agents across both scopes
+    const agentSlugs = new Set();
+    if (projectState) {
+        for (const slug of projectState.configuredAgents)
+            agentSlugs.add(slug);
+    }
+    if (userState) {
+        for (const slug of userState.configuredAgents)
+            agentSlugs.add(slug);
+    }
+    console.log('\nThis will remove all Runwork configuration from your local agents:\n');
+    if (agentSlugs.size > 0) {
+        console.log('  Agents to clean:');
+        for (const slug of agentSlugs) {
+            const adapter = getAdapterBySlug(slug);
+            console.log(`    - ${adapter?.name ?? slug}`);
+        }
+    }
+    console.log('\n  What will be removed:');
+    console.log('    - MCP server registrations');
+    console.log('    - Synced skills and instruction hints');
+    console.log('    - Team instructions');
+    console.log('    - Agent config overrides (model, permissions)');
+    console.log('    - Plugin registrations (Claude Code, Claude Desktop)');
+    if (opts.keepAuth) {
+        console.log('    - Setup state (keeping auth credentials)');
+    }
+    else {
+        console.log('    - Setup state and auth credentials (~/.runwork/)');
+    }
+    console.log('');
+    if (!opts.yes) {
+        const confirmed = await promptConfirm('Proceed with uninstall?');
+        if (!confirmed) {
+            console.log('Cancelled.');
+            return;
+        }
+    }
+    let cleanedAgents = 0;
+    let errors = 0;
+    // Process each setup state (project and/or user)
+    const entries = [];
+    if (projectState)
+        entries.push({ state: projectState, statePath: projectStatePath, label: 'project' });
+    if (userState)
+        entries.push({ state: userState, statePath: userStatePath, label: 'user' });
+    for (const { state, label } of entries) {
+        const scopes = state.scope === 'both'
+            ? ['project', 'user']
+            : [state.scope];
+        // Build manifest from sync state so adapters only remove what we synced
+        const manifest = {
+            skillFilenames: state.skillFilenames ?? state.skills.map(s => s.toLowerCase().replace(/[^a-z0-9]+/g, '-')),
+            mcpServerNames: state.mcpServers ?? [],
+        };
+        for (const slug of state.configuredAgents) {
+            const adapter = getAdapterBySlug(slug);
+            if (!adapter) {
+                console.warn(`  [${slug}] Adapter not found, skipping.`);
+                continue;
+            }
+            for (const scope of scopes) {
+                try {
+                    if (adapter.cleanup) {
+                        await adapter.cleanup(scope, manifest);
+                        console.log(`  [${adapter.name}] Cleaned up (${scope})`);
+                        cleanedAgents++;
+                    }
+                    else {
+                        console.log(`  [${adapter.name}] No cleanup handler, skipping (${scope})`);
+                    }
+                }
+                catch (err) {
+                    console.warn(`  [${adapter.name}] Cleanup failed (${scope}): ${err instanceof Error ? err.message : err}`);
+                    errors++;
+                }
+            }
+        }
+        // Remove setup state
+        const stateDir = label === 'project'
+            ? join(process.cwd(), '.runwork')
+            : join(homedir(), '.runwork');
+        if (opts.keepAuth && label === 'user') {
+            // Only remove setup.json, keep credentials and other files
+            const setupFile = join(stateDir, 'setup.json');
+            if (existsSync(setupFile)) {
+                try {
+                    unlinkSync(setupFile);
+                    console.log(`  Removed ${setupFile} (kept credentials)`);
+                }
+                catch (err) {
+                    console.warn(`  Failed to remove ${setupFile}: ${err instanceof Error ? err.message : err}`);
+                    errors++;
+                }
+            }
+        }
+        else if (existsSync(stateDir)) {
+            try {
+                rmSync(stateDir, { recursive: true, force: true });
+                console.log(`  Removed ${stateDir}`);
+            }
+            catch (err) {
+                console.warn(`  Failed to remove ${stateDir}: ${err instanceof Error ? err.message : err}`);
+                errors++;
+            }
+        }
+    }
+    console.log('');
+    if (errors > 0) {
+        console.log(`Uninstall completed with ${errors} warning${errors > 1 ? 's' : ''}. ${cleanedAgents} agent${cleanedAgents > 1 ? 's' : ''} cleaned.`);
+    }
+    else {
+        console.log(`Uninstall complete. ${cleanedAgents} agent${cleanedAgents > 1 ? 's' : ''} cleaned.`);
+    }
+    console.log('Run `runwork setup` to reconfigure at any time.');
+});

package/dist/commands/upgrade.d.ts

@@ -1,2 +1,14 @@
 import { Command } from 'commander';
+declare function fetchLatestVersion(): Promise<string | null>;
+type InstallMethod = 'brew' | 'npm' | 'bun' | 'pnpm' | 'yarn' | 'volta' | 'binary';
+declare function detectInstallMethod(): InstallMethod;
 export declare const upgradeCommand: Command;
+export declare const __internal: {
+    BASE_URL: string;
+    LATEST_JSON_URL: string;
+    INSTALL_SH_URL: string;
+    INSTALL_PS1_URL: string;
+    fetchLatestVersion: typeof fetchLatestVersion;
+    detectInstallMethod: typeof detectInstallMethod;
+};
+export {};

package/dist/commands/upgrade.js

@@ -1,15 +1,20 @@
 import { Command } from 'commander';
 import { execFileSync } from 'child_process';
+import { platform as osPlatform, tmpdir } from 'os';
+import { mkdtempSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
 import { VERSION } from '../generated/version.js';
-const GITHUB_REPO = 'runwork-ai/cli';
-const INSTALL_SCRIPT_URL = 'https://runwork.ai/install.sh';
+const BASE_URL = 'https://runwork.ai';
+const LATEST_JSON_URL = `${BASE_URL}/cli/latest.json`;
+const INSTALL_SH_URL = `${BASE_URL}/install.sh`;
+const INSTALL_PS1_URL = `${BASE_URL}/install.ps1`;
 async function fetchLatestVersion() {
     try {
-        const response = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`);
+        const response = await fetch(LATEST_JSON_URL, { cache: 'no-store' });
         if (!response.ok)
             return null;
         const data = await response.json();
-        return data.tag_name?.replace(/^v/, '') || null;
+        return data.version?.replace(/^v/, '') || null;
     }
     catch {
         return null;
@@ -48,6 +53,44 @@ function detectInstallMethod() {
     }
     return 'binary';
 }
+async function upgradeBinary() {
+    const isWindows = osPlatform() === 'win32';
+    if (isWindows) {
+        console.log('\nUpgrading via PowerShell installer...\n');
+        const response = await fetch(INSTALL_PS1_URL, { cache: 'no-store' });
+        if (!response.ok) {
+            throw new Error(`Failed to download install.ps1: HTTP ${response.status}`);
+        }
+        const script = await response.text();
+        // Write the script to a temp file and invoke it with `-File`. This is more
+        // robust than `-Command` because it avoids PowerShell's quoting rules for
+        // multi-line strings with embedded single or double quotes.
+        const tmpDir = mkdtempSync(join(tmpdir(), 'runwork-upgrade-'));
+        const scriptPath = join(tmpDir, 'install.ps1');
+        try {
+            writeFileSync(scriptPath, script);
+            execFileSync('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', scriptPath], { stdio: 'inherit' });
+        }
+        finally {
+            try {
+                rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+        }
+        console.log('\nUpgraded successfully.');
+        return;
+    }
+    console.log('\nUpgrading via install.sh...\n');
+    const response = await fetch(INSTALL_SH_URL, { cache: 'no-store' });
+    if (!response.ok) {
+        throw new Error(`Failed to download install.sh: HTTP ${response.status}`);
+    }
+    const script = await response.text();
+    execFileSync('sh', ['-s'], { input: script, stdio: ['pipe', 'inherit', 'inherit'] });
+    console.log('\nUpgraded successfully.');
+}
 export const upgradeCommand = new Command('upgrade')
     .description('Upgrade Runwork CLI to the latest version')
     .option('--check', 'Check for updates without installing')
@@ -55,7 +98,8 @@ export const upgradeCommand = new Command('upgrade')
     console.log(`Current version: ${VERSION}`);
     const latest = await fetchLatestVersion();
     if (!latest) {
-        console.error('Could not fetch latest version. Check your internet connection.');
+        console.error(`Could not fetch latest version from ${LATEST_JSON_URL}.`);
+        console.error('Check your network and that runwork.ai is reachable.');
         process.exit(1);
     }
     if (latest === VERSION) {
@@ -147,19 +191,26 @@ export const upgradeCommand = new Command('upgrade')
         }
         return;
     }
-    // Binary install: download install script and pipe to sh
-    console.log('\nUpgrading via install script...\n');
+    // Binary install: first-party runwork.ai installer.
     try {
-        const response = await fetch(INSTALL_SCRIPT_URL);
-        if (!response.ok) {
-            throw new Error(`Failed to download install script: ${response.status}`);
-        }
-        const script = await response.text();
-        execFileSync('sh', ['-c', script], { stdio: 'inherit' });
-        console.log('\nUpgraded successfully.');
+        await upgradeBinary();
     }
-    catch (error) {
-        console.error(`\nUpgrade failed. Try manually: curl -fsSL ${INSTALL_SCRIPT_URL} | sh`);
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`\nUpgrade failed: ${message}`);
+        const manualCmd = osPlatform() === 'win32'
+            ? `irm ${INSTALL_PS1_URL} | iex`
+            : `curl -fsSL ${INSTALL_SH_URL} | sh`;
+        console.error(`Try manually: ${manualCmd}`);
         process.exit(1);
     }
 });
+// Exported for tests
+export const __internal = {
+    BASE_URL,
+    LATEST_JSON_URL,
+    INSTALL_SH_URL,
+    INSTALL_PS1_URL,
+    fetchLatestVersion,
+    detectInstallMethod,
+};