runwork 0.5.0 → 0.6.0

package/dist/commands/skills.js

@@ -64,38 +64,89 @@ const listCommand = new Command('list')
         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)')
-    .argument('<file>', 'Path to skill .md file')
+    .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 (file, opts, command) => {
+    .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);
-    if (!existsSync(file)) {
-        console.error(`File not found: ${file}`);
+    // 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 {
-        const content = readFileSync(file, 'utf-8');
         // Parse frontmatter
         const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-        let name = '';
+        let name = nameArg || '';
         let description = '';
         let body = content;
         if (frontmatterMatch) {
             const fm = frontmatterMatch[1];
             body = frontmatterMatch[2];
-            const nameMatch = fm.match(/^name:\s*(.+)$/m);
             const descMatch = fm.match(/^description:\s*(.+)$/m);
-            if (nameMatch)
-                name = nameMatch[1].trim();
             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 file must have a "name" in YAML frontmatter:\n---\nname: my-skill\ndescription: What it does\n---');
+            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)
@@ -128,7 +179,174 @@ const pushCommand = new Command('push')
         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(pushCommand)
+    .addCommand(pullCommand)
+    .addCommand(searchCommand)
+    .addCommand(installCommand);

package/dist/commands/sync.d.ts

@@ -1,2 +1,10 @@
 import { Command } from 'commander';
+import type { SetupState, Credentials } from '../types.js';
+export interface SyncOptions {
+    dryRun: boolean;
+    pullOnly: boolean;
+    prefer?: 'local' | 'remote';
+    yes: boolean;
+}
+export declare function syncFromState(state: SetupState, statePath: string, credentials: Credentials, opts: SyncOptions): Promise<void>;
 export declare const syncCommand: Command;