runwork 0.5.0 → 0.6.0

package/dist/commands/sync.js

@@ -6,6 +6,11 @@ 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 { generateIntroSkill, generateInstructionHint, buildAppSkillDescription } from '../agents/intro-skill.js';
+import { computeSyncPlan } from '../sync/change-detect.js';
+import { printSyncSummary, resolveConflict, resolveConflictNonInteractive } from '../sync/conflict-ui.js';
+import { executeSyncPlan } from '../sync/executor.js';
+import { getRegistryAgent, resolveToAbsolute } from '../agents/registry.js';
 function loadSetupState(filePath) {
     if (!existsSync(filePath))
         return null;
@@ -16,115 +21,444 @@ function loadSetupState(filePath) {
         return null;
     }
 }
-async function syncFromState(state, statePath, credentials, dryRun) {
+/**
+ * Read local skill content from the first configured agent's skill directory.
+ */
+function readLocalSkills(state) {
+    const results = [];
+    if (!state.skills || state.skills.length === 0)
+        return results;
+    for (const slug of state.configuredAgents) {
+        const def = getRegistryAgent(slug);
+        if (!def?.skillsPaths)
+            continue;
+        const useScope = state.scope === 'both' ? 'user' : state.scope;
+        const pathTemplate = useScope === 'project' ? def.skillsPaths.project : def.skillsPaths.global;
+        if (!pathTemplate)
+            continue;
+        const baseDir = resolveToAbsolute(pathTemplate, useScope === 'project' ? 'project' : 'global');
+        if (!baseDir)
+            continue;
+        for (const skillName of state.skills) {
+            // Try SKILL.md in subdirectory
+            const skillMdPath = join(baseDir, skillName, 'SKILL.md');
+            if (existsSync(skillMdPath)) {
+                results.push({ name: skillName, content: readFileSync(skillMdPath, 'utf-8') });
+                continue;
+            }
+            // Try flat file
+            const filename = skillName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+            const flatPath = join(baseDir, `${filename}.md`);
+            if (existsSync(flatPath)) {
+                results.push({ name: skillName, content: readFileSync(flatPath, 'utf-8') });
+            }
+        }
+        if (results.length > 0)
+            break;
+    }
+    return results;
+}
+export async function syncFromState(state, statePath, credentials, opts) {
     const client = new ApiClient(credentials);
+    // Refresh workspace name/slug if missing or stale (e.g. setup ran before name was set)
+    if (!state.workspaceName || state.workspaceName === state.workspaceId || !state.workspaceSlug) {
+        try {
+            const workspaces = await client.listWorkspaces();
+            const ws = workspaces.find(w => w.id === state.workspaceId);
+            if (ws?.name)
+                state.workspaceName = ws.name;
+            if (ws?.slug)
+                state.workspaceSlug = ws.slug;
+        }
+        catch {
+            // Best-effort, keep existing values
+        }
+    }
     console.log(`Syncing workspace: ${state.workspaceName || state.workspaceId}`);
-    // Fetch latest data
-    const [allSkills, mcpServers, externalSkills] = await Promise.all([
-        client.listWorkspaceSkills(state.workspaceId),
+    console.log('  Fetching workspace data...');
+    // Fetch latest data (includeContent=true gets all skill content in one request)
+    const [allSkills, mcpServers, externalSkills, registries, connectedIntegrations] = await Promise.all([
+        client.listWorkspaceSkills(state.workspaceId, true),
         client.listMcpServers(state.workspaceId),
         client.listExternalSkills(state.workspaceId),
+        client.getWorkspaceAll(state.workspaceId).catch(() => null),
+        client.listConnectedIntegrations(state.workspaceId)
+            .then(list => list.map(i => i.canonicalId ?? i.integrationId))
+            .catch(() => []),
     ]);
-    // Build entries
-    const wsPrefix = state.workspaceId.substring(0, 8);
+    const appCount = allSkills.filter(s => s.type === 'app').length;
+    const parts = [];
+    if (appCount > 0)
+        parts.push(`${appCount} app${appCount > 1 ? 's' : ''}`);
+    if (externalSkills.length > 0)
+        parts.push(`${externalSkills.length} skill${externalSkills.length > 1 ? 's' : ''}`);
+    if (mcpServers.length > 0)
+        parts.push(`${mcpServers.filter(s => s.enabled).length} MCP server${mcpServers.filter(s => s.enabled).length > 1 ? 's' : ''}`);
+    if (connectedIntegrations.length > 0)
+        parts.push(`${connectedIntegrations.length} integration${connectedIntegrations.length > 1 ? 's' : ''}`);
+    if (registries) {
+        if (registries.entities.length > 0)
+            parts.push(`${registries.entities.length} entit${registries.entities.length > 1 ? 'ies' : 'y'}`);
+        if (registries.workflows.length > 0)
+            parts.push(`${registries.workflows.length} workflow${registries.workflows.length > 1 ? 's' : ''}`);
+        if (registries.agents.length > 0)
+            parts.push(`${registries.agents.length} agent${registries.agents.length > 1 ? 's' : ''}`);
+    }
+    if (parts.length > 0) {
+        console.log(`  Found: ${parts.join(', ')}`);
+    }
+    // Build MCP entries (pull-only)
     const baseUrl = credentials.baseUrl || 'https://runwork.ai';
     const mcpEntries = mcpServers
         .filter(s => s.enabled)
         .map(s => ({
-        name: `${RUNWORK_MCP_PREFIX}${wsPrefix}-${s.name}`,
+        name: `${RUNWORK_MCP_PREFIX}${s.name}`,
         url: s.url,
         transport: s.transport,
         headers: { Authorization: `Bearer ${credentials.apiKey}` },
+        description: `Runwork MCP server: ${s.name}. Provides tools for interacting with this workspace resource.`,
     }));
     mcpEntries.push({
-        name: `${RUNWORK_MCP_PREFIX}${wsPrefix}-workspace`,
+        name: `${RUNWORK_MCP_PREFIX}Workspace Tools`,
         url: `${baseUrl}/api/workspaces/${state.workspaceId}/mcp`,
         transport: 'streamable-http',
         headers: { Authorization: `Bearer ${credentials.apiKey}` },
+        description: 'Runwork workspace tools: query entities, trigger workflows, manage integrations, run agents, and access shared data across your team\'s apps.',
     });
-    const baseSkillFiles = externalSkills.map(s => ({
-        name: s.name,
-        filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
-        content: s.content,
-        description: s.description,
-    }));
-    // Fetch all app skills in parallel
-    const allAppSkillFiles = [];
-    const appSkillEntries = allSkills.filter(s => s.type === 'app' && s.appId);
-    const appSkillResults = await Promise.all(appSkillEntries.map(async (s) => {
-        try {
-            const content = await client.getAppSkillContent(state.workspaceId, s.appId);
-            if (content && content.trim()) {
-                return {
-                    name: s.name,
-                    filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
-                    content,
-                    description: s.description || `App skill for ${s.name}`,
-                };
+    // Build remote skills list
+    const remoteSkills = [];
+    for (const s of externalSkills) {
+        remoteSkills.push({ name: s.name, content: s.content, source: 'external', remoteId: s.id });
+    }
+    for (const s of allSkills) {
+        if (s.type === 'app' && s.appId && s.content?.trim()) {
+            remoteSkills.push({ name: s.name, content: s.content, source: 'app', appId: s.appId });
+        }
+    }
+    // Read local skills for change detection
+    const localSkills = readLocalSkills(state);
+    // Compute sync plan
+    const plan = computeSyncPlan({
+        storedHashes: state.skillHashes || {},
+        localSkills,
+        remoteSkills,
+    });
+    // In pull-only mode, move pushes and conflicts to skips
+    if (opts.pullOnly) {
+        plan.skips.push(...plan.pushes.map(p => ({ ...p, action: 'skip' })));
+        plan.pushes = [];
+        plan.skips.push(...plan.conflicts.map(c => ({ ...c, action: 'skip' })));
+        plan.conflicts = [];
+    }
+    // Display summary
+    const hasChanges = plan.pulls.length > 0 || plan.pushes.length > 0 || plan.conflicts.length > 0 || plan.deletions.length > 0;
+    if (hasChanges) {
+        printSyncSummary(plan);
+    }
+    else {
+        console.log('  All skills up to date.');
+    }
+    if (opts.dryRun)
+        return;
+    // Resolve conflicts
+    const resolvedConflicts = new Map();
+    for (const conflict of plan.conflicts) {
+        if (opts.yes || !process.stdout.isTTY) {
+            const nonInteractiveResolution = resolveConflictNonInteractive(opts.prefer || 'remote');
+            if (nonInteractiveResolution !== 'skip') {
+                resolvedConflicts.set(conflict.name, nonInteractiveResolution);
+            }
+        }
+        else {
+            const resolution = await resolveConflict(conflict);
+            if (resolution !== 'skip') {
+                resolvedConflicts.set(conflict.name, resolution);
             }
         }
-        catch { /* skip */ }
-        return null;
-    }));
-    for (const r of appSkillResults) {
-        if (r)
-            allAppSkillFiles.push(r);
     }
-    // Project scope: only current app's skill; User scope: all app skills
-    let projectAppSkillFile = null;
+    // 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(', ')}`);
+    }
+    // Execute skill sync plan
+    const newHashes = await executeSyncPlan(plan, resolvedConflicts, {
+        client,
+        workspaceId: state.workspaceId,
+        adapters,
+        scopes,
+    });
+    // Write intro skill, MCP configs, instruction hints (pull-only)
+    const introSkill = generateIntroSkill({
+        workspaceName: state.workspaceName || state.workspaceId,
+        workspaceId: state.workspaceId,
+        workspaceSlug: state.workspaceSlug,
+        registries,
+        connectedIntegrations,
+        mcpServerCount: mcpEntries.length,
+        skillCount: remoteSkills.length,
+        mcpServerNames: mcpEntries.map(e => e.name.replace(RUNWORK_MCP_PREFIX, '')),
+        skillNames: remoteSkills.map(s => s.name),
+    });
+    const instructionHint = generateInstructionHint({
+        workspaceName: state.workspaceName || state.workspaceId,
+        workspaceId: state.workspaceId,
+        workspaceSlug: state.workspaceSlug,
+        registries,
+        connectedIntegrations,
+        appCount: allSkills.filter(s => s.type === 'app').length,
+        skillCount: remoteSkills.length,
+        mcpServerCount: mcpEntries.length,
+    });
+    // For project scope: determine which app skill to include (only current app's skill)
+    let projectAppSkillFilter = null;
     if (existsSync('.runwork.json')) {
         try {
             const config = JSON.parse(readFileSync('.runwork.json', 'utf-8'));
             if (config.appName) {
-                const fname = config.appName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
-                projectAppSkillFile = allAppSkillFiles.find(s => s.filename === fname) || null;
+                projectAppSkillFilter = config.appName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
             }
         }
         catch { /* ignore */ }
     }
-    const userSkillFiles = [...baseSkillFiles, ...allAppSkillFiles];
-    const projectSkillFiles = projectAppSkillFile
-        ? [...baseSkillFiles, projectAppSkillFile]
-        : [...baseSkillFiles];
-    if (dryRun) {
-        console.log(`  Would update: ${mcpEntries.length} MCP servers, ${userSkillFiles.length} skills (user), ${projectSkillFiles.length} skills (project)`);
-        console.log(`  Agents: ${state.configuredAgents.join(', ')}`);
-        return;
-    }
-    // Write to configured agents
-    const scopes = state.scope === 'both' ? ['project', 'user'] : [state.scope];
-    for (const slug of state.configuredAgents) {
-        const adapter = getAdapterBySlug(slug);
-        if (!adapter)
-            continue;
+    for (const adapter of adapters) {
         for (const scope of scopes) {
-            const skillFiles = scope === 'project' ? projectSkillFiles : userSkillFiles;
             try {
+                // Write skills: for project scope, filter to only the current app's skill
+                if (adapter.supportsSkills()) {
+                    const scopeSkills = remoteSkills.filter(s => {
+                        if (scope === 'project' && s.source === 'app' && projectAppSkillFilter) {
+                            const filename = s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+                            return filename === projectAppSkillFilter;
+                        }
+                        return true;
+                    });
+                    const allSkillFiles = [introSkill, ...scopeSkills.map(s => ({
+                            name: s.name,
+                            filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
+                            content: s.content,
+                            description: buildAppSkillDescription(s.name, registries) || `${s.name} skill`,
+                        }))];
+                    await adapter.writeSkills(allSkillFiles, scope);
+                }
+                // Write MCP configs
                 if (adapter.supportsMcpScope(scope) && mcpEntries.length > 0) {
                     await adapter.writeMcpServers(mcpEntries, scope);
+                    console.log(`  [${adapter.name}] Updated ${mcpEntries.length} MCP server${mcpEntries.length > 1 ? 's' : ''} (${scope})`);
                 }
-                if (adapter.supportsSkills() && skillFiles.length > 0) {
-                    await adapter.writeSkills(skillFiles, scope);
-                }
+                // Write instruction hint
+                await adapter.writeInstructionHint(instructionHint, scope);
+                console.log(`  [${adapter.name}] Updated instruction hints (${scope})`);
             }
             catch (err) {
                 console.warn(`  [${adapter.name}] Failed (${scope}): ${err instanceof Error ? err.message : err}`);
             }
         }
-        console.log(`  [${adapter.name}] Updated`);
+    }
+    // Pull and apply team instructions from onboarding config (non-fatal)
+    let teamInstructionsApplied = false;
+    let agentConfigsApplied = 0;
+    try {
+        const onboardingConfig = await client.getOnboardingConfig(state.workspaceId);
+        const teamInstructions = onboardingConfig?.config?.teamInstructions;
+        const agentConfigs = onboardingConfig?.config?.agentConfigs;
+        // Write team instructions and/or per-agent extra instructions.
+        // Either or both may be present independently.
+        for (const adapter of adapters) {
+            if (!adapter.writeTeamInstructions)
+                continue;
+            const agentExtra = agentConfigs?.[adapter.slug]?.extraInstructions;
+            const parts = [teamInstructions, agentExtra].filter(Boolean);
+            if (parts.length === 0)
+                continue;
+            const fullInstructions = parts.join('\n\n');
+            for (const scope of scopes) {
+                try {
+                    await adapter.writeTeamInstructions(fullInstructions, scope);
+                    teamInstructionsApplied = true;
+                    console.log(`  [${adapter.name}] Updated team instructions (${scope})`);
+                }
+                catch {
+                    // Best-effort per adapter/scope
+                }
+            }
+        }
+        // Apply per-agent config overrides (model preferences, permissions)
+        if (agentConfigs) {
+            for (const adapter of adapters) {
+                const agentConfig = agentConfigs[adapter.slug];
+                if (!agentConfig || !adapter.writeAgentConfig)
+                    continue;
+                // Only apply model/permission config (extraInstructions already handled above)
+                const { extraInstructions: _, ...configWithoutInstructions } = agentConfig;
+                if (Object.keys(configWithoutInstructions).length === 0)
+                    continue;
+                for (const scope of scopes) {
+                    try {
+                        await adapter.writeAgentConfig(configWithoutInstructions, scope);
+                        agentConfigsApplied++;
+                        const configKeys = Object.keys(configWithoutInstructions).join(', ');
+                        console.log(`  [${adapter.name}] Updated agent config: ${configKeys} (${scope})`);
+                    }
+                    catch {
+                        // Best-effort per adapter/scope
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Team config pull is non-fatal
     }
     // Update state
     state.lastSyncAt = new Date().toISOString();
     state.mcpServers = mcpEntries.map(e => e.name);
-    state.skills = userSkillFiles.map(s => s.name);
+    state.skills = remoteSkills.map(s => s.name);
+    // Merge hashes: keep existing for skips, update for everything else
+    const mergedHashes = { ...(state.skillHashes || {}) };
+    for (const [name, hash] of Object.entries(newHashes)) {
+        mergedHashes[name] = hash;
+    }
+    // Remove deleted skills
+    for (const del of plan.deletions) {
+        delete mergedHashes[del.name];
+    }
+    state.skillHashes = mergedHashes;
     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,
+        });
+        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])];
+        writeFileSync(statePath, JSON.stringify(state, null, 2));
+    }
+    catch {
+        // Telemetry failures are non-fatal
+    }
 }
 export const syncCommand = new Command('sync')
-    .description('Refresh local agent configs with latest workspace skills and MCP servers')
-    .option('--dry-run', 'Show what would change without writing files')
+    .description('Sync skills bidirectionally and refresh MCP configs from workspace')
+    .option('--dry-run', 'Show what would change without doing anything')
+    .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)')
     .action(async (opts) => {
     const credentials = requireAuth();
-    const dryRun = !!opts.dryRun;
+    const syncOpts = {
+        dryRun: !!opts.dryRun,
+        pullOnly: !!opts.pullOnly,
+        yes: !!opts.yes || !!opts.prefer,
+        prefer: opts.prefer,
+    };
     const projectStatePath = join(process.cwd(), '.runwork', 'setup.json');
     const userStatePath = join(homedir(), '.runwork', 'setup.json');
     const projectState = loadSetupState(projectStatePath);
@@ -133,14 +467,13 @@ export const syncCommand = new Command('sync')
         console.error('No setup state found. Run `runwork setup` first.');
         process.exit(1);
     }
-    // Sync both states independently — even if same workspace, they may target different scopes/agents
     if (projectState) {
-        await syncFromState(projectState, projectStatePath, credentials, dryRun);
+        await syncFromState(projectState, projectStatePath, credentials, syncOpts);
     }
     if (userState) {
-        await syncFromState(userState, userStatePath, credentials, dryRun);
+        await syncFromState(userState, userStatePath, credentials, syncOpts);
     }
-    if (!dryRun) {
+    if (!syncOpts.dryRun) {
         console.log('\nSync complete.');
     }
 });

package/dist/commands/welcome.js

@@ -1,3 +1,4 @@
+import { basename } from 'path';
 import { getCredentials } from '../auth/store.js';
 import { performLogin } from '../auth/login-flow.js';
 import { ApiClient } from '../api/client.js';
@@ -50,7 +51,8 @@ export async function runWelcomeWizard() {
         console.log('');
         console.log(`Creating ${cyan(appName)} in workspace ${cyan(workspace.name)}...`);
         const { execInit } = await import('./init.js');
-        appDir = await execInit(client, appName, workspace);
+        const initResult = await execInit(client, appName, workspace);
+        appDir = initResult.directory;
     }
     else {
         const apps = await client.listApps();
@@ -60,7 +62,8 @@ export async function runWelcomeWizard() {
         }
         const choice = await promptSelect('Select app to clone:', apps.map(a => ({ label: `${a.name} (${a.workspaceName})`, value: a })));
         const { execClone } = await import('./clone.js');
-        appDir = await execClone(client, choice.value);
+        const cloneResult = await execClone(client, choice.value);
+        appDir = cloneResult.directory;
     }
     // Step 4: Agent guidance
     await runAgentWizard(appDir);
@@ -76,7 +79,7 @@ export async function runWelcomeWizard() {
         await execDev();
     }
     else {
-        const slug = appDir.split('/').pop() || appDir;
+        const slug = basename(appDir) || appDir;
         console.log('');
         console.log(`Next: ${cyan(`cd ${slug} && runwork dev`)}`);
     }

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.5.0";
+export declare const VERSION = "0.6.0";

package/dist/generated/version.js

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

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

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