runwork 0.15.1 → 0.15.2

package/dist/agents/claude-desktop.js

@@ -1,684 +0,0 @@
-import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, mkdirSync } from 'fs';
-import { dirname, join } from 'path';
-import { homedir, platform, tmpdir } from 'os';
-import { mergeJsonMcpServers, readJsonConfig, writeJsonConfig, removeRunworkMcpServers } from './utils/json-config.js';
-import { writeHintToFile, writeTeamInstructionsToFile, removeHintFromFile, removeTeamInstructionsFromFile, } from './utils/instruction-hint.js';
-import { createZipFromDir } from '../utils/zip.js';
-import { writePluginMcpConfig, writePluginMetadata, writePluginSkills, writePluginTeamInstructions, writePluginTree, } from './claude-desktop-plugin-tree.js';
-const PLUGIN_NAME = 'runwork';
-const PLUGIN_VERSION = '1.0.0';
-const PLUGIN_DESCRIPTION = 'Skills and tools from your Runwork workspace';
-const PLUGIN_AUTHOR_NAME = 'Runwork';
-function getPluginMetadata() {
-    return {
-        pluginName: PLUGIN_NAME,
-        pluginVersion: PLUGIN_VERSION,
-        description: PLUGIN_DESCRIPTION,
-        authorName: PLUGIN_AUTHOR_NAME,
-    };
-}
-function getMcpConfigPath() {
-    const os = platform();
-    if (os === 'darwin') {
-        return join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
-    }
-    if (os === 'win32') {
-        return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
-    }
-    return join(homedir(), '.config', 'Claude', 'claude_desktop_config.json');
-}
-function getCoworkBaseDir() {
-    const os = platform();
-    if (os === 'darwin') {
-        return join(homedir(), 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions');
-    }
-    if (os === 'win32') {
-        return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Claude', 'local-agent-mode-sessions');
-    }
-    return join(homedir(), '.config', 'Claude', 'local-agent-mode-sessions');
-}
-/**
- * Walk all `local-agent-mode-sessions/<session>/<org>/` directories and
- * invoke `visit` for each. Stops and returns the first non-null result.
- */
-function walkOrgDirs(visit) {
-    const baseDir = getCoworkBaseDir();
-    if (!existsSync(baseDir))
-        return null;
-    try {
-        const sessionDirs = readdirSync(baseDir).filter(d => !d.startsWith('.') && d !== 'skills-plugin');
-        for (const sessionId of sessionDirs) {
-            const sessionPath = join(baseDir, sessionId);
-            let orgDirs;
-            try {
-                orgDirs = readdirSync(sessionPath).filter(d => !d.startsWith('.'));
-            }
-            catch {
-                continue;
-            }
-            for (const orgId of orgDirs) {
-                const orgDir = join(sessionPath, orgId);
-                const result = visit(orgDir);
-                if (result !== null)
-                    return result;
-            }
-        }
-    }
-    catch {
-        /* ignore */
-    }
-    return null;
-}
-/**
- * Collect every `<session>/<org>/memory/CLAUDE.md` path under the Cowork
- * base directory. Claude Desktop loads this file on every conversation in
- * the matching session/org — writing here gets Runwork instructions applied
- * foundationally, without relying on the agent invoking a skill. We target
- * every org we find because users may flip between sessions or orgs.
- */
-export function getCoworkMemoryClaudeMdPaths() {
-    const paths = [];
-    const baseDir = getCoworkBaseDir();
-    if (!existsSync(baseDir))
-        return paths;
-    try {
-        const sessionDirs = readdirSync(baseDir).filter(d => !d.startsWith('.') && d !== 'skills-plugin');
-        for (const sessionId of sessionDirs) {
-            const sessionPath = join(baseDir, sessionId);
-            let orgDirs;
-            try {
-                orgDirs = readdirSync(sessionPath).filter(d => !d.startsWith('.'));
-            }
-            catch {
-                continue;
-            }
-            for (const orgId of orgDirs) {
-                paths.push(join(sessionPath, orgId, 'memory', 'CLAUDE.md'));
-            }
-        }
-    }
-    catch {
-        /* ignore */
-    }
-    return paths;
-}
-/**
- * Find the cowork_plugins directory by discovering the session/org ID structure.
- * Path: local-agent-mode-sessions/<session-id>/<org-id>/cowork_plugins/
- */
-function findCoworkPluginsDir() {
-    return walkOrgDirs((orgDir) => {
-        const pluginsDir = join(orgDir, 'cowork_plugins');
-        return existsSync(join(pluginsDir, 'installed_plugins.json')) ? pluginsDir : null;
-    });
-}
-/**
- * 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 function findRpmPluginByName(pluginName) {
-    return walkOrgDirs((orgDir) => {
-        const manifestPath = join(orgDir, 'rpm', 'manifest.json');
-        if (!existsSync(manifestPath))
-            return null;
-        try {
-            const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
-            const entry = manifest.plugins?.find((p) => p.name === pluginName);
-            if (!entry?.id)
-                return null;
-            return {
-                pluginPath: join(orgDir, 'rpm', entry.id),
-                orgDir,
-            };
-        }
-        catch {
-            return null;
-        }
-    });
-}
-function getMarketplaceJson() {
-    return {
-        name: 'runwork',
-        owner: { name: PLUGIN_AUTHOR_NAME },
-        plugins: [
-            {
-                name: PLUGIN_NAME,
-                source: `./plugins/${PLUGIN_NAME}`,
-                description: PLUGIN_DESCRIPTION,
-            },
-        ],
-    };
-}
-function getCoworkSettingsPath(pluginsDir) {
-    return join(dirname(pluginsDir), 'cowork_settings.json');
-}
-function setCoworkPluginEnabled(pluginsDir, enabled) {
-    const settingsPath = getCoworkSettingsPath(pluginsDir);
-    const settings = readJsonConfig(settingsPath);
-    const enabledPlugins = (settings.enabledPlugins ?? {});
-    enabledPlugins[`${PLUGIN_NAME}@runwork`] = enabled;
-    settings.enabledPlugins = enabledPlugins;
-    writeJsonConfig(settingsPath, settings);
-}
-export class ClaudeDesktopAdapter {
-    name = 'Claude Desktop (Cowork)';
-    slug = 'claude-desktop';
-    async detect() {
-        const os = platform();
-        if (os === 'darwin')
-            return existsSync('/Applications/Claude.app');
-        return existsSync(getMcpConfigPath());
-    }
-    supportsMcpScope(scope) {
-        return scope === 'user';
-    }
-    supportsSkills() {
-        return true;
-    }
-    async writeMcpServers(servers, _scope) {
-        // Claude Desktop has two MCP transport paths:
-        // 1. claude_desktop_config.json with mcp-remote (stdio bridge): for chat mode
-        // 2. .mcp.json inside the plugin directory (native HTTP): for cowork mode connectors
-        //
-        // For cowork connectors, embed the auth token in the URL query string.
-        // This lets Claude Desktop connect without requiring the user to go through
-        // an OAuth flow or manually click "Connect" in the Connectors UI.
-        // Write to claude_desktop_config.json via mcp-remote (chat mode fallback).
-        // Forward every auth header (Authorization, X-Api-Key, etc.) as a --header arg.
-        const entries = {};
-        for (const s of servers) {
-            const args = ['mcp-remote', s.url];
-            if (s.headers) {
-                for (const [name, value] of Object.entries(s.headers)) {
-                    args.push('--header', `${name}:${value}`);
-                }
-            }
-            entries[s.name] = {
-                command: 'npx',
-                args: ['-y', ...args],
-            };
-        }
-        mergeJsonMcpServers(getMcpConfigPath(), entries, 'mcpServers');
-        // Prefer rpm/plugin_<id>/ when the user has uploaded our zip through
-        // Claude Desktop's Customize > Create plugin > Upload plugin flow.
-        const rpm = findRpmPluginByName(PLUGIN_NAME);
-        if (rpm) {
-            writePluginMcpConfig(rpm.pluginPath, servers);
-            return;
-        }
-        // Fall back to the legacy cowork_plugins layout (cache + marketplace).
-        const pluginsDir = findCoworkPluginsDir();
-        if (pluginsDir) {
-            const cacheDir = join(pluginsDir, 'cache', 'runwork', PLUGIN_NAME, PLUGIN_VERSION);
-            const marketDir = join(pluginsDir, 'marketplaces', 'runwork', 'plugins', PLUGIN_NAME);
-            for (const dir of [cacheDir, marketDir]) {
-                writePluginMcpConfig(dir, servers);
-            }
-        }
-    }
-    async writeSkills(skills, _scope) {
-        // Prefer rpm/plugin_<id>/ when the user has uploaded our zip through
-        // Claude Desktop's Customize > Create plugin > Upload plugin flow.
-        // Claude Desktop owns rpm/manifest.json (registration, enablement),
-        // so we only refresh the plugin content files.
-        const rpm = findRpmPluginByName(PLUGIN_NAME);
-        if (rpm) {
-            writePluginMetadata(rpm.pluginPath, getPluginMetadata());
-            writePluginSkills(rpm.pluginPath, skills);
-            return;
-        }
-        const pluginsDir = findCoworkPluginsDir();
-        if (!pluginsDir) {
-            console.warn('  [Claude Desktop] Cowork plugins directory not found. Open Claude Desktop at least once first.');
-            return;
-        }
-        // Fall back to legacy cowork_plugins layout: write to both cache
-        // (installed copy) and marketplaces (source).
-        const cacheDir = join(pluginsDir, 'cache', 'runwork', PLUGIN_NAME, PLUGIN_VERSION);
-        const marketRoot = join(pluginsDir, 'marketplaces', 'runwork');
-        const marketDir = join(marketRoot, 'plugins', PLUGIN_NAME);
-        for (const dir of [cacheDir, marketDir]) {
-            writePluginMetadata(dir, getPluginMetadata());
-            writePluginSkills(dir, skills);
-        }
-        // Register in installed_plugins.json
-        const installedPath = join(pluginsDir, '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: cacheDir,
-                version: PLUGIN_VERSION,
-                installedAt: new Date().toISOString(),
-                lastUpdated: new Date().toISOString(),
-            }];
-        writeJsonConfig(installedPath, installed);
-        // Write marketplace.json catalog
-        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(pluginsDir, 'known_marketplaces.json');
-        const marketplaces = readJsonConfig(marketplacesPath);
-        marketplaces['runwork'] = {
-            source: { source: 'directory', path: marketRoot },
-            installLocation: marketRoot,
-            lastUpdated: new Date().toISOString(),
-        };
-        writeJsonConfig(marketplacesPath, marketplaces);
-        // Sync should recover a previously disabled plugin so it shows up in Customize.
-        setCoworkPluginEnabled(pluginsDir, true);
-    }
-    async writeInstructionHint(hint, _scope) {
-        // Cowork loads `<session>/<org>/memory/CLAUDE.md` on every conversation.
-        // This is the same always-on memory surface Claude Code uses with
-        // `~/.claude/CLAUDE.md`, so it's the right home for foundational hints.
-        // Merge into marker blocks so any user-authored content above/below our
-        // block is preserved.
-        for (const path of getCoworkMemoryClaudeMdPaths()) {
-            try {
-                writeHintToFile(path, hint);
-            }
-            catch { /* best-effort per org */ }
-        }
-    }
-    async buildPluginZip(skills, mcpServers, teamInstructions, outputPath) {
-        // Materialise the plugin tree into a temp dir, zip it, then clean up.
-        // Uses the same writePluginTree + writePluginTeamInstructions helpers
-        // the sync path uses so the on-disk layout is byte-identical whether
-        // the user installs via upload or sync.
-        const stagingRoot = mkdtempSync(join(tmpdir(), 'runwork-plugin-'));
-        const pluginStagingDir = join(stagingRoot, PLUGIN_NAME);
-        try {
-            writePluginTree(pluginStagingDir, {
-                ...getPluginMetadata(),
-                skills,
-                mcpServers,
-            });
-            if (teamInstructions) {
-                writePluginTeamInstructions(pluginStagingDir, teamInstructions);
-            }
-            createZipFromDir(pluginStagingDir, outputPath);
-        }
-        finally {
-            try {
-                rmSync(stagingRoot, { recursive: true, force: true });
-            }
-            catch {
-                /* best-effort */
-            }
-        }
-    }
-    async writeTeamInstructions(instructions, _scope) {
-        // Primary surface: `<org>/memory/CLAUDE.md`. Cowork auto-loads this on
-        // every conversation, matching the Claude Code convention. Write through
-        // the team-instructions marker block so user-authored content is safe.
-        for (const path of getCoworkMemoryClaudeMdPaths()) {
-            try {
-                writeTeamInstructionsToFile(path, instructions);
-            }
-            catch { /* best-effort per org */ }
-        }
-        // Secondary surface: the plugin's `runwork-team-instructions` SKILL.md.
-        // Kept for the build-plugin zip flow and as a slash-command fallback
-        // when users inspect plugin skills. Prefer the rpm upload location when
-        // present, otherwise fall back to the legacy cowork_plugins layout.
-        const rpm = findRpmPluginByName(PLUGIN_NAME);
-        if (rpm) {
-            writePluginTeamInstructions(rpm.pluginPath, instructions);
-            return;
-        }
-        const pluginsDir = findCoworkPluginsDir();
-        if (!pluginsDir)
-            return;
-        writePluginTeamInstructions(join(pluginsDir, 'cache', 'runwork', PLUGIN_NAME, PLUGIN_VERSION), instructions);
-        writePluginTeamInstructions(join(pluginsDir, 'marketplaces', 'runwork', 'plugins', PLUGIN_NAME), instructions);
-    }
-    // ── Agent config (limited to preferences) ──────────────────────────
-    async writeAgentConfig(config, _scope) {
-        const configPath = getMcpConfigPath();
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let desktopConfig = {};
-        if (existsSync(configPath)) {
-            try {
-                desktopConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
-            }
-            catch { /* start fresh */ }
-        }
-        if (!desktopConfig.preferences)
-            desktopConfig.preferences = {};
-        const prefs = desktopConfig.preferences;
-        if (config.permissionRules) {
-            if (config.permissionRules.allow?.includes('web_search')) {
-                prefs.coworkWebSearchEnabled = true;
-            }
-            if (config.permissionRules.deny?.includes('web_search')) {
-                prefs.coworkWebSearchEnabled = false;
-            }
-            if (config.permissionRules.allow?.includes('scheduled_tasks')) {
-                prefs.coworkScheduledTasksEnabled = true;
-                prefs.ccdScheduledTasksEnabled = true;
-            }
-            if (config.permissionRules.deny?.includes('scheduled_tasks')) {
-                prefs.coworkScheduledTasksEnabled = false;
-                prefs.ccdScheduledTasksEnabled = false;
-            }
-        }
-        writeFileSync(configPath, JSON.stringify(desktopConfig, null, 2));
-    }
-    // ── Cleanup (uninstall) ────────────────────────────────────────────
-    async cleanup(_scope, _manifest) {
-        // 1. Remove MCP entries from claude_desktop_config.json
-        removeRunworkMcpServers(getMcpConfigPath(), 'mcpServers');
-        // Remove Runwork marker blocks from each org's memory/CLAUDE.md, leaving
-        // any user-authored content in that file intact.
-        for (const path of getCoworkMemoryClaudeMdPaths()) {
-            try {
-                removeHintFromFile(path);
-            }
-            catch { /* best-effort per org */ }
-            try {
-                removeTeamInstructionsFromFile(path);
-            }
-            catch { /* best-effort per org */ }
-        }
-        // 2. Remove the uploaded rpm plugin if the user installed via
-        //    Customize > Create plugin > Upload plugin. We delete both the
-        //    plugin directory and the manifest entry so Claude Desktop does
-        //    not show a stale Runwork plugin after uninstall.
-        const rpm = findRpmPluginByName(PLUGIN_NAME);
-        if (rpm) {
-            if (existsSync(rpm.pluginPath)) {
-                try {
-                    rmSync(rpm.pluginPath, { recursive: true, force: true });
-                }
-                catch { /* best-effort */ }
-            }
-            const manifestPath = join(rpm.orgDir, 'rpm', 'manifest.json');
-            if (existsSync(manifestPath)) {
-                try {
-                    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
-                    if (Array.isArray(manifest.plugins)) {
-                        manifest.plugins = manifest.plugins.filter((p) => p.name !== PLUGIN_NAME);
-                        manifest.lastUpdated = Date.now();
-                        writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-                    }
-                }
-                catch { /* best-effort */ }
-            }
-        }
-        // 3. Remove Cowork plugin directories and registration
-        const pluginsDir = findCoworkPluginsDir();
-        if (pluginsDir) {
-            // Remove cache/runwork and marketplaces/runwork directories
-            const cacheRunwork = join(pluginsDir, 'cache', 'runwork');
-            const marketRunwork = join(pluginsDir, 'marketplaces', 'runwork');
-            for (const dir of [cacheRunwork, marketRunwork]) {
-                if (existsSync(dir)) {
-                    try {
-                        rmSync(dir, { recursive: true, force: true });
-                    }
-                    catch { /* best-effort */ }
-                }
-            }
-            // Remove from installed_plugins.json
-            const installedPath = join(pluginsDir, '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 */ }
-            }
-            // Remove from known_marketplaces.json
-            const marketplacesPath = join(pluginsDir, 'known_marketplaces.json');
-            if (existsSync(marketplacesPath)) {
-                try {
-                    const marketplaces = readJsonConfig(marketplacesPath);
-                    delete marketplaces['runwork'];
-                    writeJsonConfig(marketplacesPath, marketplaces);
-                }
-                catch { /* best-effort */ }
-            }
-            // Remove the enable flag so cleanup fully unregisters the plugin.
-            const coworkSettingsPath = getCoworkSettingsPath(pluginsDir);
-            if (existsSync(coworkSettingsPath)) {
-                try {
-                    const settings = readJsonConfig(coworkSettingsPath);
-                    const enabledPlugins = settings.enabledPlugins;
-                    if (enabledPlugins && typeof enabledPlugins === 'object' && !Array.isArray(enabledPlugins)) {
-                        delete enabledPlugins[`${PLUGIN_NAME}@runwork`];
-                        settings.enabledPlugins = enabledPlugins;
-                        writeJsonConfig(coworkSettingsPath, settings);
-                    }
-                }
-                catch { /* best-effort */ }
-            }
-        }
-    }
-    // ── Usage stats (passive, best-effort) ─────────────────────────────
-    async readUsageStats(lastSyncAt) {
-        try {
-            const os = platform();
-            let claudeAppDir;
-            if (os === 'darwin') {
-                claudeAppDir = join(homedir(), 'Library', 'Application Support', 'Claude');
-            }
-            else if (os === 'win32') {
-                claudeAppDir = join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Claude');
-            }
-            else {
-                claudeAppDir = join(homedir(), '.config', 'Claude');
-            }
-            if (!existsSync(claudeAppDir))
-                return null;
-            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
-            let sessionCount = 0;
-            let latestActivity = 0;
-            const modelsUsed = new Set();
-            let maxMcpTools = 0;
-            // Read agent mode session JSON files
-            // Path: local-agent-mode-sessions/{orgId}/{userId}/*.json
-            const agentSessionsDir = join(claudeAppDir, 'local-agent-mode-sessions');
-            if (existsSync(agentSessionsDir)) {
-                this.walkSessionDirs(agentSessionsDir, sinceMs, (session) => {
-                    const sessionTime = session.lastActivityAt ?? session.createdAt ?? 0;
-                    if (sessionTime > sinceMs)
-                        sessionCount++;
-                    if (sessionTime > latestActivity)
-                        latestActivity = sessionTime;
-                    if (session.model)
-                        modelsUsed.add(session.model);
-                    if (session.enabledMcpTools && typeof session.enabledMcpTools === 'object') {
-                        const toolCount = Object.keys(session.enabledMcpTools).length;
-                        if (toolCount > maxMcpTools)
-                            maxMcpTools = toolCount;
-                    }
-                });
-            }
-            // Also check code sessions launched from Desktop
-            const codeSessionsDir = join(claudeAppDir, 'claude-code-sessions');
-            if (existsSync(codeSessionsDir)) {
-                this.walkSessionDirs(codeSessionsDir, sinceMs, (session) => {
-                    const sessionTime = session.lastActivityAt ?? session.createdAt ?? 0;
-                    if (sessionTime > sinceMs)
-                        sessionCount++;
-                    if (sessionTime > latestActivity)
-                        latestActivity = sessionTime;
-                    if (session.model)
-                        modelsUsed.add(session.model);
-                });
-            }
-            // Check scheduled tasks
-            let scheduledTaskRuns = 0;
-            const scheduledTasksPath = join(claudeAppDir, 'scheduled-tasks.json');
-            if (existsSync(scheduledTasksPath)) {
-                try {
-                    const raw = readFileSync(scheduledTasksPath, 'utf-8');
-                    const parsed = JSON.parse(raw);
-                    const tasks = Array.isArray(parsed) ? parsed : Object.values(parsed);
-                    for (const task of tasks) {
-                        const t = task;
-                        if (t.lastRunAt && new Date(t.lastRunAt).getTime() > sinceMs) {
-                            scheduledTaskRuns++;
-                        }
-                    }
-                }
-                catch { /* best-effort */ }
-            }
-            if (sessionCount === 0 && latestActivity <= sinceMs && scheduledTaskRuns === 0)
-                return null;
-            return {
-                hasNewActivity: sessionCount > 0 || scheduledTaskRuns > 0,
-                sessionCount,
-                messageCount: 0,
-                toolCallCount: 0,
-                tokensUsed: 0,
-                aiLinesAdded: 0,
-                aiLinesRemoved: 0,
-                lastActiveAt: latestActivity > 0 ? new Date(latestActivity).toISOString() : null,
-                modelsUsed: Array.from(modelsUsed),
-                mcpToolCount: maxMcpTools > 0 ? maxMcpTools : undefined,
-                extra: scheduledTaskRuns > 0 ? { scheduledTaskRuns } : undefined,
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    async readVersion() {
-        try {
-            const os = platform();
-            let claudeAppDir;
-            if (os === 'darwin') {
-                claudeAppDir = join(homedir(), 'Library', 'Application Support', 'Claude');
-            }
-            else if (os === 'win32') {
-                claudeAppDir = join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Claude');
-            }
-            else {
-                claudeAppDir = join(homedir(), '.config', 'Claude');
-            }
-            const versionPath = join(claudeAppDir, 'claude-code', 'sdk-version');
-            if (existsSync(versionPath)) {
-                return readFileSync(versionPath, 'utf-8').trim();
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async readSkillUsage(lastSyncAt) {
-        // Cowork session JSON files contain enabledMcpTools, an object whose keys
-        // are MCP tool names. Tools matching skill_* patterns indicate which skills
-        // were loaded (reach, not invocation). This is the best we can get from
-        // local data. For actual invocation data, OTEL or the Enterprise Analytics
-        // API are needed.
-        try {
-            const baseDir = getCoworkBaseDir();
-            if (!existsSync(baseDir))
-                return null;
-            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
-            const skillCounts = new Map();
-            const agentSessionsDir = baseDir;
-            this.walkSessionDirs(agentSessionsDir, sinceMs, (session) => {
-                const sessionTime = session.lastActivityAt ?? session.createdAt ?? 0;
-                if (sessionTime <= sinceMs)
-                    return;
-                const mcpTools = session.enabledMcpTools;
-                if (!mcpTools || typeof mcpTools !== 'object')
-                    return;
-                for (const toolName of Object.keys(mcpTools)) {
-                    // Match patterns like "skill_Blog_Writing_Specialist" or
-                    // "mcp__Runwork__skill_Write_Cold_Email"
-                    const skillMatch = toolName.match(/skill_([A-Za-z0-9_]+)/);
-                    if (!skillMatch)
-                        continue;
-                    // Convert Tool_Name_Format to readable name
-                    const rawName = skillMatch[1].replace(/_/g, ' ').trim();
-                    if (!rawName)
-                        continue;
-                    const existing = skillCounts.get(rawName);
-                    if (existing) {
-                        existing.count++;
-                        if (sessionTime > existing.lastTs)
-                            existing.lastTs = sessionTime;
-                    }
-                    else {
-                        skillCounts.set(rawName, { count: 1, lastTs: sessionTime });
-                    }
-                }
-            });
-            if (skillCounts.size === 0)
-                return null;
-            const results = [];
-            for (const [skillName, { count, lastTs }] of skillCounts) {
-                results.push({
-                    skillName,
-                    count,
-                    lastUsedAt: new Date(lastTs).toISOString(),
-                });
-            }
-            return results;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Walk the org/user/session directory tree and invoke callback for each session JSON.
-     */
-    walkSessionDirs(baseDir, _sinceMs, onSession) {
-        try {
-            for (const orgDir of readdirSync(baseDir)) {
-                if (orgDir.startsWith('.') || orgDir === 'skills-plugin')
-                    continue;
-                const orgPath = join(baseDir, orgDir);
-                try {
-                    if (!statSync(orgPath).isDirectory())
-                        continue;
-                }
-                catch {
-                    continue;
-                }
-                for (const userDir of readdirSync(orgPath)) {
-                    if (userDir.startsWith('.'))
-                        continue;
-                    const userPath = join(orgPath, userDir);
-                    try {
-                        if (!statSync(userPath).isDirectory())
-                            continue;
-                    }
-                    catch {
-                        continue;
-                    }
-                    for (const file of readdirSync(userPath)) {
-                        if (!file.endsWith('.json'))
-                            continue;
-                        try {
-                            const session = JSON.parse(readFileSync(join(userPath, file), 'utf-8'));
-                            onSession(session);
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                }
-            }
-        }
-        catch { /* best-effort */ }
-    }
-}