runwork 0.5.1 → 0.6.1

package/dist/agents/cursor.js

@@ -2,6 +2,8 @@ import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir, platform } from 'os';
 import { execFileSync } from 'child_process';
+import { querySqlite } from '../utils/sqlite.js';
+import { whichBinary } from '../utils/which.js';
 import { mergeJsonMcpServers } from './utils/json-config.js';
 export class CursorAdapter {
     name = 'Cursor';
@@ -10,13 +12,7 @@ export class CursorAdapter {
         const os = platform();
         if (os === 'darwin' && existsSync('/Applications/Cursor.app'))
             return true;
-        try {
-            execFileSync('which', ['cursor'], { stdio: 'pipe' });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return !!whichBinary('cursor');
     }
     supportsMcpScope(_scope) {
         return true;
@@ -52,4 +48,165 @@ ${skill.content}`;
             writeFileSync(join(rulesDir, `${skill.filename}.mdc`), mdcContent);
         }
     }
+    async writeInstructionHint(hint, scope) {
+        // Cursor uses rules files, not a central instruction file
+        // Write as a rule file that's always loaded
+        const filePath = scope === 'project'
+            ? join(process.cwd(), '.cursor', 'rules', 'runwork.mdc')
+            : join(homedir(), '.cursor', 'rules', 'runwork.mdc');
+        const mdcContent = `---\ndescription: "Runwork workspace connection"\nalwaysApply: true\n---\n\n${hint}`;
+        mkdirSync(join(filePath, '..'), { recursive: true });
+        writeFileSync(filePath, mdcContent);
+    }
+    async writeTeamInstructions(instructions, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), '.cursor', 'rules', 'runwork-team.mdc')
+            : join(homedir(), '.cursor', 'rules', 'runwork-team.mdc');
+        const mdcContent = `---\ndescription: "Team instructions from Runwork workspace"\nalwaysApply: true\n---\n\n${instructions}`;
+        mkdirSync(join(filePath, '..'), { recursive: true });
+        writeFileSync(filePath, mdcContent);
+    }
+    // ── Agent config (model, permissions via SQLite) ────────────────────
+    async writeAgentConfig(config, scope) {
+        if (scope !== 'user')
+            return;
+        const os = platform();
+        let globalDbPath;
+        if (os === 'darwin') {
+            globalDbPath = join(homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+        }
+        else if (os === 'win32') {
+            globalDbPath = join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+        }
+        else {
+            globalDbPath = join(homedir(), '.config', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+        }
+        if (!existsSync(globalDbPath))
+            return;
+        try {
+            const Database = (await import('better-sqlite3')).default;
+            const db = new Database(globalDbPath, { timeout: 5000 });
+            try {
+                const storageKey = 'src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser';
+                const row = db.prepare(`SELECT value FROM ItemTable WHERE key = ?`).get(storageKey);
+                if (!row?.value)
+                    return;
+                const data = JSON.parse(row.value);
+                if (config.modelPreference) {
+                    if (!data.aiSettings)
+                        data.aiSettings = {};
+                    data.aiSettings.composerModel = config.modelPreference;
+                }
+                if (config.permissionRules && data.composerState) {
+                    if (config.permissionRules.allow) {
+                        data.composerState.yoloCommandAllowlist = config.permissionRules.allow;
+                    }
+                    if (config.permissionRules.deny) {
+                        data.composerState.yoloCommandDenylist = config.permissionRules.deny;
+                    }
+                }
+                db.prepare(`UPDATE ItemTable SET value = ? WHERE key = ?`).run(JSON.stringify(data), storageKey);
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch {
+            // Cursor config write is best-effort (DB may be locked while Cursor is running)
+        }
+    }
+    // ── Usage stats (passive, best-effort) ─────────────────────────────
+    async readUsageStats(lastSyncAt) {
+        try {
+            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
+            // Query composerData from state.vscdb (cursorDiskKV table)
+            const os = platform();
+            let globalDbPath;
+            if (os === 'darwin') {
+                globalDbPath = join(homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+            }
+            else if (os === 'win32') {
+                globalDbPath = join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+            }
+            else {
+                globalDbPath = join(homedir(), '.config', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+            }
+            let sessionCount = 0;
+            let totalLinesAdded = 0;
+            let totalLinesRemoved = 0;
+            let latestActivity = 0;
+            let agenticSessions = 0;
+            let chatSessions = 0;
+            if (existsSync(globalDbPath)) {
+                const composerResult = querySqlite(globalDbPath, `SELECT value FROM cursorDiskKV WHERE key LIKE 'composerData-%'`);
+                if (composerResult) {
+                    for (const line of composerResult.split('\n')) {
+                        if (!line.trim())
+                            continue;
+                        try {
+                            const data = JSON.parse(line);
+                            const createdAt = data.createdAt ?? 0;
+                            if (createdAt > sinceMs) {
+                                sessionCount++;
+                                totalLinesAdded += data.totalLinesAdded ?? 0;
+                                totalLinesRemoved += data.totalLinesRemoved ?? 0;
+                                if (data.unifiedMode === 'agent' || data.isAgentic)
+                                    agenticSessions++;
+                                else
+                                    chatSessions++;
+                            }
+                            if (createdAt > latestActivity)
+                                latestActivity = createdAt;
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+            }
+            // Check scored_commits for AI contribution data
+            // ~/.cursor/ is consistent across platforms (unlike Application Support paths)
+            const trackingDbPath = join(homedir(), '.cursor', 'ai-tracking', 'ai-code-tracking.db');
+            let aiCommitCount = 0;
+            let avgAiPercent = 0;
+            if (existsSync(trackingDbPath)) {
+                const sinceSec = Math.floor(sinceMs / 1000);
+                const commitResult = querySqlite(trackingDbPath, `SELECT count(*), avg(CAST(v2AiPercentage AS REAL)) FROM scored_commits WHERE scoredAt > ${sinceSec}`);
+                if (commitResult) {
+                    const parts = commitResult.split('|');
+                    aiCommitCount = parseInt(parts[0]) || 0;
+                    avgAiPercent = parseFloat(parts[1]) || 0;
+                }
+            }
+            if (sessionCount === 0 && latestActivity <= sinceMs)
+                return null;
+            return {
+                hasNewActivity: sessionCount > 0,
+                sessionCount,
+                messageCount: 0,
+                toolCallCount: 0,
+                tokensUsed: 0,
+                aiLinesAdded: totalLinesAdded,
+                aiLinesRemoved: totalLinesRemoved,
+                lastActiveAt: latestActivity > 0 ? new Date(latestActivity).toISOString() : null,
+                extra: {
+                    agenticSessions,
+                    chatSessions,
+                    ...(aiCommitCount > 0 ? { aiCommitCount, avgAiContributionPercent: Math.round(avgAiPercent) } : {}),
+                },
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async readVersion() {
+        try {
+            const output = execFileSync('cursor', ['--version'], { stdio: 'pipe' }).toString().trim();
+            return output;
+        }
+        catch {
+            return null;
+        }
+    }
 }

package/dist/agents/detect.js

@@ -1,21 +1,41 @@
 import { ClaudeCodeAdapter } from './claude-code.js';
 import { ClaudeDesktopAdapter } from './claude-desktop.js';
 import { CursorAdapter } from './cursor.js';
-import { CodexAdapter } from './codex.js';
 import { WindsurfAdapter } from './windsurf.js';
-import { CopilotVscodeAdapter } from './copilot-vscode.js';
-import { CopilotCliAdapter } from './copilot-cli.js';
+import { CodexAdapter } from './codex.js';
+import { ClineAdapter } from './cline.js';
 import { GeminiAdapter } from './gemini.js';
-const ALL_ADAPTERS = [
+import { GenericAgentAdapter } from './generic-adapter.js';
+import { getRegistryAgents, getCustomAdapterSlugs } from './registry.js';
+/**
+ * Agents with custom adapter implementations (plugin systems, special formats).
+ * These override the generic adapter for their slug.
+ */
+const CUSTOM_ADAPTERS = [
     new ClaudeCodeAdapter(),
     new ClaudeDesktopAdapter(),
     new CursorAdapter(),
-    new CodexAdapter(),
     new WindsurfAdapter(),
-    new CopilotVscodeAdapter(),
-    new CopilotCliAdapter(),
+    new CodexAdapter(),
+    new ClineAdapter(),
     new GeminiAdapter(),
 ];
+const customSlugs = getCustomAdapterSlugs();
+const customMap = new Map(CUSTOM_ADAPTERS.map(a => [a.slug, a]));
+/**
+ * Build the full list of adapters: custom adapters for special agents,
+ * generic adapters for everything else in the registry.
+ */
+function buildAllAdapters() {
+    const adapters = [...CUSTOM_ADAPTERS];
+    for (const def of getRegistryAgents()) {
+        if (customSlugs.has(def.slug))
+            continue;
+        adapters.push(new GenericAgentAdapter(def));
+    }
+    return adapters;
+}
+const ALL_ADAPTERS = buildAllAdapters();
 export async function detectAgents() {
     const results = await Promise.all(ALL_ADAPTERS.map(async (adapter) => {
         try {
@@ -29,6 +49,9 @@ export async function detectAgents() {
     return results.filter((a) => a !== null);
 }
 export function getAdapterBySlug(slug) {
+    // Check custom adapters first, then fall back to generic
+    if (customMap.has(slug))
+        return customMap.get(slug);
     return ALL_ADAPTERS.find(a => a.slug === slug);
 }
 export function printNoAgentsMessage() {

package/dist/agents/gemini.d.ts

@@ -1,10 +1,13 @@
-import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+import type { AgentAdapter, AgentConfigOverride, McpServerEntry, SkillFile } from './types.js';
 export declare class GeminiAdapter implements AgentAdapter {
     name: string;
     slug: string;
     detect(): Promise<boolean>;
-    supportsMcpScope(_scope: 'project' | 'user'): boolean;
+    supportsMcpScope(scope: 'project' | 'user'): boolean;
     supportsSkills(): boolean;
-    writeMcpServers(servers: McpServerEntry[], scope: 'project' | 'user'): Promise<void>;
+    writeMcpServers(servers: McpServerEntry[], _scope: 'project' | 'user'): Promise<void>;
     writeSkills(skills: SkillFile[], 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>;
 }

package/dist/agents/gemini.js

@@ -1,31 +1,24 @@
-import { mkdirSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { execFileSync } from 'child_process';
+import { whichBinary } from '../utils/which.js';
 import { buildSkillMd } from './types.js';
+import { writeHintToFile, writeTeamInstructionsToFile } from './utils/instruction-hint.js';
 import { mergeJsonMcpServers } from './utils/json-config.js';
 export class GeminiAdapter {
     name = 'Gemini CLI';
     slug = 'gemini';
     async detect() {
-        try {
-            execFileSync('which', ['gemini'], { stdio: 'pipe' });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return !!whichBinary('gemini');
     }
-    supportsMcpScope(_scope) {
-        return true;
+    supportsMcpScope(scope) {
+        return scope === 'user';
     }
     supportsSkills() {
         return true;
     }
-    async writeMcpServers(servers, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), '.gemini', 'settings.json')
-            : join(homedir(), '.gemini', 'settings.json');
+    async writeMcpServers(servers, _scope) {
+        const configPath = join(homedir(), '.gemini', 'settings.json');
         const entries = {};
         for (const s of servers) {
             entries[s.name] = {
@@ -33,15 +26,59 @@ export class GeminiAdapter {
                 ...(s.headers ? { headers: s.headers } : {}),
             };
         }
-        mergeJsonMcpServers(filePath, entries, 'mcpServers');
+        mergeJsonMcpServers(configPath, entries, 'mcpServers');
     }
     async writeSkills(skills, scope) {
         const baseDir = scope === 'project'
-            ? join(process.cwd(), '.gemini', 'commands')
-            : join(homedir(), '.gemini', 'commands');
-        mkdirSync(baseDir, { recursive: true });
+            ? join(process.cwd(), '.gemini', 'skills')
+            : join(homedir(), '.gemini', 'skills');
         for (const skill of skills) {
-            writeFileSync(join(baseDir, `${skill.filename}.md`), buildSkillMd(skill));
+            const skillDir = join(baseDir, skill.name);
+            mkdirSync(skillDir, { recursive: true });
+            writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
+        }
+    }
+    async writeInstructionHint(hint, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), 'GEMINI.md')
+            : join(homedir(), '.gemini', 'GEMINI.md');
+        writeHintToFile(filePath, hint);
+    }
+    async writeTeamInstructions(instructions, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), 'GEMINI.md')
+            : join(homedir(), '.gemini', 'GEMINI.md');
+        writeTeamInstructionsToFile(filePath, instructions);
+    }
+    // ── Agent config (settings.json) ──────────────────────────────────
+    async writeAgentConfig(config, scope) {
+        const settingsPath = scope === 'project'
+            ? join(process.cwd(), '.gemini', 'settings.json')
+            : join(homedir(), '.gemini', 'settings.json');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let settings = {};
+        if (existsSync(settingsPath)) {
+            try {
+                settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+            }
+            catch { /* start fresh */ }
+        }
+        if (config.modelPreference) {
+            if (!settings.model)
+                settings.model = {};
+            settings.model.name = config.modelPreference;
+        }
+        if (config.permissionRules?.allow) {
+            if (!settings.tools)
+                settings.tools = {};
+            settings.tools.allowed = config.permissionRules.allow;
+        }
+        if (config.permissionRules?.deny) {
+            if (!settings.tools)
+                settings.tools = {};
+            settings.tools.exclude = config.permissionRules.deny;
         }
+        mkdirSync(join(settingsPath, '..'), { recursive: true });
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
     }
 }

package/dist/agents/generic-adapter.d.ts

@@ -0,0 +1,23 @@
+import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+import type { AgentDefinition } from './registry.js';
+/**
+ * Generic adapter that handles any agent from the registry using its
+ * skillsPaths, mcpConfigPath, and instructionFile metadata.
+ *
+ * This covers the long tail of community agents. Agents with custom behavior
+ * (plugin systems, special config formats, usage stats reading) use their
+ * own dedicated adapter classes instead.
+ */
+export declare class GenericAgentAdapter implements AgentAdapter {
+    name: string;
+    slug: string;
+    private def;
+    constructor(def: AgentDefinition);
+    detect(): Promise<boolean>;
+    supportsMcpScope(scope: 'project' | 'user'): boolean;
+    supportsSkills(): boolean;
+    writeMcpServers(servers: McpServerEntry[], _scope: 'project' | 'user'): Promise<void>;
+    writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
+    writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
+    writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
+}

package/dist/agents/generic-adapter.js

@@ -0,0 +1,106 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { isAbsolute, join } from 'path';
+import { homedir } from 'os';
+import { whichBinary } from '../utils/which.js';
+import { buildSkillMd } from './types.js';
+import { mergeJsonMcpServers } from './utils/json-config.js';
+import { writeHintToFile, writeTeamInstructionsToFile } from './utils/instruction-hint.js';
+import { resolvePlatformString, resolveToAbsolute } from './registry.js';
+/**
+ * Generic adapter that handles any agent from the registry using its
+ * skillsPaths, mcpConfigPath, and instructionFile metadata.
+ *
+ * This covers the long tail of community agents. Agents with custom behavior
+ * (plugin systems, special config formats, usage stats reading) use their
+ * own dedicated adapter classes instead.
+ */
+export class GenericAgentAdapter {
+    name;
+    slug;
+    def;
+    constructor(def) {
+        this.def = def;
+        this.name = def.name;
+        this.slug = def.slug;
+    }
+    async detect() {
+        const target = resolvePlatformString(this.def.detection.target);
+        if (!target)
+            return false;
+        if (this.def.detection.method === 'binary') {
+            return !!whichBinary(target);
+        }
+        // path detection
+        if (isAbsolute(target)) {
+            return existsSync(target);
+        }
+        return existsSync(join(homedir(), target));
+    }
+    supportsMcpScope(scope) {
+        if (!this.def.mcpConfigPath)
+            return false;
+        return scope === 'user';
+    }
+    supportsSkills() {
+        return !!this.def.skillsPaths;
+    }
+    async writeMcpServers(servers, _scope) {
+        if (!this.def.mcpConfigPath)
+            return;
+        const filePath = join(homedir(), resolvePlatformString(this.def.mcpConfigPath) || '');
+        if (!filePath)
+            return;
+        const entries = {};
+        for (const s of servers) {
+            entries[s.name] = {
+                type: 'http',
+                url: s.url,
+                ...(s.headers ? { headers: s.headers } : {}),
+            };
+        }
+        mergeJsonMcpServers(filePath, entries, this.def.mcpConfigKey || 'mcpServers');
+    }
+    async writeSkills(skills, scope) {
+        if (!this.def.skillsPaths)
+            return;
+        const pathTemplate = scope === 'project'
+            ? this.def.skillsPaths.project
+            : this.def.skillsPaths.global;
+        if (!pathTemplate)
+            return;
+        const baseDir = resolveToAbsolute(pathTemplate, scope === 'project' ? 'project' : 'global');
+        if (!baseDir)
+            return;
+        for (const skill of skills) {
+            const skillDir = join(baseDir, skill.name);
+            mkdirSync(skillDir, { recursive: true });
+            writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
+        }
+    }
+    async writeInstructionHint(hint, scope) {
+        if (!this.def.instructionFile)
+            return;
+        const pathTemplate = scope === 'project'
+            ? this.def.instructionFile.project
+            : this.def.instructionFile.global;
+        if (!pathTemplate)
+            return;
+        const filePath = resolveToAbsolute(pathTemplate, scope === 'project' ? 'project' : 'global');
+        if (!filePath)
+            return;
+        writeHintToFile(filePath, hint);
+    }
+    async writeTeamInstructions(instructions, scope) {
+        if (!this.def.instructionFile)
+            return;
+        const pathTemplate = scope === 'project'
+            ? this.def.instructionFile.project
+            : this.def.instructionFile.global;
+        if (!pathTemplate)
+            return;
+        const filePath = resolveToAbsolute(pathTemplate, scope === 'project' ? 'project' : 'global');
+        if (!filePath)
+            return;
+        writeTeamInstructionsToFile(filePath, instructions);
+    }
+}

package/dist/agents/intro-skill.d.ts

@@ -0,0 +1,36 @@
+import type { WorkspaceAllData } from '../types.js';
+import type { SkillFile } from './types.js';
+export interface IntroSkillContext {
+    workspaceName: string;
+    workspaceId: string;
+    workspaceSlug?: string;
+    registries: WorkspaceAllData | null;
+    connectedIntegrations: string[];
+    mcpServerCount: number;
+    skillCount: number;
+    /** Names of external MCP servers configured in the workspace */
+    mcpServerNames?: string[];
+    /** Names of skills (app + external) configured in the workspace */
+    skillNames?: string[];
+}
+export interface InstructionHintContext {
+    workspaceName: string;
+    workspaceId: string;
+    workspaceSlug?: string;
+    registries: WorkspaceAllData | null;
+    connectedIntegrations: string[];
+    appCount: number;
+    skillCount: number;
+    mcpServerCount: number;
+}
+export declare function buildAppSkillDescription(appName: string, registries: WorkspaceAllData | null): string;
+/**
+ * Generate the dynamic Runwork intro skill that teaches agents what Runwork is
+ * and what infrastructure is available in this workspace.
+ */
+export declare function generateIntroSkill(ctx: IntroSkillContext): SkillFile;
+/**
+ * Generate the minimal instruction hint that goes into agent instruction files.
+ * Uses HTML comment delimiters so it can be found and replaced on sync.
+ */
+export declare function generateInstructionHint(ctx: InstructionHintContext): string;