runwork 0.5.1 → 0.6.0

package/dist/agents/claude-code.js

@@ -1,20 +1,45 @@
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { homedir } from 'os';
+import { homedir, platform } from 'os';
 import { execFileSync } from 'child_process';
+import { whichBinary } from '../utils/which.js';
 import { buildSkillMd } from './types.js';
-import { mergeJsonMcpServers } from './utils/json-config.js';
+import { mergeJsonMcpServers, readJsonConfig, writeJsonConfig } from './utils/json-config.js';
+import { writeHintToFile, writeTeamInstructionsToFile } from './utils/instruction-hint.js';
+const PLUGIN_NAME = 'runwork';
+const PLUGIN_VERSION = '1.0.0';
+function getPluginJson() {
+    return {
+        name: PLUGIN_NAME,
+        version: PLUGIN_VERSION,
+        description: 'Skills and tools from your Runwork workspace',
+        author: { name: 'Runwork' },
+        homepage: 'https://www.runwork.ai',
+    };
+}
+function getMarketplaceJson() {
+    return {
+        name: 'runwork',
+        owner: { name: 'Runwork' },
+        plugins: [
+            {
+                name: PLUGIN_NAME,
+                source: `./plugins/${PLUGIN_NAME}`,
+                description: 'Skills and tools from your Runwork workspace',
+            },
+        ],
+    };
+}
 export class ClaudeCodeAdapter {
     name = 'Claude Code';
     slug = 'claude-code';
     async detect() {
-        try {
-            execFileSync('which', ['claude'], { stdio: 'pipe' });
+        if (whichBinary('claude'))
             return true;
-        }
-        catch {
+        // Fallback: check app bundle on macOS
+        if (platform() === 'darwin')
             return existsSync('/Applications/Claude.app');
-        }
+        return false;
     }
     supportsMcpScope(_scope) {
         return true;
@@ -23,28 +48,326 @@ export class ClaudeCodeAdapter {
         return true;
     }
     async writeMcpServers(servers, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), '.mcp.json')
-            : join(homedir(), '.claude', 'settings.json');
-        const entries = {};
-        for (const s of servers) {
-            entries[s.name] = {
-                type: 'http',
-                url: s.url,
-                ...(s.headers ? { headers: s.headers } : {}),
-            };
+        if (scope === 'project') {
+            // Project scope: write to .mcp.json (standard Claude Code location)
+            const filePath = join(process.cwd(), '.mcp.json');
+            const entries = {};
+            for (const s of servers) {
+                entries[s.name] = {
+                    type: 'http',
+                    url: s.url,
+                    ...(s.headers ? { headers: s.headers } : {}),
+                    ...(s.description ? { description: s.description } : {}),
+                };
+            }
+            mergeJsonMcpServers(filePath, entries, 'mcpServers');
+        }
+        else {
+            // User scope: write MCP config both in global settings and inside the plugin
+            const settingsPath = join(homedir(), '.claude', 'settings.json');
+            const entries = {};
+            for (const s of servers) {
+                entries[s.name] = {
+                    type: 'http',
+                    url: s.url,
+                    ...(s.headers ? { headers: s.headers } : {}),
+                    ...(s.description ? { description: s.description } : {}),
+                };
+            }
+            mergeJsonMcpServers(settingsPath, entries, 'mcpServers');
+            // Also write .mcp.json in the plugin directory
+            const pluginDir = this.getPluginDir();
+            mkdirSync(pluginDir, { recursive: true });
+            const pluginMcpPath = join(pluginDir, '.mcp.json');
+            const pluginEntries = {};
+            for (const s of servers) {
+                pluginEntries[s.name] = {
+                    type: 'http',
+                    url: s.url,
+                    ...(s.headers ? { headers: s.headers } : {}),
+                    ...(s.description ? { description: s.description } : {}),
+                };
+            }
+            writeJsonConfig(pluginMcpPath, pluginEntries);
         }
-        mergeJsonMcpServers(filePath, entries, 'mcpServers');
     }
     async writeSkills(skills, scope) {
+        // Always write to the standard skills directory (guaranteed to work)
         const baseDir = scope === 'project'
             ? join(process.cwd(), '.claude', 'skills')
             : join(homedir(), '.claude', 'skills');
         for (const skill of skills) {
             const skillDir = join(baseDir, skill.name);
             mkdirSync(skillDir, { recursive: true });
-            const content = buildSkillMd(skill);
-            writeFileSync(join(skillDir, 'SKILL.md'), content);
+            writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
+        }
+        // User scope: also write as a plugin for native plugin UI support
+        if (scope === 'user') {
+            const pluginDir = this.getPluginDir();
+            // Create plugin.json
+            const pluginJsonDir = join(pluginDir, '.claude-plugin');
+            mkdirSync(pluginJsonDir, { recursive: true });
+            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);
+                mkdirSync(skillDir, { recursive: true });
+                writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
+            }
+            // Also write to the marketplace directory
+            const marketDir = this.getMarketplaceDir();
+            const marketPluginJsonDir = join(marketDir, '.claude-plugin');
+            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);
+                mkdirSync(skillDir, { recursive: true });
+                writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
+            }
+            // Register in installed_plugins.json
+            this.registerPlugin(pluginDir);
+        }
+    }
+    async writeInstructionHint(hint, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), '.claude', 'CLAUDE.md')
+            : join(homedir(), '.claude', 'CLAUDE.md');
+        writeHintToFile(filePath, hint);
+    }
+    async writeTeamInstructions(instructions, scope) {
+        // Write to CLAUDE.md via markers (direct instruction file approach)
+        const filePath = scope === 'project'
+            ? join(process.cwd(), '.claude', 'CLAUDE.md')
+            : join(homedir(), '.claude', 'CLAUDE.md');
+        writeTeamInstructionsToFile(filePath, instructions);
+        // Also write as a plugin skill (same mechanism as Claude Desktop)
+        if (scope === 'user') {
+            const skillContent = `---\nname: runwork-team-instructions\ndescription: Team instructions from your Runwork workspace. Always follow these guidelines.\n---\n\n${instructions}`;
+            const pluginDir = this.getPluginDir();
+            const marketDir = this.getMarketplaceDir();
+            for (const dir of [
+                join(pluginDir, 'skills', 'runwork-team-instructions'),
+                join(marketDir, 'skills', 'runwork-team-instructions'),
+            ]) {
+                mkdirSync(dir, { recursive: true });
+                writeFileSync(join(dir, 'SKILL.md'), skillContent);
+            }
+        }
+    }
+    // ── Agent config (model, permissions) ──────────────────────────────
+    async writeAgentConfig(config, scope) {
+        const settingsPath = scope === 'project'
+            ? join(process.cwd(), '.claude', 'settings.json')
+            : join(homedir(), '.claude', '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) {
+            settings.model = config.modelPreference;
+        }
+        if (config.permissionRules) {
+            if (!settings.permissions)
+                settings.permissions = {};
+            const perms = settings.permissions;
+            const MANAGED_MARKER = '# runwork-managed';
+            if (config.permissionRules.allow) {
+                const cleanExisting = this.removeAfterMarker(perms.allow ?? [], MANAGED_MARKER);
+                perms.allow = [...cleanExisting, MANAGED_MARKER, ...config.permissionRules.allow];
+            }
+            if (config.permissionRules.deny) {
+                const cleanExisting = this.removeAfterMarker(perms.deny ?? [], MANAGED_MARKER);
+                perms.deny = [...cleanExisting, MANAGED_MARKER, ...config.permissionRules.deny];
+            }
+            if (config.permissionRules.defaultMode) {
+                perms.defaultMode = config.permissionRules.defaultMode;
+            }
+        }
+        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];
+    }
+    // ── Usage stats (passive, best-effort) ─────────────────────────────
+    async readUsageStats(lastSyncAt) {
+        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,
+                        };
+                    }
+                }
+            }
+            // 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) {
+                    try {
+                        const stat = statSync(join(sessionEnvDir, entry));
+                        if (stat.mtimeMs > sinceMs)
+                            recentCount++;
+                        if (stat.mtimeMs > latestMtime)
+                            latestMtime = stat.mtimeMs;
+                    }
+                    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(),
+                    };
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async readSkillUsage(lastSyncAt) {
+        try {
+            const results = [];
+            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
+            const skillDirs = [
+                join(homedir(), '.claude', 'skills'),
+                join(process.cwd(), '.claude', 'skills'),
+            ];
+            for (const dir of skillDirs) {
+                if (!existsSync(dir))
+                    continue;
+                for (const entry of readdirSync(dir)) {
+                    if (entry === 'runwork')
+                        continue;
+                    const skillDir = join(dir, entry);
+                    try {
+                        const stat = statSync(skillDir);
+                        if (stat.mtimeMs > sinceMs) {
+                            results.push({
+                                skillName: entry,
+                                count: 1,
+                                lastUsedAt: new Date(stat.mtimeMs).toISOString(),
+                            });
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+            return results.length > 0 ? results : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async readVersion() {
+        try {
+            const output = execFileSync('claude', ['--version'], { stdio: 'pipe' }).toString().trim();
+            return output;
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Plugin helpers ─────────────────────────────────────────────────
+    getPluginsBaseDir() {
+        return join(homedir(), '.claude', 'plugins');
+    }
+    getPluginDir() {
+        return join(this.getPluginsBaseDir(), 'cache', 'runwork', PLUGIN_NAME, PLUGIN_VERSION);
+    }
+    /** The marketplace root (contains marketplace.json and plugins/) */
+    getMarketplaceRoot() {
+        return join(this.getPluginsBaseDir(), 'marketplaces', 'runwork');
+    }
+    /** The plugin directory within the marketplace */
+    getMarketplaceDir() {
+        return join(this.getMarketplaceRoot(), 'plugins', PLUGIN_NAME);
+    }
+    registerPlugin(pluginDir) {
+        const pluginsBase = this.getPluginsBaseDir();
+        mkdirSync(pluginsBase, { recursive: true });
+        // Register in installed_plugins.json
+        const installedPath = join(pluginsBase, 'installed_plugins.json');
+        const installed = readJsonConfig(installedPath);
+        if (!installed.version)
+            installed.version = 2;
+        if (!installed.plugins)
+            installed.plugins = {};
+        installed.plugins[`${PLUGIN_NAME}@runwork`] = [{
+                scope: 'user',
+                installPath: pluginDir,
+                version: PLUGIN_VERSION,
+                installedAt: new Date().toISOString(),
+                lastUpdated: new Date().toISOString(),
+            }];
+        writeJsonConfig(installedPath, installed);
+        // Write marketplace.json catalog
+        const marketRoot = this.getMarketplaceRoot();
+        const marketCatalogDir = join(marketRoot, '.claude-plugin');
+        mkdirSync(marketCatalogDir, { recursive: true });
+        writeFileSync(join(marketCatalogDir, 'marketplace.json'), JSON.stringify(getMarketplaceJson(), null, 2));
+        // Register in known_marketplaces.json
+        const marketplacesPath = join(pluginsBase, 'known_marketplaces.json');
+        const marketplaces = readJsonConfig(marketplacesPath);
+        marketplaces['runwork'] = {
+            source: { source: 'directory', path: marketRoot },
+            installLocation: marketRoot,
+            lastUpdated: new Date().toISOString(),
+        };
+        writeJsonConfig(marketplacesPath, marketplaces);
+        // Enable the plugin in settings.json
+        const settingsPath = join(homedir(), '.claude', 'settings.json');
+        const settings = readJsonConfig(settingsPath);
+        if (!settings['enabledPlugins']) {
+            settings['enabledPlugins'] = {};
+        }
+        const enabled = settings['enabledPlugins'];
+        if (!enabled[`${PLUGIN_NAME}@runwork`]) {
+            enabled[`${PLUGIN_NAME}@runwork`] = true;
+            writeJsonConfig(settingsPath, settings);
         }
     }
 }

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

@@ -1,4 +1,4 @@
-import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, McpServerEntry, SkillFile } from './types.js';
 export declare class ClaudeDesktopAdapter implements AgentAdapter {
     name: string;
     slug: string;
@@ -7,4 +7,13 @@ export declare class ClaudeDesktopAdapter implements AgentAdapter {
     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>;
+    writeAgentConfig(config: AgentConfigOverride, _scope: 'project' | 'user'): Promise<void>;
+    readUsageStats(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
+    readVersion(): Promise<string | null>;
+    /**
+     * Walk the org/user/session directory tree and invoke callback for each session JSON.
+     */
+    private walkSessionDirs;
 }