runwork 0.8.4 → 0.9.1

package/dist/agents/codex.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { parse, stringify } from 'smol-toml';
@@ -10,7 +10,9 @@ function isRunworkManagedCodexKey(key) {
 }
 import { writeHintToFile, writeTeamInstructionsToFile, removeHintFromFile, removeTeamInstructionsFromFile } from './utils/instruction-hint.js';
 import { querySqlite } from '../utils/sqlite.js';
-import { whichBinary } from '../utils/which.js';
+import { whichBinary, isAppRunning } from '../utils/which.js';
+import { runAgentDetection } from './detection.js';
+import { getRegistryAgent } from './registry.js';
 export class CodexAdapter {
     name = 'Codex';
     slug = 'codex';
@@ -107,6 +109,18 @@ export class CodexAdapter {
             };
             parsed.approval_policy = modeMap[config.permissionRules.defaultMode] ?? config.permissionRules.defaultMode;
         }
+        // Apply minimum permission floors: only upgrade, never downgrade
+        if (config.minimumPermissions) {
+            for (const { field, order, minimum } of config.minimumPermissions) {
+                const current = typeof parsed[field] === 'string' ? parsed[field] : '';
+                const currentIdx = order.indexOf(current);
+                const minimumIdx = order.indexOf(minimum);
+                // Upgrade if current is unknown (not in order) or more restrictive than minimum
+                if (currentIdx < minimumIdx) {
+                    parsed[field] = minimum;
+                }
+            }
+        }
         mkdirSync(join(configPath, '..'), { recursive: true });
         writeFileSync(configPath, stringify(parsed));
     }
@@ -225,4 +239,201 @@ export class CodexAdapter {
         catch { /* best-effort */ }
         return null;
     }
+    async readSkillUsage(lastSyncAt) {
+        // Codex rollout JSONL files contain a session_meta entry whose
+        // `instructions` field lists all skills available in the session.
+        // Skills appear as "- name: description (file: path/SKILL.md)".
+        // This gives us reach data (which skills were loaded), not invocation.
+        //
+        // Rollout files live at ~/.codex/sessions/<year>/<month>/<day>/rollout-*.jsonl
+        // and are linked from the threads table via rollout_path.
+        try {
+            const sessionsDir = join(homedir(), '.codex', 'sessions');
+            if (!existsSync(sessionsDir))
+                return null;
+            const sinceMs = lastSyncAt ? new Date(lastSyncAt).getTime() : 0;
+            const skillCounts = new Map();
+            // Walk session directories by year/month/day
+            const walkDir = (dir) => {
+                let entries;
+                try {
+                    entries = readdirSync(dir);
+                }
+                catch {
+                    return;
+                }
+                for (const entry of entries) {
+                    const fullPath = join(dir, entry);
+                    if (entry.endsWith('.jsonl')) {
+                        let fileStat;
+                        try {
+                            fileStat = statSync(fullPath);
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (fileStat.mtimeMs <= sinceMs)
+                            continue;
+                        this.parseRolloutForSkills(fullPath, sinceMs, skillCounts);
+                    }
+                    else {
+                        // Recurse into year/month/day subdirectories
+                        try {
+                            if (statSync(fullPath).isDirectory())
+                                walkDir(fullPath);
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+            };
+            walkDir(sessionsDir);
+            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;
+        }
+    }
+    /** Parse a rollout JSONL file for skill data */
+    parseRolloutForSkills(filePath, sinceMs, skillCounts) {
+        let content;
+        try {
+            content = readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        for (const line of content.split('\n')) {
+            if (!line)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (entry.type !== 'session_meta')
+                continue;
+            const payload = entry.payload;
+            if (!payload)
+                continue;
+            const tsRaw = entry.timestamp;
+            const ts = typeof tsRaw === 'string' ? Date.parse(tsRaw) : 0;
+            if (ts <= sinceMs)
+                continue;
+            const instructions = payload.instructions;
+            if (typeof instructions !== 'string')
+                continue;
+            // Parse "- name: description (file: path/SKILL.md)" entries
+            // from the "### Available skills" section
+            const skillRegex = /^- ([^:]+):\s+.+\(file:\s+.+\/SKILL\.md\)/gm;
+            let match;
+            while ((match = skillRegex.exec(instructions)) !== null) {
+                const skillName = match[1].trim();
+                const existing = skillCounts.get(skillName);
+                if (existing) {
+                    existing.count++;
+                    if (ts > existing.lastTs)
+                        existing.lastTs = ts;
+                }
+                else {
+                    skillCounts.set(skillName, { count: 1, lastTs: ts });
+                }
+            }
+            // Only process the first session_meta per file
+            break;
+        }
+    }
+    // ── Codex Desktop app workspace registration ──────────────────────
+    /**
+     * Register a workspace directory in the Codex desktop app's project list.
+     * Adds the path to electron-saved-workspace-roots, project-order, and
+     * electron-workspace-root-labels. Skips active-workspace-roots to avoid
+     * force-switching the user's active project.
+     *
+     * Returns 'written' if changes were made, 'already_registered' if the
+     * path was already present, or 'app_running' if Codex is open and would
+     * overwrite our changes.
+     */
+    registerDesktopWorkspace(workspacePath, label) {
+        const statePath = join(homedir(), '.codex', '.codex-global-state.json');
+        // Read current state (or start fresh if file doesn't exist)
+        let state = {};
+        if (existsSync(statePath)) {
+            try {
+                state = JSON.parse(readFileSync(statePath, 'utf-8'));
+            }
+            catch {
+                return 'app_running'; // corrupt file, don't touch
+            }
+        }
+        // Check if already registered in all required keys
+        const savedRoots = (Array.isArray(state['electron-saved-workspace-roots'])
+            ? state['electron-saved-workspace-roots'] : []);
+        const projectOrder = (Array.isArray(state['project-order'])
+            ? state['project-order'] : []);
+        const labels = (state['electron-workspace-root-labels'] && typeof state['electron-workspace-root-labels'] === 'object'
+            ? state['electron-workspace-root-labels'] : {});
+        const inSaved = savedRoots.includes(workspacePath);
+        const inOrder = projectOrder.includes(workspacePath);
+        const inLabels = labels[workspacePath] === label;
+        if (inSaved && inOrder && inLabels) {
+            return 'already_registered';
+        }
+        // Codex desktop app holds this file in memory and overwrites on any state
+        // change. Writing while it's open is futile. Check if it's running.
+        if (isAppRunning('Codex')) {
+            return 'app_running';
+        }
+        // Merge our workspace into the state
+        if (!inSaved) {
+            savedRoots.push(workspacePath);
+            state['electron-saved-workspace-roots'] = savedRoots;
+        }
+        if (!inOrder) {
+            projectOrder.push(workspacePath);
+            state['project-order'] = projectOrder;
+        }
+        labels[workspacePath] = label;
+        state['electron-workspace-root-labels'] = labels;
+        mkdirSync(join(statePath, '..'), { recursive: true });
+        writeFileSync(statePath, JSON.stringify(state));
+        return 'written';
+    }
+}
+/**
+ * Codex Desktop (OpenAI's GUI app) reads its config from the same `~/.codex`
+ * directory as the Codex CLI, so every sync/cleanup behavior inherits from
+ * CodexAdapter unchanged. Only the identity (slug/name) and the installation
+ * detection differ -- the desktop app is detected by application bundle
+ * presence, not by a `codex` binary on PATH.
+ */
+export class CodexDesktopAdapter extends CodexAdapter {
+    name = 'Codex';
+    slug = 'codex-app';
+    async detect() {
+        const def = getRegistryAgent('codex-app');
+        if (!def)
+            return false;
+        return runAgentDetection(def.detection);
+    }
+    // Usage stats come from ~/.codex/state_5.sqlite, which is shared between
+    // Codex CLI and Codex Desktop. Leaving the read here would double-count
+    // sessions/tokens whenever both adapters are detected on the same machine.
+    // Defer to CodexAdapter (slug 'codex') as the sole source of Codex stats.
+    async readUsageStats() {
+        return null;
+    }
 }

package/dist/agents/detect.js

@@ -2,7 +2,7 @@ import { ClaudeCodeAdapter } from './claude-code.js';
 import { ClaudeDesktopAdapter } from './claude-desktop.js';
 import { CursorAdapter } from './cursor.js';
 import { WindsurfAdapter } from './windsurf.js';
-import { CodexAdapter } from './codex.js';
+import { CodexAdapter, CodexDesktopAdapter } from './codex.js';
 import { ClineAdapter } from './cline.js';
 import { GeminiAdapter } from './gemini.js';
 import { GenericAgentAdapter } from './generic-adapter.js';
@@ -17,6 +17,7 @@ const CUSTOM_ADAPTERS = [
     new CursorAdapter(),
     new WindsurfAdapter(),
     new CodexAdapter(),
+    new CodexDesktopAdapter(),
     new ClineAdapter(),
     new GeminiAdapter(),
 ];

package/dist/agents/detection.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared agent-installation detection used by the generic adapter and by
+ * custom adapters that opt in to the registry's declared detection rules
+ * (e.g. Codex Desktop, which detects via `/Applications/Codex.app` on macOS
+ * and the AppX package on Windows rather than a `codex` binary on PATH).
+ *
+ * Mirrors the desktop's agent-detection.ts logic but uses Node APIs instead
+ * of Tauri plugins.
+ */
+import type { AgentDetection } from './registry-data.js';
+/**
+ * Synchronous detection — returns true when the agent is installed according
+ * to its registry `detection` rules. Supports every method the desktop app
+ * understands: `binary`, `path`, `windows-appx`, `windows-start-app`, and
+ * nested `any` combinators. Windows-only methods return false off Windows.
+ */
+export declare function runAgentDetection(detection: AgentDetection): boolean;

package/dist/agents/detection.js

@@ -0,0 +1,89 @@
+/**
+ * Shared agent-installation detection used by the generic adapter and by
+ * custom adapters that opt in to the registry's declared detection rules
+ * (e.g. Codex Desktop, which detects via `/Applications/Codex.app` on macOS
+ * and the AppX package on Windows rather than a `codex` binary on PATH).
+ *
+ * Mirrors the desktop's agent-detection.ts logic but uses Node APIs instead
+ * of Tauri plugins.
+ */
+import { execFileSync } from 'child_process';
+import { existsSync } from 'fs';
+import { homedir, platform } from 'os';
+import { isAbsolute, join } from 'path';
+import { whichBinary } from '../utils/which.js';
+import { resolvePlatformString } from './registry.js';
+function isWindows() {
+    return platform() === 'win32';
+}
+function powershellQuote(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function toList(value) {
+    return Array.isArray(value) ? value : [value];
+}
+function runPowerShell(script) {
+    try {
+        execFileSync('powershell', ['-NoProfile', '-Command', script], { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function checkPath(target) {
+    const resolved = resolvePlatformString(target);
+    if (!resolved)
+        return false;
+    if (isAbsolute(resolved))
+        return existsSync(resolved);
+    return existsSync(join(homedir(), resolved));
+}
+function checkWindowsAppxPackage(target) {
+    if (!isWindows())
+        return false;
+    for (const pkg of toList(target)) {
+        const script = `$p = Get-AppxPackage -Name ${powershellQuote(pkg)} -ErrorAction SilentlyContinue; if ($null -ne $p) { exit 0 } exit 1`;
+        if (runPowerShell(script))
+            return true;
+    }
+    return false;
+}
+function checkWindowsStartApp(target) {
+    if (!isWindows())
+        return false;
+    for (const pattern of toList(target)) {
+        const script = `$a = Get-StartApps -Name ${powershellQuote(pattern)} -ErrorAction SilentlyContinue | Select-Object -First 1; if ($null -ne $a) { exit 0 } exit 1`;
+        if (runPowerShell(script))
+            return true;
+    }
+    return false;
+}
+/**
+ * Synchronous detection — returns true when the agent is installed according
+ * to its registry `detection` rules. Supports every method the desktop app
+ * understands: `binary`, `path`, `windows-appx`, `windows-start-app`, and
+ * nested `any` combinators. Windows-only methods return false off Windows.
+ */
+export function runAgentDetection(detection) {
+    switch (detection.method) {
+        case 'binary': {
+            const target = resolvePlatformString(detection.target);
+            return !!target && !!whichBinary(target);
+        }
+        case 'path':
+            return checkPath(detection.target);
+        case 'windows-appx':
+            return checkWindowsAppxPackage(detection.target);
+        case 'windows-start-app':
+            return checkWindowsStartApp(detection.target);
+        case 'any':
+            for (const probe of detection.target) {
+                if (runAgentDetection(probe))
+                    return true;
+            }
+            return false;
+        default:
+            return false;
+    }
+}

package/dist/agents/generic-adapter.js

@@ -1,11 +1,11 @@
 import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'fs';
-import { isAbsolute, join } from 'path';
+import { join } from 'path';
 import { homedir } from 'os';
-import { whichBinary } from '../utils/which.js';
 import { buildSkillMd } from './types.js';
 import { mergeJsonMcpServers, removeRunworkMcpServers } from './utils/json-config.js';
 import { writeHintToFile, writeTeamInstructionsToFile, removeHintFromFile, removeTeamInstructionsFromFile } from './utils/instruction-hint.js';
 import { resolvePlatformString, resolveToAbsolute } from './registry.js';
+import { runAgentDetection } from './detection.js';
 /**
  * Generic adapter that handles any agent from the registry using its
  * skillsPaths, mcpConfigPath, and instructionFile metadata.
@@ -25,17 +25,7 @@ export class GenericAgentAdapter {
         this.slug = def.slug;
     }
     async detect() {
-        const target = resolvePlatformString(this.def.detection.target);
-        if (!target)
-            return false;
-        if (this.def.detection.method === 'binary') {
-            return !!whichBinary(target);
-        }
-        // path detection
-        if (isAbsolute(target)) {
-            return existsSync(target);
-        }
-        return existsSync(join(homedir(), target));
+        return runAgentDetection(this.def.detection);
     }
     supportsMcpScope(scope) {
         if (!this.def.mcpConfigPath)

package/dist/agents/registry-data.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Unified agent registry (types + data + browser-safe lookups).
+ *
+ * This file is the SINGLE SOURCE OF TRUTH for every agent Runwork knows about:
+ * CLI adapters read from here (via `./registry.js`), and the desktop app
+ * re-exports from here (via the `@cli-agent-registry` path alias).
+ *
+ * Keep this file browser-safe: no `os`, `path`, `fs`, or other Node-only
+ * imports. Node-only path resolvers live next to this file in `./registry.ts`.
+ */
+export type AgentCategory = 'cli' | 'ide' | 'desktop' | 'extension';
+/** Platform-specific string. Plain string = same on all platforms. */
+export type PlatformString = string | {
+    default?: string;
+    macos?: string;
+    windows?: string;
+    linux?: string;
+};
+/**
+ * Detection strategy for an agent. Supports simple binary/path checks plus
+ * richer Windows-specific methods and a nested `any` combinator used by the
+ * desktop app to detect agents that ship as both GUI app and CLI binary.
+ */
+export type AgentDetection = {
+    method: 'binary' | 'path';
+    target: PlatformString;
+} | {
+    method: 'windows-appx' | 'windows-start-app';
+    target: string | string[];
+} | {
+    method: 'any';
+    target: AgentDetection[];
+};
+export interface AgentLaunch {
+    app?: {
+        macos?: string;
+        windows?: string;
+        linux?: string;
+    };
+    cli?: string;
+    cliAcceptsPrompt?: boolean;
+}
+export interface AgentQuickStart {
+    launchHint?: string;
+    panelHint?: string;
+    skillCommand?: string;
+    examplePrompts?: string[];
+}
+export interface ManualSetupStep {
+    id: string;
+    label: string;
+}
+/**
+ * Optional downloadable artifact generated inline during a manual setup step
+ * (e.g. a plugin zip the user uploads into the agent).
+ */
+export interface AgentManualSetupArtifact {
+    label: string;
+    filename: string;
+    /** CLI subcommand that generates the artifact, e.g. "build-plugin" */
+    command: string;
+}
+/** Where a manual-setup step is inserted in the onboarding journey. */
+export type ManualSetupSlot = 'installation' | 'connecting' | 'try-it';
+export interface AgentManualSetup {
+    title: string;
+    steps: ManualSetupStep[];
+    opensAgent?: boolean;
+    /** Where in the journey to show this step. Defaults to 'try-it'. */
+    showAfter?: ManualSetupSlot;
+    downloadArtifact?: AgentManualSetupArtifact;
+}
+export interface AgentDefinition {
+    slug: string;
+    name: string;
+    aliases?: string[];
+    description: string;
+    category: AgentCategory;
+    detection: AgentDetection;
+    /** Desktop launch hints (GUI app name, CLI command) */
+    launch?: AgentLaunch;
+    /** Logo identifier used by the desktop UI */
+    logo?: string;
+    /** Public download/install URL shown in the desktop onboarding */
+    downloadUrl?: string;
+    /** Whether the CLI knows how to auto-install this agent */
+    autoInstallable?: boolean;
+    /** Skill file directories relative to $HOME (global) or project root (project) */
+    skillsPaths?: {
+        global?: PlatformString;
+        project?: PlatformString;
+    };
+    /** MCP config file path relative to $HOME */
+    mcpConfigPath?: PlatformString;
+    /** MCP config JSON key where servers are stored (default: 'mcpServers') */
+    mcpConfigKey?: string;
+    /** First-class agent = full Runwork support (custom adapter or rich desktop onboarding) */
+    firstClass?: boolean;
+    /** Instruction file path relative to $HOME (global) or project root (project) */
+    instructionFile?: {
+        global?: PlatformString;
+        project?: PlatformString;
+    };
+    /** Skill file format */
+    skillFormat?: 'skill-md' | 'mdc' | 'windsurf-md' | 'gemini-flat';
+    /** Desktop onboarding hint copy */
+    quickStart?: AgentQuickStart;
+    /** Manual setup steps required after installation (desktop onboarding) */
+    manualSetup?: AgentManualSetup;
+}
+export declare function getAgent(slug: string): AgentDefinition | undefined;
+export declare function getAgentByName(name: string): AgentDefinition | undefined;
+export declare function getAgents(): AgentDefinition[];
+export declare function getDetectableAgents(): AgentDefinition[];
+export declare function getLaunchableAgents(): AgentDefinition[];
+export declare function getFirstClassAgents(): AgentDefinition[];
+export declare function getAgentsByCategory(category: AgentCategory): AgentDefinition[];
+export declare function isCLIAgent(slug: string): boolean;
+export declare function isIDEAgent(slug: string): boolean;
+export declare function isDesktopAgent(slug: string): boolean;
+/** Alias of {@link getAgent} kept for backward compatibility with CLI callers. */
+export declare const getRegistryAgent: typeof getAgent;
+/** Alias of {@link getAgents} kept for backward compatibility with CLI callers. */
+export declare const getRegistryAgents: typeof getAgents;
+export declare function getFirstClassSlugs(): string[];
+export declare function getCustomAdapterSlugs(): Set<string>;