runwork 0.5.1 → 0.6.1

package/dist/agents/claude-desktop.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, writeFileSync, mkdirSync } from 'fs';
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir, platform } from 'os';
 import { buildSkillMd } from './types.js';
@@ -57,6 +57,19 @@ function getPluginJson() {
         author: { name: 'Runwork' },
     };
 }
+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 ClaudeDesktopAdapter {
     name = 'Claude Desktop (Cowork)';
     slug = 'claude-desktop';
@@ -87,6 +100,25 @@ export class ClaudeDesktopAdapter {
             };
         }
         mergeJsonMcpServers(getMcpConfigPath(), entries, 'mcpServers');
+        // Also write .mcp.json inside the Cowork plugin directory
+        const pluginsDir = findCoworkPluginsDir();
+        if (pluginsDir) {
+            const cacheDir = join(pluginsDir, 'cache', 'runwork', PLUGIN_NAME, PLUGIN_VERSION);
+            const marketDir = join(pluginsDir, 'marketplaces', 'runwork', 'plugins', PLUGIN_NAME);
+            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 } : {}),
+                };
+            }
+            for (const dir of [cacheDir, marketDir]) {
+                mkdirSync(dir, { recursive: true });
+                writeJsonConfig(join(dir, '.mcp.json'), pluginEntries);
+            }
+        }
     }
     async writeSkills(skills, _scope) {
         const pluginsDir = findCoworkPluginsDir();
@@ -96,7 +128,8 @@ export class ClaudeDesktopAdapter {
         }
         // Write to both cache (installed copy) and marketplaces (source)
         const cacheDir = join(pluginsDir, 'cache', 'runwork', PLUGIN_NAME, PLUGIN_VERSION);
-        const marketDir = join(pluginsDir, 'marketplaces', 'runwork', PLUGIN_NAME);
+        const marketRoot = join(pluginsDir, 'marketplaces', 'runwork');
+        const marketDir = join(marketRoot, 'plugins', PLUGIN_NAME);
         // Create plugin.json in both locations
         for (const dir of [cacheDir, marketDir]) {
             const pluginJsonDir = join(dir, '.claude-plugin');
@@ -126,16 +159,225 @@ export class ClaudeDesktopAdapter {
                 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);
-        if (!marketplaces['runwork']) {
-            marketplaces['runwork'] = {
-                source: { source: 'local', path: join(pluginsDir, 'marketplaces', 'runwork') },
-                installLocation: join(pluginsDir, 'marketplaces', 'runwork'),
-                lastUpdated: new Date().toISOString(),
+        marketplaces['runwork'] = {
+            source: { source: 'directory', path: marketRoot },
+            installLocation: marketRoot,
+            lastUpdated: new Date().toISOString(),
+        };
+        writeJsonConfig(marketplacesPath, marketplaces);
+    }
+    async writeInstructionHint(_hint, _scope) {
+        // Claude Desktop/Cowork uses project instructions within the app UI, not files.
+        // The plugin system handles skill discovery.
+    }
+    async writeTeamInstructions(instructions, _scope) {
+        // Write team instructions as a skill in the CoWork plugin system.
+        // This makes them available to Claude Desktop sessions via the plugin.
+        const pluginsDir = findCoworkPluginsDir();
+        if (!pluginsDir)
+            return;
+        const skillContent = `---\nname: runwork-team-instructions\ndescription: Team instructions from your Runwork workspace. Always follow these guidelines.\n---\n\n${instructions}`;
+        // Write to both cache and marketplace locations
+        const cacheDir = join(pluginsDir, 'cache', 'runwork', PLUGIN_NAME, PLUGIN_VERSION, 'skills', 'runwork-team-instructions');
+        const marketDir = join(pluginsDir, 'marketplaces', 'runwork', 'plugins', PLUGIN_NAME, 'skills', 'runwork-team-instructions');
+        for (const dir of [cacheDir, marketDir]) {
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, 'SKILL.md'), skillContent);
+        }
+    }
+    // ── 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));
+    }
+    // ── 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,
             };
-            writeJsonConfig(marketplacesPath, marketplaces);
         }
+        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;
+        }
+    }
+    /**
+     * 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 */ }
     }
 }

package/dist/agents/cline.d.ts

@@ -0,0 +1,13 @@
+import type { AgentAdapter, AgentConfigOverride, McpServerEntry, SkillFile } from './types.js';
+export declare class ClineAdapter implements AgentAdapter {
+    name: string;
+    slug: string;
+    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>;
+    writeAgentConfig(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
+}

package/dist/agents/cline.js

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { 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';
+export class ClineAdapter {
+    name = 'Cline';
+    slug = 'cline';
+    async detect() {
+        return !!whichBinary('cline');
+    }
+    supportsMcpScope(scope) {
+        return scope === 'user';
+    }
+    supportsSkills() {
+        return true;
+    }
+    async writeMcpServers(servers, _scope) {
+        const configPath = join(homedir(), '.cline', 'data', 'settings', 'cline_mcp_settings.json');
+        const entries = {};
+        for (const s of servers) {
+            entries[s.name] = {
+                url: s.url,
+                ...(s.headers ? { headers: s.headers } : {}),
+            };
+        }
+        mergeJsonMcpServers(configPath, entries, 'mcpServers');
+    }
+    async writeSkills(skills, scope) {
+        if (scope === 'user')
+            return;
+        const rulesDir = join(process.cwd(), '.clinerules');
+        mkdirSync(rulesDir, { recursive: true });
+        for (const skill of skills) {
+            writeFileSync(join(rulesDir, `${skill.filename}.md`), buildSkillMd(skill));
+        }
+    }
+    async writeInstructionHint(hint, scope) {
+        if (scope === 'user')
+            return;
+        const filePath = join(process.cwd(), '.clinerules', 'runwork.md');
+        mkdirSync(join(filePath, '..'), { recursive: true });
+        writeFileSync(filePath, hint);
+    }
+    async writeTeamInstructions(instructions, scope) {
+        if (scope === 'user')
+            return;
+        const filePath = join(process.cwd(), '.clinerules', 'runwork-team.md');
+        mkdirSync(join(filePath, '..'), { recursive: true });
+        writeFileSync(filePath, instructions);
+    }
+    // ── Agent config (globalState.json) ────────────────────────────────
+    async writeAgentConfig(config, scope) {
+        if (scope !== 'user')
+            return;
+        const globalStatePath = join(homedir(), '.cline', 'data', 'globalState.json');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let state = {};
+        if (existsSync(globalStatePath)) {
+            try {
+                state = JSON.parse(readFileSync(globalStatePath, 'utf-8'));
+            }
+            catch { /* start fresh */ }
+        }
+        if (config.modelPreference) {
+            state.apiModelId = config.modelPreference;
+        }
+        if (config.permissionRules) {
+            if (!state.autoApprovalSettings)
+                state.autoApprovalSettings = {};
+            if (!state.autoApprovalSettings.actions)
+                state.autoApprovalSettings.actions = {};
+            if (config.permissionRules.defaultMode === 'auto') {
+                state.autoApprovalSettings.enabled = true;
+                state.autoApprovalSettings.actions.readFiles = true;
+                state.autoApprovalSettings.actions.editFiles = true;
+                state.autoApprovalSettings.actions.executeSafeCommands = true;
+                state.autoApprovalSettings.actions.useMcp = true;
+            }
+            else if (config.permissionRules.defaultMode === 'default') {
+                state.autoApprovalSettings.enabled = false;
+            }
+        }
+        mkdirSync(join(globalStatePath, '..'), { recursive: true });
+        writeFileSync(globalStatePath, JSON.stringify(state, null, 2));
+    }
+}

package/dist/agents/codex.d.ts

@@ -1,10 +1,15 @@
-import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, McpServerEntry, SkillFile } from './types.js';
 export declare class CodexAdapter implements AgentAdapter {
     name: string;
     slug: string;
     detect(): Promise<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>;
+    readUsageStats(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
+    readVersion(): Promise<string | null>;
 }

package/dist/agents/codex.js

@@ -1,20 +1,16 @@
-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 { parse, stringify } from 'smol-toml';
 import { buildSkillMd } from './types.js';
-import { mergeTomlMcpServers } from './utils/toml-config.js';
+import { writeHintToFile, writeTeamInstructionsToFile } from './utils/instruction-hint.js';
+import { querySqlite } from '../utils/sqlite.js';
+import { whichBinary } from '../utils/which.js';
 export class CodexAdapter {
-    name = 'Codex CLI';
+    name = 'Codex';
     slug = 'codex';
     async detect() {
-        try {
-            execFileSync('which', ['codex'], { stdio: 'pipe' });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return !!whichBinary('codex');
     }
     supportsMcpScope(_scope) {
         return true;
@@ -22,15 +18,31 @@ export class CodexAdapter {
     supportsSkills() {
         return true;
     }
-    async writeMcpServers(servers, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), '.codex', 'config.toml')
-            : join(homedir(), '.codex', 'config.toml');
-        const entries = {};
+    async writeMcpServers(servers, _scope) {
+        // Codex uses config.toml with [mcp_servers.*] sections
+        const configPath = join(homedir(), '.codex', 'config.toml');
+        let parsed = {};
+        if (existsSync(configPath)) {
+            parsed = parse(readFileSync(configPath, 'utf-8'));
+        }
+        if (!parsed.mcp_servers || typeof parsed.mcp_servers !== 'object') {
+            parsed.mcp_servers = {};
+        }
+        const mcpServers = parsed.mcp_servers;
+        // Remove existing runwork-* entries
+        for (const key of Object.keys(mcpServers)) {
+            if (key.startsWith('runwork-'))
+                delete mcpServers[key];
+        }
+        // Add new entries
         for (const s of servers) {
-            entries[s.name] = { url: s.url, bearerTokenEnvVar: 'RUNWORK_API_KEY' };
+            mcpServers[s.name] = {
+                url: s.url,
+                ...(s.headers?.Authorization ? { bearer_token_env_var: 'RUNWORK_MCP_TOKEN' } : {}),
+            };
         }
-        mergeTomlMcpServers(filePath, entries);
+        mkdirSync(join(configPath, '..'), { recursive: true });
+        writeFileSync(configPath, stringify(parsed));
     }
     async writeSkills(skills, scope) {
         const baseDir = scope === 'project'
@@ -42,4 +54,104 @@ export class CodexAdapter {
             writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
         }
     }
+    async writeInstructionHint(hint, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), 'AGENTS.md')
+            : join(homedir(), '.codex', 'instructions.md');
+        writeHintToFile(filePath, hint);
+    }
+    async writeTeamInstructions(instructions, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), 'AGENTS.md')
+            : join(homedir(), '.codex', 'instructions.md');
+        writeTeamInstructionsToFile(filePath, instructions);
+    }
+    // ── Agent config (TOML) ───────────────────────────────────────────
+    async writeAgentConfig(config, scope) {
+        const configPath = scope === 'project'
+            ? join(process.cwd(), '.codex', 'config.toml')
+            : join(homedir(), '.codex', 'config.toml');
+        let parsed = {};
+        if (existsSync(configPath)) {
+            parsed = parse(readFileSync(configPath, 'utf-8'));
+        }
+        if (config.modelPreference) {
+            parsed.model = config.modelPreference;
+        }
+        if (config.permissionRules?.defaultMode) {
+            const modeMap = {
+                auto: 'never',
+                default: 'on-request',
+                plan: 'untrusted',
+            };
+            parsed.approval_policy = modeMap[config.permissionRules.defaultMode] ?? config.permissionRules.defaultMode;
+        }
+        mkdirSync(join(configPath, '..'), { recursive: true });
+        writeFileSync(configPath, stringify(parsed));
+    }
+    // ── Usage stats (passive, best-effort) ─────────────────────────────
+    async readUsageStats(lastSyncAt) {
+        try {
+            const codexDir = join(homedir(), '.codex');
+            if (!existsSync(codexDir))
+                return null;
+            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
+            const sinceSec = Math.floor(sinceMs / 1000);
+            const dbPath = join(codexDir, 'state_5.sqlite');
+            if (!existsSync(dbPath))
+                return null;
+            const countResult = querySqlite(dbPath, `SELECT count(*) FROM threads WHERE created_at > ${sinceSec}`);
+            const sessionCount = parseInt(countResult) || 0;
+            const tokensResult = querySqlite(dbPath, `SELECT coalesce(sum(tokens_used), 0) FROM threads WHERE created_at > ${sinceSec}`);
+            const tokensUsed = parseInt(tokensResult) || 0;
+            const latestResult = querySqlite(dbPath, `SELECT max(updated_at) FROM threads`);
+            const latestSec = parseInt(latestResult) || 0;
+            const versionsResult = querySqlite(dbPath, `SELECT DISTINCT cli_version FROM threads WHERE cli_version IS NOT NULL ORDER BY created_at DESC LIMIT 3`);
+            const versions = versionsResult ? versionsResult.split(/[\r\n]+/).filter(Boolean) : [];
+            let messageCount = 0;
+            const historyPath = join(codexDir, 'history.jsonl');
+            if (existsSync(historyPath)) {
+                const content = readFileSync(historyPath, 'utf-8').trim();
+                if (content) {
+                    for (const line of content.split(/[\r\n]+/)) {
+                        try {
+                            const entry = JSON.parse(line);
+                            if (entry.ts && entry.ts > sinceSec)
+                                messageCount++;
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+            }
+            if (sessionCount === 0 && (latestSec * 1000) <= sinceMs)
+                return null;
+            return {
+                hasNewActivity: sessionCount > 0,
+                sessionCount,
+                messageCount,
+                toolCallCount: 0,
+                tokensUsed,
+                aiLinesAdded: 0,
+                aiLinesRemoved: 0,
+                lastActiveAt: latestSec > 0 ? new Date(latestSec * 1000).toISOString() : null,
+                extra: versions.length > 0 ? { cliVersions: versions } : undefined,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async readVersion() {
+        try {
+            const versionPath = join(homedir(), '.codex', 'version.json');
+            if (existsSync(versionPath)) {
+                const data = JSON.parse(readFileSync(versionPath, 'utf-8'));
+                return data.latest_version ?? null;
+            }
+        }
+        catch { /* best-effort */ }
+        return null;
+    }
 }

package/dist/agents/cursor.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 CursorAdapter implements AgentAdapter {
     name: string;
     slug: string;
@@ -7,4 +7,9 @@ export declare class CursorAdapter 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>;
 }