runwork 0.15.0 → 0.15.1

package/dist/agents/__tests__/claude-code-managed-block.test.js

@@ -1,8 +1,9 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdirSync, writeFileSync, rmSync } from 'fs';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
 import { ClaudeCodeAdapter } from '../claude-code.js';
+const MARKER = '# runwork-managed';
 let homeDir;
 let originalHome;
 beforeEach(() => {
@@ -10,7 +11,6 @@ beforeEach(() => {
     homeDir = join(tmpdir(), `runwork-cc-managed-${Date.now()}-${Math.random().toString(36).slice(2)}`);
     mkdirSync(join(homeDir, '.claude'), { recursive: true });
     process.env.HOME = homeDir;
-    // Reset the homedir() cache by mocking it via env (Node's os.homedir reads HOME on macOS/Linux).
 });
 afterEach(() => {
     if (originalHome)
@@ -23,75 +23,83 @@ afterEach(() => {
     catch { /* ignore */ }
     vi.restoreAllMocks();
 });
+function settingsPath() {
+    return join(homeDir, '.claude', 'settings.json');
+}
 function writeSettings(settings) {
-    writeFileSync(join(homeDir, '.claude', 'settings.json'), JSON.stringify(settings, null, 2));
+    writeFileSync(settingsPath(), JSON.stringify(settings, null, 2));
+}
+function readSettings() {
+    return JSON.parse(readFileSync(settingsPath(), 'utf-8'));
 }
-describe('ClaudeCodeAdapter.readManagedBlock (user scope)', () => {
+describe('ClaudeCodeAdapter.readManagedBlock (markerless)', () => {
     it('returns undefined when settings.json is missing', async () => {
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result).toBeUndefined();
+        expect(await adapter.readManagedBlock('user')).toBeUndefined();
     });
-    it('returns empty arrays when permissions key is absent', async () => {
-        writeSettings({ model: 'claude-sonnet-4-6' });
+    it('returns undefined even when a legacy marker is present (no on-disk read)', async () => {
+        writeSettings({ permissions: { allow: [MARKER, 'Bash(runwork *)'], deny: [] } });
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result).toEqual({ allow: [], deny: [] });
+        expect(await adapter.readManagedBlock('user')).toBeUndefined();
     });
-    it('returns empty arrays when marker is absent', async () => {
-        writeSettings({ permissions: { allow: ['Bash(npm test)'], deny: ['Bash(rm)'] } });
-        const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result).toEqual({ allow: [], deny: [] });
-    });
-    it('returns entries after marker in allow', async () => {
+});
+describe('ClaudeCodeAdapter.writeAgentConfig legacy-marker migration', () => {
+    it('strips the legacy marker from allow and deny when injecting new rules', async () => {
         writeSettings({
             permissions: {
-                allow: ['Bash(npm test)', '# runwork-managed', 'Bash(runwork *)', 'Bash(git status)'],
-                deny: [],
+                allow: [MARKER, 'Bash(runwork *)', 'Bash(git status)'],
+                deny: [MARKER, 'Bash(rm -rf *)'],
             },
         });
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result?.allow).toEqual(['Bash(runwork *)', 'Bash(git status)']);
-        expect(result?.deny).toEqual([]);
+        await adapter.writeAgentConfig({ permissionRules: { allow: ['Bash(runwork *)', 'Bash(git status)'], deny: ['Bash(rm -rf *)'] } }, 'user', { allow: ['Bash(runwork *)', 'Bash(git status)'], deny: ['Bash(rm -rf *)'] });
+        const perms = readSettings().permissions;
+        expect(perms.allow).not.toContain(MARKER);
+        expect(perms.deny).not.toContain(MARKER);
+        expect(perms.allow).toEqual(['Bash(runwork *)', 'Bash(git status)']);
+        expect(perms.deny).toEqual(['Bash(rm -rf *)']);
     });
-    it('returns entries after marker in deny', async () => {
+    it('strips the legacy marker even when there are no new permission rules', async () => {
         writeSettings({
             permissions: {
-                allow: [],
-                deny: ['Bash(curl evil.com)', '# runwork-managed', 'Bash(rm -rf *)'],
+                allow: ['Bash(user-custom)', MARKER, 'Bash(runwork *)'],
+                deny: [MARKER],
             },
         });
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result?.deny).toEqual(['Bash(rm -rf *)']);
+        await adapter.writeAgentConfig({}, 'user');
+        const perms = readSettings().permissions;
+        expect(perms.allow).toEqual(['Bash(user-custom)', 'Bash(runwork *)']);
+        expect(perms.deny).toEqual([]);
     });
-    it('returns empty when marker exists but nothing follows', async () => {
+});
+describe('ClaudeCodeAdapter.writeAgentConfig markerless merge', () => {
+    it('preserves user entries and subtracts the baseline before re-injecting', async () => {
         writeSettings({
             permissions: {
-                allow: ['Bash(npm test)', '# runwork-managed'],
-                deny: [],
+                allow: ['Bash(user-custom)', 'Bash(runwork *)', 'Bash(old-default)'],
             },
         });
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result?.allow).toEqual([]);
+        await adapter.writeAgentConfig({ permissionRules: { allow: ['Bash(runwork *)', 'Bash(git status)'] } }, 'user', { allow: ['Bash(runwork *)', 'Bash(old-default)'] });
+        // user entry kept; baseline-only entry (old-default) dropped; new managed set appended
+        expect(readSettings().permissions.allow).toEqual([
+            'Bash(user-custom)',
+            'Bash(runwork *)',
+            'Bash(git status)',
+        ]);
     });
-    it('returns undefined on JSON parse error', async () => {
-        writeFileSync(join(homeDir, '.claude', 'settings.json'), '{ not valid json');
+    it('writes model preference and defaultMode', async () => {
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result).toBeUndefined();
+        await adapter.writeAgentConfig({ modelPreference: 'claude-sonnet-4-6', permissionRules: { allow: ['Bash(runwork *)'], defaultMode: 'acceptEdits' } }, 'user');
+        const settings = readSettings();
+        expect(settings.model).toBe('claude-sonnet-4-6');
+        expect(settings.permissions.defaultMode).toBe('acceptEdits');
+        expect(settings.permissions.allow).toEqual(['Bash(runwork *)']);
     });
-    it('filters out non-string entries after marker (defensive)', async () => {
-        writeSettings({
-            permissions: {
-                allow: ['# runwork-managed', 'Bash(runwork *)', 42, null, 'Bash(git status)'],
-            },
-        });
+    it('does not create an empty settings file when there is nothing to write', async () => {
         const adapter = new ClaudeCodeAdapter();
-        const result = await adapter.readManagedBlock('user');
-        expect(result?.allow).toEqual(['Bash(runwork *)', 'Bash(git status)']);
+        await adapter.writeAgentConfig({}, 'user');
+        expect(existsSync(settingsPath())).toBe(false);
     });
 });

package/dist/agents/claude-code.d.ts

@@ -31,11 +31,17 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     writeBuiltInHooks(scope: 'project' | 'user'): Promise<void>;
     writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
     writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
-    writeAgentConfig(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
-    /** Remove the managed marker and all entries after it from a permissions array */
-    private removeAfterMarker;
-    /** Return entries after the managed marker for both allow and deny lists. */
-    readManagedBlock(scope: 'project' | 'user'): Promise<{
+    writeAgentConfig(config: AgentConfigOverride, scope: 'project' | 'user', baseline?: {
+        allow?: string[];
+        deny?: string[];
+    }): Promise<void>;
+    /**
+     * Markerless adapter: removal detection relies on the `baseline`
+     * (state.lastInjected) passed to writeAgentConfig, exactly like Cursor, since
+     * the adapter no longer writes an on-disk sentinel to delimit its entries.
+     * Returning undefined tells the sync loop to skip on-disk removal detection.
+     */
+    readManagedBlock(_scope: 'project' | 'user'): Promise<{
         allow?: string[];
         deny?: string[];
     } | undefined>;

package/dist/agents/claude-code.js

@@ -7,8 +7,17 @@ import { buildSkillMd } from './types.js';
 import { mergeJsonMcpServers, readJsonConfig, writeJsonConfig, removeRunworkMcpServers } from './utils/json-config.js';
 import { writeHintToFile, writeTeamInstructionsToFile, removeHintFromFile, removeTeamInstructionsFromFile } from './utils/instruction-hint.js';
 import { SESSION_START_HOOK_SCRIPT } from './session-start-hook.js';
+import { mergeMarkerless } from './defaults-merge.js';
 const PLUGIN_NAME = 'runwork';
 const PLUGIN_VERSION = '1.0.0';
+/**
+ * Legacy in-array sentinel that older CLI versions injected at the head of the
+ * managed permission block. Claude Code >= 2.1.x validates every allow/deny
+ * entry as a tool rule and rejects this with "matches no known tool" on
+ * startup, so the adapter is now markerless and actively strips this marker
+ * from any existing user's settings on their next sync.
+ */
+const LEGACY_MANAGED_MARKER = '# runwork-managed';
 function getPluginJson() {
     return {
         name: PLUGIN_NAME,
@@ -215,18 +224,31 @@ export class ClaudeCodeAdapter {
         }
     }
     // ── Agent config (model, permissions) ──────────────────────────────
-    async writeAgentConfig(config, scope) {
+    async writeAgentConfig(config, scope, baseline) {
         const settingsPath = scope === 'project'
             ? join(process.cwd(), '.claude', 'settings.json')
             : join(homedir(), '.claude', 'settings.json');
+        const hadFile = existsSync(settingsPath);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let settings = {};
-        if (existsSync(settingsPath)) {
+        if (hadFile) {
             try {
                 settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
             }
             catch { /* start fresh */ }
         }
+        // Retro-fix migration: strip the legacy in-array sentinel from any existing
+        // settings, regardless of whether we inject new rules this sync. This is
+        // what removes the broken "# runwork-managed" entry that makes Claude Code
+        // >= 2.1.x print "matches no known tool" on startup.
+        if (settings.permissions && typeof settings.permissions === 'object') {
+            for (const key of ['allow', 'deny']) {
+                const arr = settings.permissions[key];
+                if (Array.isArray(arr)) {
+                    settings.permissions[key] = arr.filter((x) => x !== LEGACY_MANAGED_MARKER);
+                }
+            }
+        }
         if (config.modelPreference) {
             settings.model = config.modelPreference;
         }
@@ -234,55 +256,32 @@ export class ClaudeCodeAdapter {
             if (!settings.permissions)
                 settings.permissions = {};
             const perms = settings.permissions;
-            const MANAGED_MARKER = '# runwork-managed';
+            // Markerless merge: subtract our previous contribution (baseline) to leave
+            // the user's own entries intact, then append the freshly resolved set.
             if (config.permissionRules.allow) {
-                const cleanExisting = this.removeAfterMarker(perms.allow ?? [], MANAGED_MARKER);
-                perms.allow = [...cleanExisting, MANAGED_MARKER, ...config.permissionRules.allow];
+                perms.allow = mergeMarkerless(Array.isArray(perms.allow) ? perms.allow : [], baseline?.allow ?? [], config.permissionRules.allow);
             }
             if (config.permissionRules.deny) {
-                const cleanExisting = this.removeAfterMarker(perms.deny ?? [], MANAGED_MARKER);
-                perms.deny = [...cleanExisting, MANAGED_MARKER, ...config.permissionRules.deny];
+                perms.deny = mergeMarkerless(Array.isArray(perms.deny) ? perms.deny : [], baseline?.deny ?? [], config.permissionRules.deny);
             }
             if (config.permissionRules.defaultMode) {
                 perms.defaultMode = config.permissionRules.defaultMode;
             }
         }
+        // Nothing to persist and no file to clean up: avoid creating an empty file.
+        if (!hadFile && !config.modelPreference && !config.permissionRules)
+            return;
         mkdirSync(join(settingsPath, '..'), { recursive: true });
         writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
     }
-    /** Remove the managed marker and all entries after it from a permissions array */
-    removeAfterMarker(arr, marker) {
-        const idx = arr.indexOf(marker);
-        return idx >= 0 ? arr.slice(0, idx) : [...arr];
-    }
-    /** Return entries after the managed marker for both allow and deny lists. */
-    async readManagedBlock(scope) {
-        const settingsPath = scope === 'project'
-            ? join(process.cwd(), '.claude', 'settings.json')
-            : join(homedir(), '.claude', 'settings.json');
-        if (!existsSync(settingsPath))
-            return undefined;
-        const MANAGED_MARKER = '# runwork-managed';
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-            const perms = settings?.permissions;
-            if (!perms || typeof perms !== 'object')
-                return { allow: [], deny: [] };
-            const extractAfter = (arr) => {
-                if (!Array.isArray(arr))
-                    return [];
-                const idx = arr.indexOf(MANAGED_MARKER);
-                return idx >= 0 ? arr.slice(idx + 1).filter((x) => typeof x === 'string') : [];
-            };
-            return {
-                allow: extractAfter(perms.allow),
-                deny: extractAfter(perms.deny),
-            };
-        }
-        catch {
-            return undefined;
-        }
+    /**
+     * Markerless adapter: removal detection relies on the `baseline`
+     * (state.lastInjected) passed to writeAgentConfig, exactly like Cursor, since
+     * the adapter no longer writes an on-disk sentinel to delimit its entries.
+     * Returning undefined tells the sync loop to skip on-disk removal detection.
+     */
+    async readManagedBlock(_scope) {
+        return undefined;
     }
     // ── Cleanup (uninstall) ────────────────────────────────────────────
     async cleanup(scope, manifest) {
@@ -320,18 +319,18 @@ export class ClaudeCodeAdapter {
             if (existsSync(settingsPath)) {
                 try {
                     const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-                    // Remove managed permission entries
+                    // Remove managed permission entries. Legacy installs carry the
+                    // in-array marker, so everything from the marker onward is ours.
+                    // Always also drop any stray marker so uninstall never leaves the
+                    // entry that breaks Claude Code startup.
                     if (settings.permissions) {
-                        const MANAGED_MARKER = '# runwork-managed';
-                        if (settings.permissions.allow) {
-                            const idx = settings.permissions.allow.indexOf(MANAGED_MARKER);
-                            if (idx >= 0)
-                                settings.permissions.allow = settings.permissions.allow.slice(0, idx);
-                        }
-                        if (settings.permissions.deny) {
-                            const idx = settings.permissions.deny.indexOf(MANAGED_MARKER);
-                            if (idx >= 0)
-                                settings.permissions.deny = settings.permissions.deny.slice(0, idx);
+                        for (const key of ['allow', 'deny']) {
+                            const arr = settings.permissions[key];
+                            if (!Array.isArray(arr))
+                                continue;
+                            const idx = arr.indexOf(LEGACY_MANAGED_MARKER);
+                            settings.permissions[key] = (idx >= 0 ? arr.slice(0, idx) : arr)
+                                .filter((x) => x !== LEGACY_MANAGED_MARKER);
                         }
                     }
                     // Remove plugin enablement

package/dist/agents/cursor.d.ts

@@ -1,19 +1,6 @@
 import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, CleanupManifest, McpServerEntry, SkillFile } from './types.js';
-/**
- * Merge a new managed list into a markerless on-disk array while preserving
- * user-added entries.
- *
- * existing  = what's currently on disk
- * baseline  = what we wrote on the previous sync (state.lastInjected). Items
- *             present here are assumed to be ours; subtracting them from
- *             existing leaves entries the user added themselves.
- * incoming  = the new managed set to inject (defaults already filtered for
- *             opt-outs, merged with team rules)
- *
- * If baseline is empty (bootstrap or first run with this CLI version), we
- * assume nothing currently on disk is ours and preserve all existing entries.
- */
-export declare function mergeMarkerless(existing: string[], baseline: string[], incoming: string[]): string[];
+import { mergeMarkerless } from './defaults-merge.js';
+export { mergeMarkerless };
 export declare class CursorAdapter implements AgentAdapter {
     name: string;
     slug: string;

package/dist/agents/cursor.js

@@ -5,39 +5,9 @@ import { execFileSync } from '../utils/subprocess.js';
 import { querySqlite, openWritableSqlite } from '../utils/sqlite.js';
 import { whichBinary } from '../utils/which.js';
 import { mergeJsonMcpServers, removeRunworkMcpServers, readJsonConfig, writeJsonConfig } from './utils/json-config.js';
-/**
- * Merge a new managed list into a markerless on-disk array while preserving
- * user-added entries.
- *
- * existing  = what's currently on disk
- * baseline  = what we wrote on the previous sync (state.lastInjected). Items
- *             present here are assumed to be ours; subtracting them from
- *             existing leaves entries the user added themselves.
- * incoming  = the new managed set to inject (defaults already filtered for
- *             opt-outs, merged with team rules)
- *
- * If baseline is empty (bootstrap or first run with this CLI version), we
- * assume nothing currently on disk is ours and preserve all existing entries.
- */
-export function mergeMarkerless(existing, baseline, incoming) {
-    const baselineSet = new Set(baseline);
-    const userEntries = existing.filter((item) => !baselineSet.has(item));
-    const seen = new Set();
-    const result = [];
-    for (const item of userEntries) {
-        if (!seen.has(item)) {
-            seen.add(item);
-            result.push(item);
-        }
-    }
-    for (const item of incoming) {
-        if (!seen.has(item)) {
-            seen.add(item);
-            result.push(item);
-        }
-    }
-    return result;
-}
+import { mergeMarkerless } from './defaults-merge.js';
+// Re-exported for backward compatibility with existing importers/tests.
+export { mergeMarkerless };
 export class CursorAdapter {
     name = 'Cursor';
     slug = 'cursor';

package/dist/agents/defaults-merge.d.ts

@@ -20,6 +20,21 @@ export declare function computeApplicable(baked: string[], optOuts: string[]): s
  */
 export declare function mergeAllow(applicableDefaults: string[], teamRules: string[]): string[];
 export declare function unique(items: string[]): string[];
+/**
+ * Merge a new managed list into a markerless on-disk array while preserving
+ * user-added entries. Shared by all markerless adapters (Cursor, Claude Code).
+ *
+ * existing  = what's currently on disk
+ * baseline  = what we wrote on the previous sync (state.lastInjected). Items
+ *             present here are assumed to be ours; subtracting them from
+ *             existing leaves entries the user added themselves.
+ * incoming  = the new managed set to inject (defaults already filtered for
+ *             opt-outs, merged with team rules)
+ *
+ * If baseline is empty (bootstrap or first run with this CLI version), we
+ * assume nothing currently on disk is ours and preserve all existing entries.
+ */
+export declare function mergeMarkerless(existing: string[], baseline: string[], incoming: string[]): string[];
 /** True if no per-agent state has ever been recorded — first sync after upgrade or fresh install. */
 export declare function isBootstrap(state: AgentDefaultsState | undefined): boolean;
 export interface ResolveResult {

package/dist/agents/defaults-merge.js

@@ -45,6 +45,25 @@ export function unique(items) {
     }
     return out;
 }
+/**
+ * Merge a new managed list into a markerless on-disk array while preserving
+ * user-added entries. Shared by all markerless adapters (Cursor, Claude Code).
+ *
+ * existing  = what's currently on disk
+ * baseline  = what we wrote on the previous sync (state.lastInjected). Items
+ *             present here are assumed to be ours; subtracting them from
+ *             existing leaves entries the user added themselves.
+ * incoming  = the new managed set to inject (defaults already filtered for
+ *             opt-outs, merged with team rules)
+ *
+ * If baseline is empty (bootstrap or first run with this CLI version), we
+ * assume nothing currently on disk is ours and preserve all existing entries.
+ */
+export function mergeMarkerless(existing, baseline, incoming) {
+    const baselineSet = new Set(baseline);
+    const userEntries = existing.filter((item) => !baselineSet.has(item));
+    return unique([...userEntries, ...incoming]);
+}
 /** True if no per-agent state has ever been recorded — first sync after upgrade or fresh install. */
 export function isBootstrap(state) {
     return state === undefined;

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.15.0";
+export declare const VERSION = "0.15.1";

package/dist/generated/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runwork",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "description": "CLI for Runwork: develop, preview, and deploy Runwork apps from your local machine.",
   "license": "UNLICENSED",
   "author": "Runwork <info@runwork.ai> (https://www.runwork.ai)",