runwork 0.15.0 → 0.15.2

package/dist/agents/types.d.ts

@@ -1,171 +0,0 @@
-export interface McpServerEntry {
-    name: string;
-    url: string;
-    transport: 'sse' | 'streamable-http';
-    headers?: Record<string, string>;
-    description?: string;
-}
-export interface SkillFile {
-    name: string;
-    filename: string;
-    content: string;
-    description: string;
-    appId?: string;
-}
-export interface AgentAdapter {
-    /** Display name, e.g. "Claude Code" */
-    name: string;
-    /** CLI identifier, e.g. "claude-code" */
-    slug: string;
-    /** Check if this agent is installed */
-    detect(): Promise<boolean>;
-    /** Write MCP server configs (merge with existing, only touch runwork-* entries) */
-    writeMcpServers(servers: McpServerEntry[], scope: 'project' | 'user'): Promise<void>;
-    /** Write skill files to agent's skills directory */
-    writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
-    /** Write a minimal Runwork hint to the agent's instruction file (CLAUDE.md, AGENTS.md, etc.) */
-    writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
-    /** Whether this agent supports skills/commands */
-    supportsSkills(): boolean;
-    /** Whether this agent supports MCP config at the given scope */
-    supportsMcpScope(scope: 'project' | 'user'): boolean;
-    /** True when this agent's skill files overlap with MCP skill_* tools (skip writing app skills when MCP is configured) */
-    mcpProvidesSkills?: boolean;
-    /** Write team-managed instructions (separate marker block from auto-generated hint) */
-    writeTeamInstructions?(instructions: string, scope: 'project' | 'user'): Promise<void>;
-    /**
-     * Install the runwork SessionStart hook (or any equivalent platform-managed
-     * hook) into the agent's hook directory. Called once per (adapter, scope) by
-     * the main sync loop, AFTER writeSkills has fully populated the plugin tree.
-     * Separate from writeSkills because writeSkills is also invoked per-skill by
-     * the diff executor during push/pull, and hook installation must not be
-     * repeated for every skill.
-     *
-     * Optional - only adapters with a hook system implement it (Claude Code,
-     * eventually Claude Desktop Cowork plugin tree).
-     */
-    writeBuiltInHooks?(scope: 'project' | 'user'): Promise<void>;
-    /**
-     * Write agent-specific config overrides from workspace admin (model, permissions).
-     *
-     * @param config - The full resolved config to apply this sync (already merged
-     *   with baked defaults and network/minimum settings by the sync loop).
-     * @param scope - Project- or user-scope configuration target.
-     * @param baseline - Optional. The set of managed entries the previous sync
-     *   wrote (lastInjected from setup.json). Adapters that lack on-disk markers
-     *   to distinguish runwork-managed entries from user-added entries (e.g.
-     *   Cursor's yoloCommandAllowlist) use this to subtract our previous
-     *   contribution before re-injecting, preserving user edits. Marker-based
-     *   adapters (Claude Code) can ignore this parameter.
-     */
-    writeAgentConfig?(config: AgentConfigOverride, scope: 'project' | 'user', baseline?: {
-        allow?: string[];
-        deny?: string[];
-    }): Promise<void>;
-    /**
-     * Read the currently-injected managed-block entries for this scope.
-     * Used by sync to detect when the user has removed an entry that we
-     * previously injected (so we can record it as a sticky opt-out).
-     *
-     * For marker-based adapters (Claude Code): returns items after the marker.
-     * For markerless adapters (Cursor): may return undefined; the sync loop
-     * falls back to the `baseline` mechanism (state.lastInjected) for those.
-     * Optional — adapters without a permission file at all (Cline) skip this.
-     */
-    readManagedBlock?(scope: 'project' | 'user'): Promise<{
-        allow?: string[];
-        deny?: string[];
-    } | undefined>;
-    /** Remove all Runwork-managed config, skills, MCP entries, and instruction hints.
-     *  The manifest lists exactly which resources were synced so only those are removed. */
-    cleanup?(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
-    /** Read passive usage stats from local agent files (best-effort, no hooks) */
-    readUsageStats?(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
-    /** Read which skills were used locally since last sync (best-effort) */
-    readSkillUsage?(lastSyncAt: string | null): Promise<SkillUsageEntry[] | null>;
-    /** Get the agent's version string (best-effort) */
-    readVersion?(): Promise<string | null>;
-    /**
-     * Build an installable plugin archive for this agent. Implementations
-     * generate their agent-specific plugin layout into a temporary directory
-     * and zip it to `outputPath`. `teamInstructions` is the merged string of
-     * workspace team instructions + per-agent extra instructions (or null if
-     * none are configured) — adapters should embed them in the archive so
-     * uploaded zips match what a normal sync would write. Only adapters whose
-     * target agent has a plugin upload flow implement this (e.g. Claude Desktop).
-     */
-    buildPluginZip?(skills: SkillFile[], mcpServers: McpServerEntry[], teamInstructions: string | null, outputPath: string): Promise<void>;
-}
-/**
- * Exact list of resources that Runwork synced to this agent.
- * Cleanup must only remove these specific items, nothing else.
- */
-export interface CleanupManifest {
-    /** Skill directory/file names that were written (kebab-case slugs) */
-    skillFilenames: string[];
-    /** MCP server entry names that were registered */
-    mcpServerNames: string[];
-}
-export interface AgentConfigOverride {
-    extraInstructions?: string;
-    modelPreference?: string;
-    permissionRules?: {
-        allow?: string[];
-        deny?: string[];
-        defaultMode?: string;
-    };
-    /** Domains to allowlist in the agent's sandbox/network config (e.g. for Cursor CLI sandbox) */
-    networkAllowlist?: string[];
-    /**
-     * Minimum permission levels required for Runwork tools to function.
-     * Adapters should only UPGRADE restrictive settings, never downgrade
-     * more permissive ones. Keys are agent-specific config field names,
-     * values are ordered arrays from most restrictive to least, plus
-     * the minimum required value.
-     */
-    minimumPermissions?: Array<{
-        field: string;
-        order: string[];
-        minimum: string;
-    }>;
-}
-export interface AgentUsageStats {
-    hasNewActivity: boolean;
-    sessionCount: number;
-    messageCount: number;
-    toolCallCount: number;
-    tokensUsed: number;
-    aiLinesAdded: number;
-    aiLinesRemoved: number;
-    lastActiveAt: string | null;
-    modelsUsed?: string[];
-    mcpToolCount?: number;
-    extra?: Record<string, unknown>;
-}
-export interface SkillUsageEntry {
-    skillName: string;
-    count: number;
-    lastUsedAt: string;
-}
-/** Prefix for MCP server entries managed by runwork */
-export declare const RUNWORK_MCP_PREFIX = "Runwork: ";
-/** Legacy prefix used before human-readable names were introduced */
-export declare const RUNWORK_MCP_PREFIX_LEGACY = "runwork-";
-/**
- * Top-level name for the Runwork workspace tools MCP server.
- * Kept short (no prefix) so agents surface tools as `mcp__Runwork__*`
- * instead of the visually noisy `mcp__Runwork_Workspace_Tools__*`.
- */
-export declare const RUNWORK_WORKSPACE_MCP_NAME = "Runwork";
-/**
- * Append an auth token to a URL as a query parameter.
- * The server extracts this via its standard token extraction (query param fallback).
- */
-export declare function appendTokenToUrl(url: string, token: string): string;
-/**
- * Convert a skill display name to a kebab-case slug safe for slash commands.
- * Spaces in skill names break slash command parsing (e.g. "/Write Cold Email"
- * gets parsed as skill "Write" with args "Cold Email").
- */
-export declare function toSlug(name: string): string;
-export declare function buildSkillMd(skill: SkillFile): string;

package/dist/agents/types.js

@@ -1,75 +0,0 @@
-/** Prefix for MCP server entries managed by runwork */
-export const RUNWORK_MCP_PREFIX = 'Runwork: ';
-/** Legacy prefix used before human-readable names were introduced */
-export const RUNWORK_MCP_PREFIX_LEGACY = 'runwork-';
-/**
- * Top-level name for the Runwork workspace tools MCP server.
- * Kept short (no prefix) so agents surface tools as `mcp__Runwork__*`
- * instead of the visually noisy `mcp__Runwork_Workspace_Tools__*`.
- */
-export const RUNWORK_WORKSPACE_MCP_NAME = 'Runwork';
-/**
- * Append an auth token to a URL as a query parameter.
- * The server extracts this via its standard token extraction (query param fallback).
- */
-export function appendTokenToUrl(url, token) {
-    const parsed = new URL(url);
-    parsed.searchParams.set('token', token);
-    return parsed.toString();
-}
-/**
- * Convert a skill display name to a kebab-case slug safe for slash commands.
- * Spaces in skill names break slash command parsing (e.g. "/Write Cold Email"
- * gets parsed as skill "Write" with args "Cold Email").
- */
-export function toSlug(name) {
-    return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-}
-/**
- * Build a SKILL.md file with YAML frontmatter.
- * Ensures the content always has proper frontmatter for agent discovery.
- * The name field is always kebab-cased to work as a slash command.
- */
-/**
- * Quote a YAML value if it contains characters that would break parsing
- * (colons, brackets, quotes, leading/trailing spaces, etc.)
- */
-function yamlQuote(value) {
-    if (/[:#\[\]{}|>&*!,?'"]/.test(value) || value !== value.trim()) {
-        // Use double quotes, escaping internal double quotes and backslashes
-        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-        return `"${escaped}"`;
-    }
-    return value;
-}
-export function buildSkillMd(skill) {
-    const description = skill.description || `${skill.name} skill`;
-    const slug = toSlug(skill.name);
-    const safeDescription = yamlQuote(description);
-    if (skill.content.trimStart().startsWith('---\n')) {
-        let content = skill.content;
-        // Normalize name to kebab-case slug (spaces break slash command parsing)
-        content = content.replace(/^(name:\s*)["']?[^"'\n]+["']?\s*$/m, `$1${slug}`);
-        // Normalize description: ensure space after colon, strip nested quotes, and quote if needed
-        content = content.replace(/^description:\s*(.+)$/m, (_match, rawValue) => {
-            // Strip wrapping quotes and escaped quotes from the raw value
-            let cleaned = rawValue.trim();
-            // Remove outer quotes if present (single or double)
-            if ((cleaned.startsWith('"') && cleaned.endsWith('"')) || (cleaned.startsWith("'") && cleaned.endsWith("'"))) {
-                cleaned = cleaned.slice(1, -1);
-            }
-            // Remove escaped quotes left from double-wrapping (e.g. \"value\")
-            cleaned = cleaned.replace(/\\"/g, '"');
-            // Strip any remaining wrapping quotes after unescaping
-            if ((cleaned.startsWith('"') && cleaned.endsWith('"')) || (cleaned.startsWith("'") && cleaned.endsWith("'"))) {
-                cleaned = cleaned.slice(1, -1);
-            }
-            return `description: ${yamlQuote(cleaned)}`;
-        });
-        const hasDescription = /^description:\s*.+$/m.test(content);
-        if (hasDescription)
-            return content;
-        return content.replace(/^---\n/, `---\nname: ${slug}\ndescription: ${safeDescription}\n`);
-    }
-    return `---\nname: ${slug}\ndescription: ${safeDescription}\n---\n\n${skill.content}`;
-}

package/dist/agents/utils/instruction-hint.d.ts

@@ -1,21 +0,0 @@
-/**
- * Append or replace a Runwork instruction hint in an agent's instruction file.
- * If the file contains existing Runwork markers, replaces that section.
- * Otherwise appends the hint at the end.
- */
-export declare function writeHintToFile(filePath: string, hint: string): void;
-/**
- * Append or replace team instructions in an agent's instruction file.
- * Uses separate markers from the auto-generated hint so both coexist.
- */
-/**
- * Remove the Runwork instruction hint from an agent's instruction file.
- * Returns true if something was removed.
- */
-export declare function removeHintFromFile(filePath: string): boolean;
-/**
- * Remove Runwork team instructions from an agent's instruction file.
- * Returns true if something was removed.
- */
-export declare function removeTeamInstructionsFromFile(filePath: string): boolean;
-export declare function writeTeamInstructionsToFile(filePath: string, instructions: string): void;

package/dist/agents/utils/instruction-hint.js

@@ -1,108 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
-const START_MARKER = '<!-- runwork:start -->';
-const END_MARKER = '<!-- runwork:end -->';
-const TEAM_START_MARKER = '<!-- runwork-team:start -->';
-const TEAM_END_MARKER = '<!-- runwork-team:end -->';
-/**
- * Append or replace a Runwork instruction hint in an agent's instruction file.
- * If the file contains existing Runwork markers, replaces that section.
- * Otherwise appends the hint at the end.
- */
-export function writeHintToFile(filePath, hint) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    let content = '';
-    if (existsSync(filePath)) {
-        content = readFileSync(filePath, 'utf-8');
-    }
-    const startIdx = content.indexOf(START_MARKER);
-    const endIdx = content.indexOf(END_MARKER);
-    if (startIdx >= 0 && endIdx >= 0) {
-        // Replace existing section
-        content = content.substring(0, startIdx) + hint + content.substring(endIdx + END_MARKER.length);
-    }
-    else {
-        // Append with spacing
-        if (content.length > 0 && !content.endsWith('\n')) {
-            content += '\n';
-        }
-        if (content.length > 0) {
-            content += '\n';
-        }
-        content += hint + '\n';
-    }
-    writeFileSync(filePath, content);
-}
-/**
- * Append or replace team instructions in an agent's instruction file.
- * Uses separate markers from the auto-generated hint so both coexist.
- */
-/**
- * Remove the Runwork instruction hint from an agent's instruction file.
- * Returns true if something was removed.
- */
-export function removeHintFromFile(filePath) {
-    if (!existsSync(filePath))
-        return false;
-    let content = readFileSync(filePath, 'utf-8');
-    const startIdx = content.indexOf(START_MARKER);
-    const endIdx = content.indexOf(END_MARKER);
-    if (startIdx < 0 || endIdx < 0)
-        return false;
-    content = content.substring(0, startIdx) + content.substring(endIdx + END_MARKER.length);
-    // Clean up extra blank lines left behind
-    content = content.replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
-    if (content.trim() === '') {
-        // File is now empty, could remove it but safer to leave a minimal file
-        writeFileSync(filePath, '');
-    }
-    else {
-        writeFileSync(filePath, content);
-    }
-    return true;
-}
-/**
- * Remove Runwork team instructions from an agent's instruction file.
- * Returns true if something was removed.
- */
-export function removeTeamInstructionsFromFile(filePath) {
-    if (!existsSync(filePath))
-        return false;
-    let content = readFileSync(filePath, 'utf-8');
-    const startIdx = content.indexOf(TEAM_START_MARKER);
-    const endIdx = content.indexOf(TEAM_END_MARKER);
-    if (startIdx < 0 || endIdx < 0)
-        return false;
-    content = content.substring(0, startIdx) + content.substring(endIdx + TEAM_END_MARKER.length);
-    content = content.replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
-    if (content.trim() === '') {
-        writeFileSync(filePath, '');
-    }
-    else {
-        writeFileSync(filePath, content);
-    }
-    return true;
-}
-export function writeTeamInstructionsToFile(filePath, instructions) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    let content = '';
-    if (existsSync(filePath)) {
-        content = readFileSync(filePath, 'utf-8');
-    }
-    const block = `${TEAM_START_MARKER}\n${instructions}\n${TEAM_END_MARKER}`;
-    const startIdx = content.indexOf(TEAM_START_MARKER);
-    const endIdx = content.indexOf(TEAM_END_MARKER);
-    if (startIdx >= 0 && endIdx >= 0) {
-        content = content.substring(0, startIdx) + block + content.substring(endIdx + TEAM_END_MARKER.length);
-    }
-    else {
-        if (content.length > 0 && !content.endsWith('\n')) {
-            content += '\n';
-        }
-        if (content.length > 0) {
-            content += '\n';
-        }
-        content += block + '\n';
-    }
-    writeFileSync(filePath, content);
-}

package/dist/agents/utils/json-config.d.ts

@@ -1,19 +0,0 @@
-/**
- * Read a JSON config file. Returns empty object if file doesn't exist.
- */
-export declare function readJsonConfig(filePath: string): Record<string, unknown>;
-/**
- * Write a JSON config file, creating parent directories as needed.
- */
-export declare function writeJsonConfig(filePath: string, config: Record<string, unknown>): void;
-/**
- * Remove all Runwork-managed MCP server entries from a JSON config file.
- * Returns true if any entries were removed.
- */
-export declare function removeRunworkMcpServers(filePath: string, topKey: string): boolean;
-/**
- * Merge MCP server entries into a JSON config file.
- * Removes all existing runwork-managed entries, adds new ones.
- * Preserves user's non-runwork entries.
- */
-export declare function mergeJsonMcpServers(filePath: string, servers: Record<string, Record<string, unknown>>, topKey: string): void;

package/dist/agents/utils/json-config.js

@@ -1,69 +0,0 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
-import { dirname } from 'path';
-import { RUNWORK_MCP_PREFIX, RUNWORK_MCP_PREFIX_LEGACY, RUNWORK_WORKSPACE_MCP_NAME, } from '../types.js';
-function isRunworkManagedKey(key) {
-    return (key === RUNWORK_WORKSPACE_MCP_NAME ||
-        key.startsWith(RUNWORK_MCP_PREFIX) ||
-        key.startsWith(RUNWORK_MCP_PREFIX_LEGACY));
-}
-/**
- * Read a JSON config file. Returns empty object if file doesn't exist.
- */
-export function readJsonConfig(filePath) {
-    if (!existsSync(filePath))
-        return {};
-    try {
-        return JSON.parse(readFileSync(filePath, 'utf-8'));
-    }
-    catch {
-        return {};
-    }
-}
-/**
- * Write a JSON config file, creating parent directories as needed.
- */
-export function writeJsonConfig(filePath, config) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n');
-}
-/**
- * Remove all Runwork-managed MCP server entries from a JSON config file.
- * Returns true if any entries were removed.
- */
-export function removeRunworkMcpServers(filePath, topKey) {
-    if (!existsSync(filePath))
-        return false;
-    const config = readJsonConfig(filePath);
-    const existing = (config[topKey] || {});
-    let removed = false;
-    for (const key of Object.keys(existing)) {
-        if (isRunworkManagedKey(key)) {
-            delete existing[key];
-            removed = true;
-        }
-    }
-    if (removed) {
-        config[topKey] = existing;
-        writeJsonConfig(filePath, config);
-    }
-    return removed;
-}
-/**
- * Merge MCP server entries into a JSON config file.
- * Removes all existing runwork-managed entries, adds new ones.
- * Preserves user's non-runwork entries.
- */
-export function mergeJsonMcpServers(filePath, servers, topKey) {
-    const config = readJsonConfig(filePath);
-    const existing = (config[topKey] || {});
-    // Remove all Runwork-managed entries (current, legacy, and the bare "Runwork" name)
-    for (const key of Object.keys(existing)) {
-        if (isRunworkManagedKey(key)) {
-            delete existing[key];
-        }
-    }
-    // Add new runwork entries
-    Object.assign(existing, servers);
-    config[topKey] = existing;
-    writeJsonConfig(filePath, config);
-}

package/dist/agents/utils/toml-config.d.ts

@@ -1,8 +0,0 @@
-/**
- * Merge MCP servers into a Codex config.toml file.
- * Removes existing [mcp_servers.runwork-*] sections, adds new ones.
- */
-export declare function mergeTomlMcpServers(filePath: string, servers: Record<string, {
-    url: string;
-    bearerTokenEnvVar?: string;
-}>): void;

package/dist/agents/utils/toml-config.js

@@ -1,27 +0,0 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
-import { dirname } from 'path';
-/**
- * Merge MCP servers into a Codex config.toml file.
- * Removes existing [mcp_servers.runwork-*] sections, adds new ones.
- */
-export function mergeTomlMcpServers(filePath, servers) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    let content = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '';
-    // Remove existing runwork-* mcp_servers sections
-    content = content.replace(/\[mcp_servers\.runwork-[^\]]*\]\n(?:[^\[]*\n?)*/g, '');
-    // Remove trailing blank lines
-    content = content.trimEnd();
-    // Append new sections
-    const sections = [];
-    for (const [name, config] of Object.entries(servers)) {
-        const lines = [`[mcp_servers.${name}]`, `url = "${config.url}"`];
-        if (config.bearerTokenEnvVar) {
-            lines.push(`bearer_token_env_var = "${config.bearerTokenEnvVar}"`);
-        }
-        sections.push(lines.join('\n'));
-    }
-    if (sections.length > 0) {
-        content += '\n\n' + sections.join('\n\n') + '\n';
-    }
-    writeFileSync(filePath, content);
-}

package/dist/agents/windsurf.d.ts

@@ -1,14 +0,0 @@
-import type { AgentAdapter, CleanupManifest, McpServerEntry, SkillFile } from './types.js';
-export declare class WindsurfAdapter implements AgentAdapter {
-    name: string;
-    slug: string;
-    mcpProvidesSkills: boolean;
-    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>;
-    writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
-    writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
-    cleanup(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
-}

package/dist/agents/windsurf.js

@@ -1,102 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { homedir, platform } from 'os';
-import { whichBinary } from '../utils/which.js';
-import { mergeJsonMcpServers, removeRunworkMcpServers } from './utils/json-config.js';
-function getWindsurfDataDir() {
-    if (platform() === 'win32') {
-        return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Codeium', 'windsurf');
-    }
-    return join(homedir(), '.codeium', 'windsurf');
-}
-function getConfigPath() {
-    return join(getWindsurfDataDir(), 'mcp_config.json');
-}
-export class WindsurfAdapter {
-    name = 'Windsurf';
-    slug = 'windsurf';
-    mcpProvidesSkills = true;
-    async detect() {
-        const os = platform();
-        if (os === 'darwin' && existsSync('/Applications/Windsurf.app'))
-            return true;
-        return !!whichBinary('windsurf');
-    }
-    supportsMcpScope(scope) {
-        return scope === 'user';
-    }
-    supportsSkills() {
-        return true;
-    }
-    async writeMcpServers(servers, _scope) {
-        const entries = {};
-        for (const s of servers) {
-            entries[s.name] = {
-                serverUrl: s.url,
-                ...(s.headers ? { headers: s.headers } : {}),
-            };
-        }
-        mergeJsonMcpServers(getConfigPath(), entries, 'mcpServers');
-    }
-    async writeSkills(skills, scope) {
-        if (scope === 'user')
-            return;
-        const rulesDir = join(process.cwd(), '.windsurf', 'rules');
-        mkdirSync(rulesDir, { recursive: true });
-        for (const skill of skills) {
-            const content = `---\ntrigger: manual\n---\n\n${skill.content}`;
-            writeFileSync(join(rulesDir, `${skill.filename}.md`), content);
-        }
-    }
-    async writeTeamInstructions(instructions, scope) {
-        const filePath = scope === 'project'
-            ? join(process.cwd(), '.windsurf', 'rules', 'runwork-team.md')
-            : join(getWindsurfDataDir(), 'rules', 'runwork-team.md');
-        const content = `---\ntrigger: always_on\ndescription: "Team instructions from Runwork workspace"\n---\n\n${instructions}`;
-        mkdirSync(join(filePath, '..'), { recursive: true });
-        writeFileSync(filePath, content);
-    }
-    async writeInstructionHint(hint, scope) {
-        // Windsurf uses rules files
-        const filePath = scope === 'project'
-            ? join(process.cwd(), '.windsurf', 'rules', 'runwork.md')
-            : join(getWindsurfDataDir(), 'rules', 'runwork.md');
-        const content = `---\ntrigger: always\n---\n\n${hint}`;
-        mkdirSync(join(filePath, '..'), { recursive: true });
-        writeFileSync(filePath, content);
-    }
-    // ── Cleanup (uninstall) ────────────────────────────────────────────
-    async cleanup(scope, manifest) {
-        // 1. Remove MCP entries (user scope only)
-        if (scope === 'user') {
-            removeRunworkMcpServers(getConfigPath(), 'mcpServers');
-        }
-        // 2. Remove rule files
-        const rulesDir = scope === 'project'
-            ? join(process.cwd(), '.windsurf', 'rules')
-            : join(getWindsurfDataDir(), 'rules');
-        if (existsSync(rulesDir)) {
-            for (const file of ['runwork.md', 'runwork-team.md']) {
-                const filePath = join(rulesDir, file);
-                if (existsSync(filePath)) {
-                    try {
-                        unlinkSync(filePath);
-                    }
-                    catch { /* best-effort */ }
-                }
-            }
-            // Remove only skill .md files that we synced
-            if (manifest?.skillFilenames.length) {
-                const allowed = new Set(manifest.skillFilenames.map(f => `${f}.md`));
-                for (const entry of readdirSync(rulesDir)) {
-                    if (allowed.has(entry)) {
-                        try {
-                            unlinkSync(join(rulesDir, entry));
-                        }
-                        catch { /* best-effort */ }
-                    }
-                }
-            }
-        }
-    }
-}

package/dist/api/__tests__/client.test.d.ts

@@ -1 +0,0 @@
-export {};