runwork 0.15.0 → 0.15.2

package/dist/commands/skills.js

@@ -1,352 +0,0 @@
-import { Command } from 'commander';
-import { readFileSync, existsSync } from 'fs';
-import { requireAuth } from '../auth/store.js';
-import { ApiClient } from '../api/client.js';
-import { resolveWorkspace } from '../workspace/resolve.js';
-import { shouldOutputJson, jsonOut } from '../utils/output.js';
-function truncate(text, max) {
-    if (!text)
-        return '';
-    const first = text.split('\n')[0];
-    if (first.length <= max)
-        return first;
-    return first.slice(0, max - 3) + '...';
-}
-const listCommand = new Command('list')
-    .description('List workspace skills (app, external, MCP-generated)')
-    .option('--workspace <id>', 'Workspace ID')
-    .action(async (opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId, workspaceName } = await resolveWorkspace(client, opts);
-    try {
-        const skills = await client.listWorkspaceSkills(workspaceId);
-        if (useJson) {
-            jsonOut({ skills });
-            return;
-        }
-        if (skills.length === 0) {
-            console.log('No skills found in this workspace.');
-            return;
-        }
-        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
-        const appSkills = skills.filter(s => s.type === 'app');
-        const externalSkills = skills.filter(s => s.type === 'external');
-        const mcpSkills = skills.filter(s => s.type === 'mcp');
-        if (appSkills.length > 0) {
-            console.log('  App Skills (auto-generated)');
-            console.log('  ' + '-'.repeat(40));
-            for (const s of appSkills) {
-                console.log(`  ${s.name.padEnd(24)} ${truncate(s.description, 60)}`);
-            }
-            console.log('');
-        }
-        if (externalSkills.length > 0) {
-            console.log('  External Skills');
-            console.log('  ' + '-'.repeat(40));
-            for (const s of externalSkills) {
-                console.log(`  ${s.name.padEnd(24)} ${truncate(s.description, 60)}`);
-            }
-            console.log('');
-        }
-        if (mcpSkills.length > 0) {
-            console.log('  MCP-Generated Skills');
-            console.log('  ' + '-'.repeat(40));
-            for (const s of mcpSkills) {
-                console.log(`  ${s.name.padEnd(24)} ${truncate(s.description, 60)}`);
-            }
-            console.log('');
-        }
-    }
-    catch (err) {
-        console.error('Failed to list skills:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-        chunks.push(Buffer.from(chunk));
-    }
-    return Buffer.concat(chunks).toString('utf-8');
-}
-const pushCommand = new Command('push')
-    .description('Upload a local skill file to workspace (upsert by name). Accepts piped content via stdin.')
-    .argument('[first]', 'Skill name (if piping content) or file path (name from frontmatter)')
-    .argument('[second]', 'File path (when first arg is the skill name)')
-    .option('--workspace <id>', 'Workspace ID')
-    .action(async (first, second, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    // Resolve args: figure out which is the name and which is the file
-    let nameArg;
-    let filePath;
-    if (first && second) {
-        // Two args: name + file
-        nameArg = first;
-        filePath = second;
-    }
-    else if (first) {
-        // One arg: is it a file or a name?
-        if (existsSync(first)) {
-            filePath = first;
-        }
-        else if (!process.stdin.isTTY) {
-            // Not a file and stdin has data: treat as name, read from stdin
-            nameArg = first;
-        }
-        else {
-            // Assume it's a file path that doesn't exist
-            console.error(`File not found: ${first}`);
-            process.exit(1);
-        }
-    }
-    else if (!process.stdin.isTTY) {
-        // No args, stdin has data: read from stdin, name must be in frontmatter
-    }
-    else {
-        console.error('Usage:\n  runwork skills push <file>\n  runwork skills push <name> <file>\n  cat skill.md | runwork skills push <name>');
-        process.exit(1);
-    }
-    // Read content from file or stdin
-    let content;
-    if (filePath) {
-        if (!existsSync(filePath)) {
-            console.error(`File not found: ${filePath}`);
-            process.exit(1);
-        }
-        content = readFileSync(filePath, 'utf-8');
-    }
-    else {
-        content = await readStdin();
-        if (!content.trim()) {
-            console.error('No input received from stdin.');
-            process.exit(1);
-        }
-    }
-    try {
-        // Parse frontmatter
-        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-        let name = nameArg || '';
-        let description = '';
-        let body = content;
-        if (frontmatterMatch) {
-            const fm = frontmatterMatch[1];
-            body = frontmatterMatch[2];
-            const descMatch = fm.match(/^description:\s*(.+)$/m);
-            if (descMatch)
-                description = descMatch[1].trim();
-            if (!name) {
-                const nameMatch = fm.match(/^name:\s*(.+)$/m);
-                if (nameMatch)
-                    name = nameMatch[1].trim();
-            }
-        }
-        if (!name) {
-            console.error('Skill name required. Provide as first argument or in YAML frontmatter:\n  runwork skills push "My Skill" ./skill.md\n  cat skill.md | runwork skills push "My Skill"');
-            process.exit(1);
-        }
-        // Check if skill already exists (upsert by name)
-        const existing = await client.listExternalSkills(workspaceId);
-        const match = existing.find(s => s.name === name);
-        if (match) {
-            const updated = await client.updateExternalSkill(workspaceId, match.id, {
-                name, description, content: body,
-            });
-            if (useJson) {
-                jsonOut({ skill: updated, action: 'updated' });
-                return;
-            }
-            console.log(`Updated skill "${name}" in workspace.`);
-        }
-        else {
-            const created = await client.importExternalSkill(workspaceId, {
-                name, description, content: body, importedFrom: 'cli',
-            });
-            if (useJson) {
-                jsonOut({ skill: created, action: 'created' });
-                return;
-            }
-            console.log(`Created skill "${name}" in workspace.`);
-        }
-        console.log('Run `runwork sync` to update your local agent configs.');
-    }
-    catch (err) {
-        console.error('Failed to push skill:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const pullCommand = new Command('pull')
-    .alias('download')
-    .description('Download a skill from the workspace and print to stdout (or save to file)')
-    .argument('<name>', 'Skill name or ID')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('-o, --output <file>', 'Save to file instead of stdout')
-    .action(async (nameOrId, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    try {
-        // Search external skills first
-        const externalSkills = await client.listExternalSkills(workspaceId);
-        const externalMatch = externalSkills.find(s => s.id === nameOrId || s.name === nameOrId || s.name.toLowerCase() === nameOrId.toLowerCase());
-        if (externalMatch) {
-            if (!externalMatch.content) {
-                console.error(`Skill "${externalMatch.name}" exists but has no content.`);
-                process.exit(1);
-            }
-            const fullContent = buildSkillOutput(externalMatch.name, externalMatch.description, externalMatch.content);
-            if (useJson) {
-                jsonOut({ skill: externalMatch });
-                return;
-            }
-            if (opts.output) {
-                const { writeFileSync: writeFile } = await import('fs');
-                writeFile(opts.output, fullContent);
-                console.error(`Saved skill "${externalMatch.name}" to ${opts.output}`);
-            }
-            else {
-                process.stdout.write(fullContent);
-            }
-            return;
-        }
-        // Search app skills (includeContent to avoid a second round-trip)
-        const allSkills = await client.listWorkspaceSkills(workspaceId, true);
-        const appSkill = allSkills.find(s => s.id === nameOrId || s.name === nameOrId || s.name.toLowerCase() === nameOrId.toLowerCase());
-        if (appSkill?.appId) {
-            const content = appSkill.content;
-            if (!content) {
-                console.error(`Skill "${appSkill.name}" exists but has no content yet.`);
-                process.exit(1);
-            }
-            if (useJson) {
-                jsonOut({ skill: { name: appSkill.name, type: appSkill.type, content } });
-                return;
-            }
-            if (opts.output) {
-                const { writeFileSync: writeFile } = await import('fs');
-                writeFile(opts.output, content);
-                console.error(`Saved skill "${appSkill.name}" to ${opts.output}`);
-            }
-            else {
-                process.stdout.write(content);
-            }
-            return;
-        }
-        // Also check MCP-generated skills (they don't have downloadable content)
-        const mcpSkill = allSkills.find(s => s.type === 'mcp' && (s.id === nameOrId || s.name === nameOrId || s.name.toLowerCase() === nameOrId.toLowerCase()));
-        if (mcpSkill) {
-            console.error(`Skill "${mcpSkill.name}" is auto-generated from an MCP server and cannot be downloaded.`);
-            process.exit(1);
-        }
-        console.error(`Skill "${nameOrId}" not found. Run \`runwork skills list\` to see available skills.`);
-        process.exit(1);
-    }
-    catch (err) {
-        console.error('Failed to pull skill:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-function buildSkillOutput(name, description, content) {
-    // If content already has frontmatter, return as-is
-    if (content.trimStart().startsWith('---\n'))
-        return content;
-    return `---\nname: ${name}\ndescription: ${description}\n---\n\n${content}`;
-}
-pushCommand.alias('upload');
-const searchCommand = new Command('search')
-    .description('Search community skills from skills.sh')
-    .argument('<query>', 'Search query')
-    .option('--limit <n>', 'Max results (1-50)', '10')
-    .action(async (query, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    try {
-        const results = await client.searchCommunitySkills(query, Number(opts.limit));
-        if (useJson) {
-            jsonOut(results);
-            return;
-        }
-        if (results.skills.length === 0) {
-            console.log(`No community skills found for "${query}".`);
-            return;
-        }
-        console.log(`\n  ${results.count} result${results.count !== 1 ? 's' : ''} for "${query}"\n`);
-        console.log(`  ${'Name'.padEnd(30)} ${'Source'.padEnd(35)} Installs`);
-        console.log('  ' + '-'.repeat(80));
-        for (const s of results.skills) {
-            const installs = s.install_count >= 1000
-                ? `${(s.install_count / 1000).toFixed(1)}K`
-                : String(s.install_count);
-            console.log(`  ${s.title.padEnd(30)} ${s.source.padEnd(35)} ${installs}`);
-        }
-        console.log(`\n  Install with: runwork skills install <source>/<id>`);
-        console.log('');
-    }
-    catch (err) {
-        console.error('Search failed:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const installCommand = new Command('install')
-    .description('Install a community skill from skills.sh into your workspace')
-    .argument('<identifier>', 'Skill identifier: source/skill-id (e.g. vercel-labs/skills/find-skills)')
-    .option('--workspace <id>', 'Workspace ID')
-    .action(async (identifier, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    // Parse identifier: "owner/repo/skill-id" or "owner/repo" (skill-id = last segment)
-    const parts = identifier.split('/');
-    let source;
-    let skillId;
-    if (parts.length >= 3) {
-        source = parts.slice(0, -1).join('/');
-        skillId = parts[parts.length - 1];
-    }
-    else if (parts.length === 2) {
-        // Try as source/skillId directly
-        source = parts[0];
-        skillId = parts[1];
-    }
-    else {
-        console.error('Invalid identifier. Use format: owner/repo/skill-id or owner/repo');
-        process.exit(1);
-    }
-    try {
-        const skill = await client.getCommunitySkillContent(source, skillId);
-        if (!skill.content) {
-            console.error(`Skill "${identifier}" found but has no content.`);
-            process.exit(1);
-        }
-        const imported = await client.importExternalSkill(workspaceId, {
-            name: skill.title || skillId,
-            description: skill.description || '',
-            content: skill.content,
-            importedFrom: `skills.sh:${source}/${skillId}`,
-        });
-        if (useJson) {
-            jsonOut({ skill: imported, source: identifier });
-            return;
-        }
-        console.log(`Installed "${skill.title || skillId}" from ${source}`);
-        console.log('Run `runwork sync` to update your local agent configs.');
-    }
-    catch (err) {
-        console.error('Install failed:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-export const skillsCommand = new Command('skills')
-    .description('Manage workspace skills')
-    .addCommand(listCommand)
-    .addCommand(pushCommand)
-    .addCommand(pullCommand)
-    .addCommand(searchCommand)
-    .addCommand(installCommand);

package/dist/commands/sync-telemetry.d.ts

@@ -1,33 +0,0 @@
-import type { AgentAdapter, AgentUsageStats, SkillUsageEntry } from '../agents/types.js';
-import type { SetupState } from '../types.js';
-export interface TelemetryEvent {
-    eventType: string;
-    agentSlug?: string;
-    metadata?: Record<string, unknown>;
-    timestamp: string;
-}
-export interface TelemetryAdapterResult {
-    slug: string;
-    name: string;
-    stats: AgentUsageStats | null | 'unsupported';
-    skills: SkillUsageEntry[] | null | 'unsupported';
-    error?: string;
-}
-export interface TelemetryCollection {
-    events: TelemetryEvent[];
-    adapterResults: TelemetryAdapterResult[];
-    newlyReportedAgents: string[];
-    healthReported: boolean;
-}
-export interface CollectTelemetryParams {
-    adapters: AgentAdapter[];
-    state: SetupState;
-    syncedSkillsCount: number;
-    syncedMcpServersCount: number;
-    teamInstructionsApplied: boolean;
-    agentConfigsApplied: number;
-    now?: string;
-}
-export declare function collectTelemetryEvents(params: CollectTelemetryParams): Promise<TelemetryCollection>;
-export declare function printTelemetryVerbose(result: TelemetryCollection): void;
-export declare function summarizeTelemetryForDryRun(result: TelemetryCollection): string;

package/dist/commands/sync-telemetry.js

@@ -1,186 +0,0 @@
-export async function collectTelemetryEvents(params) {
-    const now = params.now ?? new Date().toISOString();
-    const events = [];
-    const adapterResults = [];
-    const previouslyReported = new Set(params.state.reportedAgentSlugs ?? []);
-    const newlyReportedAgents = [];
-    for (const slug of params.state.configuredAgents) {
-        if (!previouslyReported.has(slug)) {
-            events.push({
-                eventType: 'local_agent.detected',
-                agentSlug: slug,
-                metadata: { installed: true },
-                timestamp: now,
-            });
-            newlyReportedAgents.push(slug);
-        }
-    }
-    for (const adapter of params.adapters) {
-        let stats = 'unsupported';
-        let skills = 'unsupported';
-        let error;
-        if (adapter.readUsageStats) {
-            try {
-                stats = await adapter.readUsageStats(params.state.lastSyncAt ?? null);
-                if (stats && stats.hasNewActivity) {
-                    events.push({
-                        eventType: 'local_agent.usage',
-                        agentSlug: adapter.slug,
-                        metadata: {
-                            sessionCount: stats.sessionCount,
-                            messageCount: stats.messageCount,
-                            toolCallCount: stats.toolCallCount,
-                            tokensUsed: stats.tokensUsed,
-                            aiLinesAdded: stats.aiLinesAdded,
-                            aiLinesRemoved: stats.aiLinesRemoved,
-                            lastActiveAt: stats.lastActiveAt,
-                            modelsUsed: stats.modelsUsed,
-                            mcpToolCount: stats.mcpToolCount,
-                            ...stats.extra,
-                        },
-                        timestamp: now,
-                    });
-                }
-            }
-            catch (err) {
-                error = err instanceof Error ? err.message : String(err);
-                stats = null;
-            }
-        }
-        if (adapter.readSkillUsage) {
-            try {
-                skills = await adapter.readSkillUsage(params.state.lastSyncAt ?? null);
-                if (skills && skills.length > 0) {
-                    for (const entry of skills) {
-                        events.push({
-                            eventType: 'local_agent.skill_used',
-                            agentSlug: adapter.slug,
-                            metadata: {
-                                skillName: entry.skillName,
-                                count: entry.count,
-                                lastUsedAt: entry.lastUsedAt,
-                            },
-                            timestamp: now,
-                        });
-                    }
-                }
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                error = error ? `${error}; skills: ${msg}` : `skills: ${msg}`;
-                skills = null;
-            }
-        }
-        adapterResults.push({
-            slug: adapter.slug,
-            name: adapter.name,
-            stats,
-            skills,
-            error,
-        });
-    }
-    const lastHealthReport = params.state.lastHealthReportAt
-        ? new Date(params.state.lastHealthReportAt)
-        : null;
-    const shouldReportHealth = !lastHealthReport ||
-        Date.now() - lastHealthReport.getTime() > 24 * 60 * 60 * 1000;
-    let healthReported = false;
-    if (shouldReportHealth) {
-        for (const adapter of params.adapters) {
-            try {
-                const version = await adapter.readVersion?.();
-                events.push({
-                    eventType: 'local_agent.health',
-                    agentSlug: adapter.slug,
-                    metadata: {
-                        version,
-                        installed: true,
-                        platform: process.platform,
-                        arch: process.arch,
-                    },
-                    timestamp: now,
-                });
-            }
-            catch {
-                // Health reporting is best-effort
-            }
-        }
-        healthReported = true;
-    }
-    events.push({
-        eventType: 'local_agent.sync_completed',
-        metadata: {
-            syncedSkills: params.syncedSkillsCount,
-            syncedMcpServers: params.syncedMcpServersCount,
-            teamInstructionsApplied: params.teamInstructionsApplied,
-            agentConfigsApplied: params.agentConfigsApplied,
-        },
-        timestamp: now,
-    });
-    return { events, adapterResults, newlyReportedAgents, healthReported };
-}
-function formatStatsLine(stats) {
-    const parts = [];
-    parts.push(`${stats.sessionCount} session${stats.sessionCount === 1 ? '' : 's'}`);
-    if (stats.messageCount)
-        parts.push(`${stats.messageCount} msgs`);
-    if (stats.toolCallCount)
-        parts.push(`${stats.toolCallCount} tool calls`);
-    if (stats.tokensUsed)
-        parts.push(`${stats.tokensUsed} tokens`);
-    if (stats.aiLinesAdded || stats.aiLinesRemoved) {
-        parts.push(`+${stats.aiLinesAdded}/-${stats.aiLinesRemoved} lines`);
-    }
-    if (stats.mcpToolCount)
-        parts.push(`${stats.mcpToolCount} mcp tools`);
-    if (stats.modelsUsed && stats.modelsUsed.length > 0) {
-        parts.push(`models: ${stats.modelsUsed.join(',')}`);
-    }
-    if (stats.lastActiveAt)
-        parts.push(`last ${stats.lastActiveAt}`);
-    return parts.join(', ');
-}
-export function printTelemetryVerbose(result) {
-    console.log('\n  Telemetry collection:');
-    for (const r of result.adapterResults) {
-        let statsLabel;
-        if (r.stats === 'unsupported') {
-            statsLabel = 'no stats reader';
-        }
-        else if (r.stats === null || !r.stats.hasNewActivity) {
-            statsLabel = 'no new activity';
-        }
-        else {
-            statsLabel = formatStatsLine(r.stats);
-        }
-        let skillsLabel;
-        if (r.skills === 'unsupported') {
-            skillsLabel = 'no skill reader';
-        }
-        else if (r.skills === null || r.skills.length === 0) {
-            skillsLabel = 'none';
-        }
-        else {
-            skillsLabel = `${r.skills.length} skill${r.skills.length === 1 ? '' : 's'}`;
-        }
-        const errSuffix = r.error ? ` (error: ${r.error})` : '';
-        console.log(`    [${r.name}] stats: ${statsLabel}; skills: ${skillsLabel}${errSuffix}`);
-    }
-    if (result.newlyReportedAgents.length > 0) {
-        console.log(`\n  First-time detections: ${result.newlyReportedAgents.join(', ')}`);
-    }
-    if (result.healthReported) {
-        console.log('  Health report: due (daily)');
-    }
-    console.log(`\n  Events to send (${result.events.length}):`);
-    const json = JSON.stringify(result.events, null, 2);
-    console.log(json
-        .split('\n')
-        .map(l => '    ' + l)
-        .join('\n'));
-}
-export function summarizeTelemetryForDryRun(result) {
-    const activeCount = result.adapterResults.filter(r => r.stats && r.stats !== 'unsupported' && r.stats.hasNewActivity).length;
-    const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
-    return `Telemetry preview: ${plural(result.events.length, 'event')} would be sent (${plural(activeCount, 'adapter')} with activity). Use --verbose for details.`;
-}

package/dist/commands/sync.d.ts

@@ -1,37 +0,0 @@
-import { Command } from 'commander';
-import type { SetupState, Credentials } from '../types.js';
-export interface SyncOptions {
-    dryRun: boolean;
-    pullOnly: boolean;
-    prefer?: 'local' | 'remote';
-    yes: boolean;
-    verbose?: boolean;
-    /**
-     * Force a fresh agent-installation detection pass and union newly-found
-     * agents into `state.configuredAgents`. Without this, sync only re-detects
-     * when state is empty or `lastDetectedAt` is older than REDETECT_TTL_MS.
-     */
-    redetect?: boolean;
-}
-/**
- * How long a detection result stays trusted before sync re-runs detection
- * on its own. Detection is cheap on macOS/Linux but pays a PowerShell
- * waterfall on Windows, so we cache for a day. Users who just installed
- * a new agent can shortcut the wait via `--redetect` (or the desktop's
- * "Rescan" button, which forwards the flag).
- */
-export declare const REDETECT_TTL_MS: number;
-/**
- * Decide whether to re-run installation detection for this sync. We always
- * re-detect on explicit user request, on first sync (no timestamp yet), when
- * setup ended up with zero agents (recovery), or after the TTL has lapsed.
- */
-export declare function shouldRedetect(state: SetupState, opts: SyncOptions): boolean;
-/**
- * Detect installed agents and merge any new slugs into `state.configuredAgents`.
- * Never removes agents — a transient PATH glitch shouldn't wipe the setup.
- * Returns the slugs that were newly added (for logging).
- */
-export declare function refreshConfiguredAgents(state: SetupState): Promise<string[]>;
-export declare function syncFromState(state: SetupState, statePath: string, credentials: Credentials, opts: SyncOptions): Promise<void>;
-export declare const syncCommand: Command;