runwork 0.6.2 → 0.8.3

package/dist/agents/claude-code.js

@@ -1,11 +1,11 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir, platform } from 'os';
 import { execFileSync } from 'child_process';
 import { whichBinary } from '../utils/which.js';
 import { buildSkillMd } from './types.js';
-import { mergeJsonMcpServers, readJsonConfig, writeJsonConfig } from './utils/json-config.js';
-import { writeHintToFile, writeTeamInstructionsToFile } from './utils/instruction-hint.js';
+import { mergeJsonMcpServers, readJsonConfig, writeJsonConfig, removeRunworkMcpServers } from './utils/json-config.js';
+import { writeHintToFile, writeTeamInstructionsToFile, removeHintFromFile, removeTeamInstructionsFromFile } from './utils/instruction-hint.js';
 const PLUGIN_NAME = 'runwork';
 const PLUGIN_VERSION = '1.0.0';
 function getPluginJson() {
@@ -33,6 +33,7 @@ function getMarketplaceJson() {
 export class ClaudeCodeAdapter {
     name = 'Claude Code';
     slug = 'claude-code';
+    mcpProvidesSkills = true;
     async detect() {
         if (whichBinary('claude'))
             return true;
@@ -79,6 +80,9 @@ export class ClaudeCodeAdapter {
             const pluginDir = this.getPluginDir();
             mkdirSync(pluginDir, { recursive: true });
             const pluginMcpPath = join(pluginDir, '.mcp.json');
+            const marketDir = this.getMarketplaceDir();
+            mkdirSync(marketDir, { recursive: true });
+            const marketplaceMcpPath = join(marketDir, '.mcp.json');
             const pluginEntries = {};
             for (const s of servers) {
                 pluginEntries[s.name] = {
@@ -89,6 +93,7 @@ export class ClaudeCodeAdapter {
                 };
             }
             writeJsonConfig(pluginMcpPath, pluginEntries);
+            writeJsonConfig(marketplaceMcpPath, pluginEntries);
         }
     }
     async writeSkills(skills, scope) {
@@ -97,7 +102,8 @@ export class ClaudeCodeAdapter {
             ? join(process.cwd(), '.claude', 'skills')
             : join(homedir(), '.claude', 'skills');
         for (const skill of skills) {
-            const skillDir = join(baseDir, skill.name);
+            const skillDir = join(baseDir, skill.filename);
+            cleanupOldSkillDir(baseDir, skill);
             mkdirSync(skillDir, { recursive: true });
             writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
         }
@@ -110,7 +116,8 @@ export class ClaudeCodeAdapter {
             writeFileSync(join(pluginJsonDir, 'plugin.json'), JSON.stringify(getPluginJson(), null, 2));
             // Write skill files inside the plugin
             for (const skill of skills) {
-                const skillDir = join(pluginDir, 'skills', skill.name);
+                const skillDir = join(pluginDir, 'skills', skill.filename);
+                cleanupOldSkillDir(join(pluginDir, 'skills'), skill);
                 mkdirSync(skillDir, { recursive: true });
                 writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
             }
@@ -120,7 +127,8 @@ export class ClaudeCodeAdapter {
             mkdirSync(marketPluginJsonDir, { recursive: true });
             writeFileSync(join(marketPluginJsonDir, 'plugin.json'), JSON.stringify(getPluginJson(), null, 2));
             for (const skill of skills) {
-                const skillDir = join(marketDir, 'skills', skill.name);
+                const skillDir = join(marketDir, 'skills', skill.filename);
+                cleanupOldSkillDir(join(marketDir, 'skills'), skill);
                 mkdirSync(skillDir, { recursive: true });
                 writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
             }
@@ -195,72 +203,224 @@ export class ClaudeCodeAdapter {
         const idx = arr.indexOf(marker);
         return idx >= 0 ? arr.slice(0, idx) : [...arr];
     }
+    // ── Cleanup (uninstall) ────────────────────────────────────────────
+    async cleanup(scope, manifest) {
+        // 1. Remove MCP server entries
+        if (scope === 'project') {
+            removeRunworkMcpServers(join(process.cwd(), '.mcp.json'), 'mcpServers');
+        }
+        else {
+            removeRunworkMcpServers(join(homedir(), '.claude', 'settings.json'), 'mcpServers');
+        }
+        // 2. Remove only skill directories that we synced (listed in manifest)
+        const skillsDir = scope === 'project'
+            ? join(process.cwd(), '.claude', 'skills')
+            : join(homedir(), '.claude', 'skills');
+        if (existsSync(skillsDir) && manifest?.skillFilenames.length) {
+            const allowed = new Set(manifest.skillFilenames);
+            for (const entry of readdirSync(skillsDir)) {
+                if (!allowed.has(entry))
+                    continue;
+                try {
+                    rmSync(join(skillsDir, entry), { recursive: true, force: true });
+                }
+                catch { /* best-effort */ }
+            }
+        }
+        // 3. Remove instruction hints and team instructions
+        const instructionFile = scope === 'project'
+            ? join(process.cwd(), '.claude', 'CLAUDE.md')
+            : join(homedir(), '.claude', 'CLAUDE.md');
+        removeHintFromFile(instructionFile);
+        removeTeamInstructionsFromFile(instructionFile);
+        // 4. Remove agent config overrides (managed permission entries, model, enabledPlugins)
+        if (scope === 'user') {
+            const settingsPath = join(homedir(), '.claude', 'settings.json');
+            if (existsSync(settingsPath)) {
+                try {
+                    const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+                    // Remove managed permission entries
+                    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);
+                        }
+                    }
+                    // Remove plugin enablement
+                    if (settings.enabledPlugins) {
+                        delete settings.enabledPlugins[`${PLUGIN_NAME}@runwork`];
+                    }
+                    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+                }
+                catch { /* best-effort */ }
+            }
+            // 5. Remove plugin directories
+            const pluginDir = this.getPluginDir();
+            const marketRoot = this.getMarketplaceRoot();
+            for (const dir of [pluginDir, marketRoot]) {
+                if (existsSync(dir)) {
+                    try {
+                        rmSync(dir, { recursive: true, force: true });
+                    }
+                    catch { /* best-effort */ }
+                }
+            }
+            // 6. Remove from installed_plugins.json
+            const pluginsBase = this.getPluginsBaseDir();
+            const installedPath = join(pluginsBase, 'installed_plugins.json');
+            if (existsSync(installedPath)) {
+                try {
+                    const installed = readJsonConfig(installedPath);
+                    if (installed.plugins) {
+                        delete installed.plugins[`${PLUGIN_NAME}@runwork`];
+                        writeJsonConfig(installedPath, installed);
+                    }
+                }
+                catch { /* best-effort */ }
+            }
+            // 7. Remove from known_marketplaces.json
+            const marketplacesPath = join(pluginsBase, 'known_marketplaces.json');
+            if (existsSync(marketplacesPath)) {
+                try {
+                    const marketplaces = readJsonConfig(marketplacesPath);
+                    delete marketplaces['runwork'];
+                    writeJsonConfig(marketplacesPath, marketplaces);
+                }
+                catch { /* best-effort */ }
+            }
+        }
+    }
     // ── Usage stats (passive, best-effort) ─────────────────────────────
     async readUsageStats(lastSyncAt) {
+        // Source of truth: ~/.claude/projects/<encoded-cwd>/<session-id>.jsonl
+        // Each line is one user/assistant/system entry. The file grows continuously
+        // during a live session, so mtime + per-entry timestamp give an accurate
+        // post-sync activity picture. (stats-cache.json was abandoned upstream and
+        // session-env/ only records session-start hooks.)
         try {
             const claudeDir = join(homedir(), '.claude');
             if (!existsSync(claudeDir))
                 return null;
-            // Primary: stats-cache.json has pre-computed daily activity
-            // Format: { version, lastComputedDate, dailyActivity: [{ date, messageCount, sessionCount, toolCallCount }] }
-            const statsCachePath = join(claudeDir, 'stats-cache.json');
-            if (existsSync(statsCachePath)) {
-                const statsCache = JSON.parse(readFileSync(statsCachePath, 'utf-8'));
-                if (statsCache.dailyActivity && Array.isArray(statsCache.dailyActivity)) {
-                    const sinceDate = lastSyncAt ? lastSyncAt.slice(0, 10) : '1970-01-01';
-                    const recentDays = statsCache.dailyActivity.filter((d) => d.date > sinceDate);
-                    const totalMessages = recentDays.reduce((sum, d) => sum + (d.messageCount ?? 0), 0);
-                    const totalSessions = recentDays.reduce((sum, d) => sum + (d.sessionCount ?? 0), 0);
-                    const totalToolCalls = recentDays.reduce((sum, d) => sum + (d.toolCallCount ?? 0), 0);
-                    if (totalMessages > 0 || totalSessions > 0) {
-                        return {
-                            hasNewActivity: true,
-                            sessionCount: totalSessions,
-                            messageCount: totalMessages,
-                            toolCallCount: totalToolCalls,
-                            tokensUsed: 0,
-                            aiLinesAdded: 0,
-                            aiLinesRemoved: 0,
-                            lastActiveAt: recentDays.length > 0
-                                ? new Date(recentDays[recentDays.length - 1].date).toISOString()
-                                : null,
-                        };
-                    }
-                }
+            const projectsDir = join(claudeDir, 'projects');
+            if (!existsSync(projectsDir))
+                return null;
+            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
+            let sessionCount = 0;
+            let messageCount = 0;
+            let toolCallCount = 0;
+            let inputTokens = 0;
+            let outputTokens = 0;
+            let cacheReadTokens = 0;
+            let latestActivityMs = 0;
+            let cwdEntries;
+            try {
+                cwdEntries = readdirSync(projectsDir);
+            }
+            catch {
+                return null;
             }
-            // Fallback: count session directories modified since last sync
-            const sessionEnvDir = join(claudeDir, 'session-env');
-            if (existsSync(sessionEnvDir)) {
-                const entries = readdirSync(sessionEnvDir);
-                const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
-                let recentCount = 0;
-                let latestMtime = 0;
-                for (const entry of entries) {
+            for (const cwd of cwdEntries) {
+                const cwdPath = join(projectsDir, cwd);
+                let files;
+                try {
+                    files = readdirSync(cwdPath);
+                }
+                catch {
+                    continue;
+                }
+                for (const file of files) {
+                    if (!file.endsWith('.jsonl'))
+                        continue;
+                    const filePath = join(cwdPath, file);
+                    let stat;
                     try {
-                        const stat = statSync(join(sessionEnvDir, entry));
-                        if (stat.mtimeMs > sinceMs)
-                            recentCount++;
-                        if (stat.mtimeMs > latestMtime)
-                            latestMtime = stat.mtimeMs;
+                        stat = statSync(filePath);
                     }
                     catch {
                         continue;
                     }
-                }
-                if (recentCount > 0) {
-                    return {
-                        hasNewActivity: true,
-                        sessionCount: recentCount,
-                        messageCount: 0,
-                        toolCallCount: 0,
-                        tokensUsed: 0,
-                        aiLinesAdded: 0,
-                        aiLinesRemoved: 0,
-                        lastActiveAt: new Date(latestMtime).toISOString(),
-                    };
+                    if (stat.mtimeMs <= sinceMs)
+                        continue;
+                    let content;
+                    try {
+                        content = readFileSync(filePath, 'utf-8');
+                    }
+                    catch {
+                        continue;
+                    }
+                    let sessionHadActivity = false;
+                    for (const line of content.split('\n')) {
+                        if (!line)
+                            continue;
+                        let entry;
+                        try {
+                            entry = JSON.parse(line);
+                        }
+                        catch {
+                            continue;
+                        }
+                        const tsRaw = entry.timestamp;
+                        if (typeof tsRaw !== 'string')
+                            continue;
+                        const ts = Date.parse(tsRaw);
+                        if (!Number.isFinite(ts) || ts <= sinceMs)
+                            continue;
+                        sessionHadActivity = true;
+                        if (ts > latestActivityMs)
+                            latestActivityMs = ts;
+                        const type = entry.type;
+                        if (type === 'user' || type === 'assistant') {
+                            messageCount++;
+                        }
+                        if (type === 'assistant') {
+                            const msg = entry.message;
+                            if (msg && typeof msg === 'object') {
+                                const msgRecord = msg;
+                                const blocks = Array.isArray(msgRecord.content) ? msgRecord.content : [];
+                                for (const block of blocks) {
+                                    if (block && typeof block === 'object'
+                                        && block.type === 'tool_use') {
+                                        toolCallCount++;
+                                    }
+                                }
+                                const usage = msgRecord.usage;
+                                if (usage && typeof usage === 'object') {
+                                    const u = usage;
+                                    if (typeof u.input_tokens === 'number')
+                                        inputTokens += u.input_tokens;
+                                    if (typeof u.output_tokens === 'number')
+                                        outputTokens += u.output_tokens;
+                                    if (typeof u.cache_read_input_tokens === 'number') {
+                                        cacheReadTokens += u.cache_read_input_tokens;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (sessionHadActivity)
+                        sessionCount++;
                 }
             }
-            return null;
+            if (sessionCount === 0)
+                return null;
+            return {
+                hasNewActivity: true,
+                sessionCount,
+                messageCount,
+                toolCallCount,
+                tokensUsed: inputTokens + outputTokens,
+                aiLinesAdded: 0,
+                aiLinesRemoved: 0,
+                lastActiveAt: latestActivityMs > 0 ? new Date(latestActivityMs).toISOString() : null,
+                extra: { inputTokens, outputTokens, cacheReadTokens },
+            };
         }
         catch {
             return null;
@@ -371,3 +531,18 @@ export class ClaudeCodeAdapter {
         }
     }
 }
+/**
+ * Remove old skill directory that used the display name (with spaces) if it
+ * differs from the new slug-based directory name.
+ */
+function cleanupOldSkillDir(baseDir, skill) {
+    if (skill.name === skill.filename)
+        return;
+    const oldDir = join(baseDir, skill.name);
+    if (existsSync(oldDir)) {
+        try {
+            rmSync(oldDir, { recursive: true, force: true });
+        }
+        catch { /* best-effort */ }
+    }
+}

package/dist/agents/claude-desktop-plugin-tree.d.ts

@@ -0,0 +1,44 @@
+import type { McpServerEntry, SkillFile } from './types.js';
+export interface PluginMetadata {
+    pluginName: string;
+    pluginVersion: string;
+    description: string;
+    authorName: string;
+}
+export interface PluginTreeInput extends PluginMetadata {
+    skills: SkillFile[];
+    mcpServers: McpServerEntry[];
+}
+/**
+ * Write <destDir>/.claude-plugin/plugin.json.
+ */
+export declare function writePluginMetadata(destDir: string, metadata: PluginMetadata): void;
+/**
+ * Write <destDir>/.mcp.json with the { mcpServers: { ... } } wrapper
+ * Claude Desktop expects. Token from Authorization header is appended to
+ * the URL so the connector auto-authenticates without a manual OAuth click.
+ */
+export declare function writePluginMcpConfig(destDir: string, mcpServers: McpServerEntry[]): void;
+/**
+ * Write <destDir>/skills/runwork-team-instructions/SKILL.md containing the
+ * workspace team instructions (plus any per-agent extra instructions that
+ * the caller has already merged in). Called from both the sync path and the
+ * plugin zip build path so both produce the same on-disk layout.
+ */
+export declare function writePluginTeamInstructions(destDir: string, instructions: string): void;
+/**
+ * Write <destDir>/skills/<filename>/SKILL.md for each skill. Cleans up
+ * legacy directories that used display name with spaces (e.g. "Write Cold
+ * Email" instead of kebab-cased "write-cold-email").
+ */
+export declare function writePluginSkills(destDir: string, skills: SkillFile[]): void;
+/**
+ * Convenience wrapper that writes the entire plugin tree in one shot.
+ * Used by the build-plugin command to materialise a zip-ready directory.
+ *
+ * Layout:
+ *   <destDir>/.claude-plugin/plugin.json
+ *   <destDir>/.mcp.json
+ *   <destDir>/skills/<filename>/SKILL.md
+ */
+export declare function writePluginTree(destDir: string, input: PluginTreeInput): void;

package/dist/agents/claude-desktop-plugin-tree.js

@@ -0,0 +1,92 @@
+import { mkdirSync, rmSync, existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { appendTokenToUrl, buildSkillMd } from './types.js';
+/**
+ * Write <destDir>/.claude-plugin/plugin.json.
+ */
+export function writePluginMetadata(destDir, metadata) {
+    const pluginJsonDir = join(destDir, '.claude-plugin');
+    mkdirSync(pluginJsonDir, { recursive: true });
+    writeFileSync(join(pluginJsonDir, 'plugin.json'), JSON.stringify({
+        name: metadata.pluginName,
+        version: metadata.pluginVersion,
+        description: metadata.description,
+        author: { name: metadata.authorName },
+    }, null, 2));
+}
+/**
+ * Write <destDir>/.mcp.json with the { mcpServers: { ... } } wrapper
+ * Claude Desktop expects. Token from Authorization header is appended to
+ * the URL so the connector auto-authenticates without a manual OAuth click.
+ */
+export function writePluginMcpConfig(destDir, mcpServers) {
+    mkdirSync(destDir, { recursive: true });
+    const mcpEntries = {};
+    for (const server of mcpServers) {
+        const token = server.headers?.Authorization?.replace(/^Bearer\s+/i, '');
+        const connectorUrl = token ? appendTokenToUrl(server.url, token) : server.url;
+        mcpEntries[server.name] = {
+            type: 'http',
+            url: connectorUrl,
+            ...(server.description ? { description: server.description } : {}),
+        };
+    }
+    writeFileSync(join(destDir, '.mcp.json'), JSON.stringify({ mcpServers: mcpEntries }, null, 2));
+}
+/**
+ * Write <destDir>/skills/runwork-team-instructions/SKILL.md containing the
+ * workspace team instructions (plus any per-agent extra instructions that
+ * the caller has already merged in). Called from both the sync path and the
+ * plugin zip build path so both produce the same on-disk layout.
+ */
+export function writePluginTeamInstructions(destDir, instructions) {
+    const skillDir = join(destDir, 'skills', 'runwork-team-instructions');
+    mkdirSync(skillDir, { recursive: true });
+    const skillContent = `---\nname: runwork-team-instructions\ndescription: Team instructions from your Runwork workspace. Always follow these guidelines.\n---\n\n${instructions}`;
+    writeFileSync(join(skillDir, 'SKILL.md'), skillContent);
+}
+/**
+ * Write <destDir>/skills/<filename>/SKILL.md for each skill. Cleans up
+ * legacy directories that used display name with spaces (e.g. "Write Cold
+ * Email" instead of kebab-cased "write-cold-email").
+ */
+export function writePluginSkills(destDir, skills) {
+    const skillsRoot = join(destDir, 'skills');
+    mkdirSync(skillsRoot, { recursive: true });
+    for (const skill of skills) {
+        if (skill.name !== skill.filename) {
+            const legacyDir = join(skillsRoot, skill.name);
+            if (existsSync(legacyDir)) {
+                try {
+                    rmSync(legacyDir, { recursive: true, force: true });
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+        }
+        const skillDir = join(skillsRoot, skill.filename);
+        mkdirSync(skillDir, { recursive: true });
+        writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
+    }
+}
+/**
+ * Convenience wrapper that writes the entire plugin tree in one shot.
+ * Used by the build-plugin command to materialise a zip-ready directory.
+ *
+ * Layout:
+ *   <destDir>/.claude-plugin/plugin.json
+ *   <destDir>/.mcp.json
+ *   <destDir>/skills/<filename>/SKILL.md
+ */
+export function writePluginTree(destDir, input) {
+    mkdirSync(destDir, { recursive: true });
+    writePluginMetadata(destDir, {
+        pluginName: input.pluginName,
+        pluginVersion: input.pluginVersion,
+        description: input.description,
+        authorName: input.authorName,
+    });
+    writePluginMcpConfig(destDir, input.mcpServers);
+    writePluginSkills(destDir, input.skills);
+}

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

@@ -1,4 +1,21 @@
-import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, McpServerEntry, SkillFile } from './types.js';
+import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, CleanupManifest, McpServerEntry, SkillFile } from './types.js';
+export interface RpmPluginLocation {
+    /** Full path to the rpm plugin directory, e.g. `<org>/rpm/plugin_01YBqw...` */
+    pluginPath: string;
+    /** The org-level directory that contains `rpm/` */
+    orgDir: string;
+}
+/**
+ * Look for a plugin named `pluginName` in any `rpm/manifest.json`. These
+ * entries are created by Claude Desktop when the user uploads a plugin zip
+ * through Customize > Create plugin > Upload plugin. If found, sync should
+ * update the plugin content files inside the rpm plugin directory instead
+ * of writing to the legacy `cowork_plugins/` layout.
+ *
+ * We never modify `rpm/manifest.json` itself — Claude Desktop owns that
+ * registry and assigns the plugin id we read from it here.
+ */
+export declare function findRpmPluginByName(pluginName: string): RpmPluginLocation | null;
 export declare class ClaudeDesktopAdapter implements AgentAdapter {
     name: string;
     slug: string;
@@ -8,8 +25,10 @@ export declare class ClaudeDesktopAdapter implements AgentAdapter {
     writeMcpServers(servers: McpServerEntry[], _scope: 'project' | 'user'): Promise<void>;
     writeSkills(skills: SkillFile[], _scope: 'project' | 'user'): Promise<void>;
     writeInstructionHint(_hint: string, _scope: 'project' | 'user'): Promise<void>;
+    buildPluginZip(skills: SkillFile[], mcpServers: McpServerEntry[], teamInstructions: string | null, outputPath: string): Promise<void>;
     writeTeamInstructions(instructions: string, _scope: 'project' | 'user'): Promise<void>;
     writeAgentConfig(config: AgentConfigOverride, _scope: 'project' | 'user'): Promise<void>;
+    cleanup(_scope: 'project' | 'user', _manifest?: CleanupManifest): Promise<void>;
     readUsageStats(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
     readVersion(): Promise<string | null>;
     /**