runwork 0.10.4 → 0.12.0

package/dist/commands/sync.js

@@ -7,6 +7,8 @@ import { ApiClient } from '../api/client.js';
 import { getAdapterBySlug, detectAgents } from '../agents/detect.js';
 import { CodexAdapter } from '../agents/codex.js';
 import { RUNWORK_MCP_PREFIX, RUNWORK_WORKSPACE_MCP_NAME } from '../agents/types.js';
+import { RUNWORK_AGENT_DEFAULTS, AGENT_DEFAULTS_SCHEMA_VERSION } from '../agents/default-config.js';
+import { resolveAgentDefaults } from '../agents/defaults-merge.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';
@@ -291,6 +293,7 @@ export async function syncFromState(state, statePath, credentials, opts) {
         appCount: allSkills.filter(s => s.type === 'app').length,
         skillCount: remoteSkills.length,
         mcpServerCount: mcpEntries.length,
+        persona: state.persona,
     });
     // For project scope: determine which app skill to include (only current app's skill)
     let projectAppSkillFilter = null;
@@ -346,85 +349,170 @@ export async function syncFromState(state, statePath, credentials, opts) {
             }
         }
     }
-    // Pull and apply team instructions from onboarding config (non-fatal)
+    // Pull team config from server. A failure here must not stop the
+    // unified user-scope write below, which applies network and minimum-permission
+    // floors regardless of whether team config was fetched.
     let teamInstructionsApplied = false;
     let agentConfigsApplied = 0;
+    let teamInstructions;
+    let agentConfigs;
     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.
+        teamInstructions = onboardingConfig?.config?.teamInstructions ?? undefined;
+        agentConfigs = onboardingConfig?.config?.agentConfigs ?? undefined;
+    }
+    catch {
+        // Team config pull is non-fatal — proceed with no team-managed overrides.
+    }
+    // Write team instructions and/or per-agent extra instructions.
+    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 project-scope config (team overrides only).
+    // User scope is handled below in the unified defaults+network+minimum block.
+    if (agentConfigs) {
         for (const adapter of adapters) {
-            if (!adapter.writeTeamInstructions)
+            const agentConfig = agentConfigs[adapter.slug];
+            if (!agentConfig || !adapter.writeAgentConfig)
                 continue;
-            const agentExtra = agentConfigs?.[adapter.slug]?.extraInstructions;
-            const parts = [teamInstructions, agentExtra].filter(Boolean);
-            if (parts.length === 0)
+            const { extraInstructions: _, ...configWithoutInstructions } = agentConfig;
+            if (Object.keys(configWithoutInstructions).length === 0)
                 continue;
-            const fullInstructions = parts.join('\n\n');
             for (const scope of scopes) {
+                if (scope === 'user')
+                    continue; // handled in unified block below
                 try {
-                    await adapter.writeTeamInstructions(fullInstructions, scope);
-                    teamInstructionsApplied = true;
-                    console.log(`  [${adapter.name}] Updated team instructions (${scope})`);
+                    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
                 }
             }
         }
-        // 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})`);
+    }
+    // Unified user-scope write: merge baked defaults with team config, network
+    // allowlist, and minimum permissions into a single writeAgentConfig call
+    // per adapter. The merge layer tracks injected defaults in state.agentDefaults
+    // so user-removed entries become sticky opt-outs.
+    if (scopes.includes('user')) {
+        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 */ }
+        // Order arrays list each agent's valid values from most restrictive to most
+        // permissive. The floor logic upgrades anything strictly below `minimum`,
+        // including unknown values (-1 < minimumIdx). That makes it critical to
+        // include the agent's most-permissive option in `order` — otherwise a user
+        // who explicitly set, say, `sandbox_mode = "danger-full-access"` gets
+        // silently downgraded to `workspace-write`.
+        const minimumPermissions = [
+            { field: 'approval_policy', order: ['untrusted', 'on-request', 'on-failure', 'never'], minimum: 'on-request' },
+            { field: 'sandbox_mode', order: ['read-only', 'workspace-write', 'danger-full-access'], minimum: 'workspace-write' },
+        ];
+        // agentDefaults lifecycle: full `runwork uninstall` deletes ~/.runwork
+        // (state and all per-agent defaults state with it). Re-running `runwork
+        // setup` overwrites setup.json without agentDefaults so every remaining
+        // tool bootstraps fresh on the next sync. refreshConfiguredAgents only
+        // adds slugs (never removes), so we don't need orphan-entry pruning here.
+        if (!state.agentDefaults)
+            state.agentDefaults = {};
+        for (const adapter of adapters) {
+            if (!adapter.writeAgentConfig)
+                continue;
+            const slug = adapter.slug;
+            const baked = RUNWORK_AGENT_DEFAULTS[slug];
+            const agentState = state.agentDefaults[slug];
+            const team = agentConfigs?.[slug];
+            // onDisk = undefined signals "removal detection is not possible" — used for
+            // markerless adapters (Cursor) and for any adapter without readManagedBlock.
+            // The resolver treats undefined differently from an empty array: it skips
+            // opt-out fabrication entirely and trusts the baseline mechanism in the
+            // adapter to preserve user edits via subtraction.
+            let onDisk;
+            if (baked && adapter.readManagedBlock) {
+                try {
+                    onDisk = await adapter.readManagedBlock('user');
+                }
+                catch {
+                    onDisk = undefined;
+                }
+            }
+            const resolved = resolveAgentDefaults({
+                baked,
+                state: agentState,
+                onDisk,
+                team: team?.permissionRules,
+            });
+            const mergedConfig = {
+                modelPreference: team?.modelPreference,
+                permissionRules: (resolved.managedAllow.length || resolved.managedDeny.length || team?.permissionRules?.defaultMode)
+                    ? {
+                        ...(resolved.managedAllow.length ? { allow: resolved.managedAllow } : {}),
+                        ...(resolved.managedDeny.length ? { deny: resolved.managedDeny } : {}),
+                        ...(team?.permissionRules?.defaultMode ? { defaultMode: team.permissionRules.defaultMode } : {}),
                     }
-                    catch {
-                        // Best-effort per adapter/scope
+                    : undefined,
+                networkAllowlist: networkDomains,
+                minimumPermissions,
+            };
+            try {
+                const baseline = agentState?.lastInjected;
+                await adapter.writeAgentConfig(mergedConfig, 'user', baseline);
+                if (baked) {
+                    const nextState = {
+                        lastInjected: {
+                            allow: resolved.applicableAllow,
+                            deny: resolved.applicableDeny,
+                        },
+                        userOptOuts: {
+                            allow: resolved.newOptOutsAllow,
+                            deny: resolved.newOptOutsDeny,
+                        },
+                    };
+                    state.agentDefaults[slug] = nextState;
+                    // Diagnostic log line (per "invisible / sync log only" policy)
+                    if (resolved.bootstrapped) {
+                        console.log(`  [${adapter.name}] Bootstrapped default-rule tracking (defaults apply on next sync)`);
+                    }
+                    else if (resolved.applicableAllow.length || resolved.applicableDeny.length || resolved.removalsThisSync.allow || resolved.removalsThisSync.deny) {
+                        const totalRemovals = resolved.removalsThisSync.allow + resolved.removalsThisSync.deny;
+                        const removalNote = totalRemovals > 0
+                            ? ` (${totalRemovals} new opt-out${totalRemovals > 1 ? 's' : ''} honored)`
+                            : '';
+                        console.log(`  [${adapter.name}] Applied defaults: ${resolved.applicableAllow.length} allow, ${resolved.applicableDeny.length} deny${removalNote}`);
                     }
                 }
+                if (team)
+                    agentConfigsApplied++;
+            }
+            catch {
+                // Best-effort per adapter
             }
         }
-    }
-    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,
-                minimumPermissions: [
-                    { field: 'approval_policy', order: ['always', 'untrusted', 'on-request', 'never'], minimum: 'on-request' },
-                    { field: 'sandbox_mode', order: ['full', 'read-only', 'workspace-write', 'off'], minimum: 'workspace-write' },
-                ],
-            }, 'user');
-        }
-        catch {
-            // Best-effort
-        }
+        state.agentDefaultsVersion = AGENT_DEFAULTS_SCHEMA_VERSION;
     }
     // Register ~/.runwork as a project in the Codex desktop app (best-effort).
     // Only attempts when Codex adapter is configured and the desktop app is closed.