@orchagent/cli 0.2.9 → 0.2.11

package/dist/commands/call.js

@@ -128,7 +128,7 @@ Note: Use 'call' for server-side execution (requires login), 'run' for local exe
         if (!org) {
             throw new errors_1.CliError('Missing org. Use org/agent or set default org.');
         }
-        const agentMeta = await (0, api_1.getPublicAgent)(resolved, org, parsed.agent, parsed.version);
+        const agentMeta = await (0, api_1.getAgentWithFallback)(resolved, org, parsed.agent, parsed.version);
         const endpoint = options.endpoint?.trim() || agentMeta.default_endpoint || 'analyze';
         const headers = {
             Authorization: `Bearer ${resolved.apiKey}`,

package/dist/commands/delete.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDeleteCommand = registerDeleteCommand;
+const promises_1 = __importDefault(require("readline/promises"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+async function promptText(message) {
+    const rl = promises_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const answer = await rl.question(message);
+    rl.close();
+    return answer.trim();
+}
+async function promptConfirm(message) {
+    const answer = await promptText(`${message} (y/N): `);
+    return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+}
+function registerDeleteCommand(program) {
+    program
+        .command('delete <agent-name>')
+        .description('Delete an agent')
+        .option('--version <version>', 'Specific version to delete (default: latest)')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .action(async (agentName, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Not logged in. Run `orch login` first.');
+        }
+        process.stdout.write('Finding agent...\n');
+        // Find the agent
+        const agents = await (0, api_1.listMyAgents)(config);
+        const matching = agents.filter(a => a.name === agentName);
+        if (matching.length === 0) {
+            throw new errors_1.CliError(`Agent '${agentName}' not found`);
+        }
+        // Select version
+        let agent;
+        if (options.version) {
+            agent = matching.find(a => a.version === options.version);
+            if (!agent) {
+                throw new errors_1.CliError(`Version '${options.version}' not found for agent '${agentName}'`);
+            }
+        }
+        else {
+            // Get latest version
+            agent = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+        }
+        // Check if confirmation is required
+        const deleteCheck = await (0, api_1.checkAgentDelete)(config, agent.id);
+        // Show agent info
+        process.stdout.write(`\n${chalk_1.default.bold('Agent:')} ${agent.name}@${agent.version}\n`);
+        if (deleteCheck.stars_count > 0 || deleteCheck.fork_count > 0) {
+            process.stdout.write(`${chalk_1.default.bold('Stars:')} ${deleteCheck.stars_count}  ${chalk_1.default.bold('Forks:')} ${deleteCheck.fork_count}\n`);
+        }
+        process.stdout.write('\n');
+        // Handle confirmation
+        if (!options.yes) {
+            if (deleteCheck.requires_confirmation) {
+                process.stdout.write(chalk_1.default.yellow('Warning: This agent has stars or forks. Type the agent name to confirm deletion.\n\n'));
+                const confirmName = await promptText(`Type "${agent.name}" to confirm deletion: `);
+                if (confirmName !== agent.name) {
+                    process.stdout.write(chalk_1.default.red('\nDeletion cancelled. Name did not match.\n'));
+                    process.exit(1);
+                }
+            }
+            else {
+                const confirmed = await promptConfirm(`Delete ${agent.name}@${agent.version}?`);
+                if (!confirmed) {
+                    process.stdout.write(chalk_1.default.gray('Deletion cancelled.\n'));
+                    process.exit(0);
+                }
+            }
+        }
+        // Perform deletion
+        process.stdout.write('Deleting agent...\n');
+        const confirmationName = deleteCheck.requires_confirmation ? agent.name : undefined;
+        await (0, api_1.deleteAgent)(config, agent.id, confirmationName);
+        await (0, analytics_1.track)('cli_delete', { agent_name: agent.name, version: agent.version });
+        process.stdout.write(`✓ Deleted ${agent.name}@${agent.version}\n`);
+        process.stdout.write(chalk_1.default.gray('\nData will be retained for 30 days before permanent deletion.\n'));
+    });
+}

package/dist/commands/index.js

@@ -15,6 +15,7 @@ const keys_1 = require("./keys");
 const run_1 = require("./run");
 const info_1 = require("./info");
 const skill_1 = require("./skill");
+const delete_1 = require("./delete");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, whoami_1.registerWhoamiCommand)(program);
@@ -30,4 +31,5 @@ function registerCommands(program) {
     (0, llm_config_1.registerLlmConfigCommand)(program);
     (0, keys_1.registerKeysCommand)(program);
     (0, skill_1.registerSkillCommand)(program);
+    (0, delete_1.registerDeleteCommand)(program);
 }

package/dist/commands/info.js

@@ -54,6 +54,57 @@ async function fetchReadme(url) {
         return null;
     }
 }
+async function downloadAgentWithFallback(config, org, agent, version) {
+    // Try public endpoint first
+    try {
+        return await (0, api_1.publicRequest)(config, `/public/agents/${org}/${agent}/${version}/download`);
+    }
+    catch (err) {
+        if (!(err instanceof api_1.ApiError) || err.status !== 404)
+            throw err;
+    }
+    // Fallback to authenticated endpoint for private agents
+    if (!config.apiKey) {
+        throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+    }
+    const userOrg = await (0, api_1.getOrg)(config);
+    if (userOrg.slug !== org) {
+        throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+    }
+    // Find agent in user's list and construct download data
+    const agents = await (0, api_1.listMyAgents)(config);
+    const matching = agents.filter(a => a.name === agent);
+    if (matching.length === 0) {
+        throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+    }
+    let targetAgent = matching[0];
+    if (version !== 'latest') {
+        const found = matching.find(a => a.version === version);
+        if (!found) {
+            throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+        }
+        targetAgent = found;
+    }
+    else {
+        // Get most recent
+        targetAgent = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+    }
+    // Convert Agent to AgentDownload format
+    return {
+        type: targetAgent.type,
+        name: targetAgent.name,
+        version: targetAgent.version,
+        description: targetAgent.description,
+        prompt: targetAgent.prompt,
+        input_schema: targetAgent.input_schema,
+        output_schema: targetAgent.output_schema,
+        supported_providers: targetAgent.supported_providers || ['any'],
+        source_url: targetAgent.source_url,
+        run_command: targetAgent.run_command,
+        url: targetAgent.url,
+        sdk_compatible: false,
+    };
+}
 function registerInfoCommand(program) {
     program
         .command('info <agent>')
@@ -63,7 +114,7 @@ function registerInfoCommand(program) {
         const config = await (0, config_1.getResolvedConfig)();
         const { org, agent, version } = parseAgentRef(agentArg);
         // Fetch agent metadata
-        const agentData = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${agent}/${version}/download`);
+        const agentData = await downloadAgentWithFallback(config, org, agent, version);
         if (options.json) {
             // Don't expose internal routing URLs in JSON output
             const output = { ...agentData };
@@ -93,6 +144,10 @@ function registerInfoCommand(program) {
             if (agentData.run_command) {
                 process.stdout.write(`Run: ${agentData.run_command}\n`);
             }
+            // Display SDK/Local Ready status
+            if (agentData.sdk_compatible) {
+                process.stdout.write(`Local Ready: yes (uses orchagent-sdk)\n`);
+            }
         }
         // Display input schema if available
         if (agentData.input_schema?.properties && Object.keys(agentData.input_schema.properties).length > 0) {

package/dist/commands/init.js

@@ -46,15 +46,38 @@ const SCHEMA_TEMPLATE = `{
   }
 }
 `;
+const SKILL_TEMPLATE = `---
+name: my-skill
+description: When to use this skill
+license: MIT
+---
+
+# My Skill
+
+Instructions and guidance for AI agents...
+`;
 function registerInitCommand(program) {
     program
         .command('init')
         .description('Initialize a new agent project')
         .argument('[name]', 'Agent name (default: current directory name)')
-        .option('--type <type>', 'Agent type: prompt or code (default: prompt)', 'prompt')
+        .option('--type <type>', 'Type: prompt, code, or skill (default: prompt)', 'prompt')
         .action(async (name, options) => {
         const cwd = process.cwd();
         const agentName = name || path_1.default.basename(cwd);
+        // Handle skill type separately
+        if (options.type === 'skill') {
+            const skillPath = path_1.default.join(cwd, 'SKILL.md');
+            const skillContent = SKILL_TEMPLATE.replace('my-skill', agentName);
+            await promises_1.default.writeFile(skillPath, skillContent);
+            process.stdout.write(`Initialized skill "${agentName}" in ${cwd}\n`);
+            process.stdout.write(`\nFiles created:\n`);
+            process.stdout.write(`  SKILL.md - Skill content with frontmatter\n`);
+            process.stdout.write(`\nNext steps:\n`);
+            process.stdout.write(`  1. Edit SKILL.md with your skill content\n`);
+            process.stdout.write(`  2. Run: orchagent publish\n`);
+            return;
+        }
         const manifestPath = path_1.default.join(cwd, 'orchagent.json');
         const promptPath = path_1.default.join(cwd, 'prompt.md');
         const schemaPath = path_1.default.join(cwd, 'schema.json');
@@ -71,7 +94,7 @@ function registerInitCommand(program) {
         // Create manifest
         const manifest = JSON.parse(MANIFEST_TEMPLATE);
         manifest.name = agentName;
-        manifest.type = options.type === 'code' ? 'code' : 'prompt';
+        manifest.type = ['code', 'skill'].includes(options.type) ? options.type : 'prompt';
         await promises_1.default.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
         // Create prompt template (for prompt-based agents)
         if (options.type !== 'code') {

package/dist/commands/publish.js

@@ -13,6 +13,37 @@ const api_1 = require("../lib/api");
 const errors_1 = require("../lib/errors");
 const analytics_1 = require("../lib/analytics");
 const bundle_1 = require("../lib/bundle");
+/**
+ * Check if orchagent-sdk is listed in requirements.txt or pyproject.toml
+ */
+async function detectSdkCompatible(agentDir) {
+    // Check requirements.txt
+    const requirementsPath = path_1.default.join(agentDir, 'requirements.txt');
+    try {
+        const content = await promises_1.default.readFile(requirementsPath, 'utf-8');
+        // Match orchagent-sdk with or without version specifier (e.g., orchagent-sdk, orchagent-sdk>=0.1.0)
+        if (/^orchagent-sdk\b/m.test(content)) {
+            return true;
+        }
+    }
+    catch {
+        // File doesn't exist, continue checking pyproject.toml
+    }
+    // Check pyproject.toml
+    const pyprojectPath = path_1.default.join(agentDir, 'pyproject.toml');
+    try {
+        const content = await promises_1.default.readFile(pyprojectPath, 'utf-8');
+        // Match orchagent-sdk in dependencies (various formats in TOML)
+        // e.g., "orchagent-sdk", 'orchagent-sdk>=0.1.0', orchagent-sdk = ">=0.1.0"
+        if (/["']?orchagent-sdk["']?\s*[=<>~!]?/m.test(content)) {
+            return true;
+        }
+    }
+    catch {
+        // File doesn't exist
+    }
+    return false;
+}
 async function parseSkillMd(filePath) {
     try {
         const content = await promises_1.default.readFile(filePath, 'utf-8');
@@ -32,7 +63,7 @@ async function parseSkillMd(filePath) {
 function registerPublishCommand(program) {
     program
         .command('publish')
-        .description('Publish agent from local files')
+        .description('Publish agent or skill from local files')
         .option('--url <url>', 'Agent URL (for code-based agents)')
         .option('--public', 'Make agent public (default: true)', true)
         .option('--private', 'Make agent private')
@@ -77,16 +108,17 @@ function registerPublishCommand(program) {
         if (!manifest.name) {
             throw new errors_1.CliError('orchagent.json must have name');
         }
-        // Read prompt (for prompt-based agents)
+        // Read prompt (for prompt-based agents and skills)
         let prompt;
-        if (manifest.type === 'prompt') {
+        if (manifest.type === 'prompt' || manifest.type === 'skill') {
             const promptPath = path_1.default.join(cwd, 'prompt.md');
             try {
                 prompt = await promises_1.default.readFile(promptPath, 'utf-8');
             }
             catch (err) {
                 if (err.code === 'ENOENT') {
-                    throw new errors_1.CliError('No prompt.md found for prompt-based agent');
+                    const agentTypeName = manifest.type === 'skill' ? 'skill' : 'prompt-based agent';
+                    throw new errors_1.CliError(`No prompt.md found for ${agentTypeName}`);
                 }
                 throw err;
             }
@@ -128,6 +160,14 @@ function registerPublishCommand(program) {
         const org = await (0, api_1.getOrg)(config);
         // Default to 'any' provider if not specified
         const supportedProviders = manifest.supported_providers || ['any'];
+        // Detect SDK compatibility for code agents
+        let sdkCompatible = false;
+        if (manifest.type === 'code') {
+            sdkCompatible = await detectSdkCompatible(cwd);
+            if (sdkCompatible) {
+                process.stdout.write(`SDK detected - agent will be marked as Local Ready\n`);
+            }
+        }
         // Create the agent (server auto-assigns version)
         const result = await (0, api_1.createAgent)(config, {
             name: manifest.name,
@@ -145,6 +185,10 @@ function registerPublishCommand(program) {
             source_url: manifest.source_url,
             pip_package: manifest.pip_package,
             run_command: manifest.run_command,
+            // SDK compatibility flag
+            sdk_compatible: sdkCompatible || undefined,
+            // Orchestration manifest (includes dependencies)
+            manifest: manifest.manifest,
         });
         const assignedVersion = result.agent?.version || 'v1';
         const agentId = result.agent?.id;
@@ -165,9 +209,9 @@ function registerPublishCommand(program) {
                 if (!validation.valid) {
                     throw new errors_1.CliError(`Bundle validation failed: ${validation.error}`);
                 }
-                // Upload the bundle
+                // Upload the bundle with entrypoint
                 process.stdout.write(`  Uploading bundle...\n`);
-                const uploadResult = await (0, api_1.uploadCodeBundle)(config, agentId, bundlePath);
+                const uploadResult = await (0, api_1.uploadCodeBundle)(config, agentId, bundlePath, manifest.entrypoint);
                 process.stdout.write(`  Uploaded: ${uploadResult.code_hash.substring(0, 12)}...\n`);
             }
             finally {

package/dist/commands/run.js

@@ -68,8 +68,73 @@ function parseAgentRef(value) {
     throw new errors_1.CliError('Invalid agent reference. Use org/agent or agent format.');
 }
 async function downloadAgent(config, org, agent, version) {
-    // Public endpoint - no auth required
-    return (0, api_1.publicRequest)(config, `/public/agents/${org}/${agent}/${version}/download`);
+    // Try public endpoint first
+    try {
+        return await (0, api_1.publicRequest)(config, `/public/agents/${org}/${agent}/${version}/download`);
+    }
+    catch (err) {
+        if (!(err instanceof api_1.ApiError) || err.status !== 404)
+            throw err;
+    }
+    // Fallback to authenticated endpoint for private agents
+    if (!config.apiKey) {
+        throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+    }
+    const userOrg = await (0, api_1.getOrg)(config);
+    if (userOrg.slug !== org) {
+        throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+    }
+    // Find agent in user's list
+    const agents = await (0, api_1.listMyAgents)(config);
+    const matching = agents.filter(a => a.name === agent);
+    if (matching.length === 0) {
+        throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+    }
+    let targetAgent = matching[0];
+    if (version !== 'latest') {
+        const found = matching.find(a => a.version === version);
+        if (!found) {
+            throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+        }
+        targetAgent = found;
+    }
+    else {
+        targetAgent = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+    }
+    // Convert Agent to AgentDownload format
+    return {
+        id: targetAgent.id,
+        type: targetAgent.type,
+        name: targetAgent.name,
+        version: targetAgent.version,
+        description: targetAgent.description,
+        prompt: targetAgent.prompt,
+        input_schema: targetAgent.input_schema,
+        output_schema: targetAgent.output_schema,
+        supported_providers: targetAgent.supported_providers || ['any'],
+        default_models: targetAgent.default_models,
+        source_url: targetAgent.source_url,
+        pip_package: targetAgent.pip_package,
+        run_command: targetAgent.run_command,
+        url: targetAgent.url,
+        has_bundle: !!targetAgent.code_bundle_url,
+        entrypoint: targetAgent.entrypoint,
+    };
+}
+async function downloadBundleWithFallback(config, org, agentName, version, agentId) {
+    // Try public endpoint first
+    try {
+        return await (0, api_1.downloadCodeBundle)(config, org, agentName, version);
+    }
+    catch (err) {
+        if (!(err instanceof api_1.ApiError) || err.status !== 404)
+            throw err;
+    }
+    // Fallback to authenticated endpoint
+    if (!config.apiKey || !agentId) {
+        throw new api_1.ApiError(`Bundle for '${org}/${agentName}@${version}' not found`, 404);
+    }
+    return await (0, api_1.downloadCodeBundleAuthenticated)(config, agentId);
 }
 async function checkDependencies(config, dependencies) {
     const results = [];
@@ -144,7 +209,7 @@ async function downloadDependenciesRecursively(config, depStatuses, visited = ne
         await saveAgentLocally(org, agent, status.agentData);
         // For bundle-based agents, also extract the bundle
         if (status.agentData.has_bundle) {
-            await saveBundleLocally(config, org, agent, status.dep.version);
+            await saveBundleLocally(config, org, agent, status.dep.version, status.agentData.id);
         }
         // Install if it's a pip/source code agent
         if (status.agentData.type === 'code' && (status.agentData.source_url || status.agentData.pip_package)) {
@@ -306,7 +371,9 @@ async function unzipBundle(zipPath, destDir) {
         });
         proc.on('close', (code) => {
             if (code !== 0) {
-                reject(new errors_1.CliError(`Failed to extract bundle: ${stderr || `exit code ${code}`}`));
+                const detail = stderr.trim() || `exit code ${code}`;
+                reject(new errors_1.CliError(`Failed to extract bundle: ${detail}\n` +
+                    `Ensure the bundle is valid. Try re-publishing the agent.`));
             }
             else {
                 resolve();
@@ -328,7 +395,7 @@ async function executeBundleAgent(config, org, agentName, version, agentData, ar
     try {
         // Download the bundle
         process.stderr.write(`Downloading bundle...\n`);
-        const bundleBuffer = await (0, api_1.downloadCodeBundle)(config, org, agentName, version);
+        const bundleBuffer = await downloadBundleWithFallback(config, org, agentName, version, agentData.id);
         await promises_1.default.writeFile(bundleZip, bundleBuffer);
         process.stderr.write(`Bundle downloaded (${bundleBuffer.length} bytes)\n`);
         // Extract the bundle
@@ -501,9 +568,14 @@ async function executeBundleAgent(config, org, agentName, version, agentData, ar
         else if (exitCode !== 0) {
             // No stdout, check stderr
             if (stderr.trim()) {
-                throw new errors_1.CliError(`Agent error: ${stderr.trim()}`);
+                throw new errors_1.CliError(`Agent exited with code ${exitCode}\n\nError output:\n${stderr.trim()}`);
             }
-            throw new errors_1.CliError(`Agent exited with code ${exitCode} (no output)`);
+            throw new errors_1.CliError(`Agent exited with code ${exitCode} (no output)\n\n` +
+                `Common causes:\n` +
+                `  - Missing dependency (check requirements.txt)\n` +
+                `  - Syntax error in entrypoint\n` +
+                `  - Agent crashed before writing output\n\n` +
+                `Run with --verbose or check logs in dashboard.`);
         }
     }
     finally {
@@ -535,7 +607,7 @@ async function saveAgentLocally(org, agent, agentData) {
     }
     return agentDir;
 }
-async function saveBundleLocally(config, org, agent, version) {
+async function saveBundleLocally(config, org, agent, version, agentId) {
     const agentDir = path_1.default.join(AGENTS_DIR, org, agent);
     const bundleDir = path_1.default.join(agentDir, 'bundle');
     // Check if already extracted with same version
@@ -559,7 +631,7 @@ async function saveBundleLocally(config, org, agent, version) {
     }
     // Download and extract bundle
     process.stderr.write(`Downloading bundle for ${org}/${agent}@${version}...\n`);
-    const bundleBuffer = await (0, api_1.downloadCodeBundle)(config, org, agent, version);
+    const bundleBuffer = await downloadBundleWithFallback(config, org, agent, version, agentId);
     const tempZip = path_1.default.join(os_1.default.tmpdir(), `bundle-${Date.now()}.zip`);
     await promises_1.default.writeFile(tempZip, bundleBuffer);
     // Clean and recreate bundle directory

package/dist/commands/skill.js

@@ -49,6 +49,61 @@ function parseSkillRef(value) {
     }
     throw new errors_1.CliError('Invalid skill reference. Use org/skill or skill format.');
 }
+async function downloadSkillWithFallback(config, org, skill, version) {
+    // Try public endpoint first
+    try {
+        const meta = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${skill}/${version}`);
+        // Verify it's a skill type before downloading
+        const skillType = meta.type;
+        if (skillType !== 'skill') {
+            throw new errors_1.CliError(`${org}/${skill} is not a skill (type: ${skillType || 'prompt'})`);
+        }
+        // Download content from public endpoint
+        return await (0, api_1.publicRequest)(config, `/public/agents/${org}/${skill}/${version}/download`);
+    }
+    catch (err) {
+        if (!(err instanceof api_1.ApiError) || err.status !== 404)
+            throw err;
+    }
+    // Fallback to authenticated endpoint for private skills
+    if (!config.apiKey) {
+        throw new api_1.ApiError(`Skill '${org}/${skill}@${version}' not found`, 404);
+    }
+    const userOrg = await (0, api_1.getOrg)(config);
+    if (userOrg.slug !== org) {
+        throw new api_1.ApiError(`Skill '${org}/${skill}@${version}' not found`, 404);
+    }
+    // Find skill in user's list
+    const agents = await (0, api_1.listMyAgents)(config);
+    const matching = agents.filter(a => a.name === skill && a.type === 'skill');
+    if (matching.length === 0) {
+        throw new api_1.ApiError(`Skill '${org}/${skill}@${version}' not found`, 404);
+    }
+    let targetAgent = matching[0];
+    if (version !== 'v1' && version !== 'latest') {
+        const found = matching.find(a => a.version === version);
+        if (!found) {
+            throw new api_1.ApiError(`Skill '${org}/${skill}@${version}' not found`, 404);
+        }
+        targetAgent = found;
+    }
+    else {
+        // Get most recent
+        targetAgent = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+    }
+    // Verify it's a skill type
+    if (targetAgent.type !== 'skill') {
+        throw new errors_1.CliError(`${org}/${skill} is not a skill (type: ${targetAgent.type || 'prompt'})`);
+    }
+    // Convert Agent to SkillDownload format
+    return {
+        type: targetAgent.type,
+        name: targetAgent.name,
+        version: targetAgent.version,
+        description: targetAgent.description,
+        prompt: targetAgent.prompt,
+    };
+}
 function registerSkillCommand(program) {
     const skill = program.command('skill').description('Manage and install skills');
     // orch skill list (deprecated)
@@ -65,6 +120,40 @@ function registerSkillCommand(program) {
             'Browse all skills at: https://orchagent.io/explore\n');
         process.exit(0);
     });
+    // orch skill create [name]
+    skill
+        .command('create [name]')
+        .description('Create a new skill from template')
+        .action(async (name) => {
+        const cwd = process.cwd();
+        const skillName = name || path_1.default.basename(cwd);
+        const skillPath = path_1.default.join(cwd, 'SKILL.md');
+        // Check if SKILL.md already exists
+        try {
+            await promises_1.default.access(skillPath);
+            throw new errors_1.CliError('SKILL.md already exists');
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+        const template = `---
+name: ${skillName}
+description: When to use this skill
+license: MIT
+---
+
+# ${skillName}
+
+Instructions and guidance for AI agents...
+`;
+        await promises_1.default.writeFile(skillPath, template);
+        await (0, analytics_1.track)('cli_skill_create', { name: skillName });
+        process.stdout.write(`Created skill: ${skillPath}\n`);
+        process.stdout.write(`\nNext steps:\n`);
+        process.stdout.write(`  1. Edit SKILL.md with your skill content\n`);
+        process.stdout.write(`  2. Run: orchagent publish\n`);
+    });
     // orch skill install <skill>
     skill
         .command('install <skill>')
@@ -77,14 +166,8 @@ function registerSkillCommand(program) {
         if (!org) {
             throw new errors_1.CliError('Missing org. Use org/skill or set default org.');
         }
-        // Fetch skill metadata to verify it's a skill
-        const skillMeta = await (0, api_1.publicRequest)(resolved, `/public/agents/${org}/${parsed.skill}/${parsed.version}`);
-        const skillType = skillMeta.type;
-        if (skillType !== 'skill') {
-            throw new errors_1.CliError(`${org}/${parsed.skill} is not a skill (type: ${skillType || 'prompt'})`);
-        }
-        // Download skill content
-        const skillData = await (0, api_1.publicRequest)(resolved, `/public/agents/${org}/${parsed.skill}/${parsed.version}/download`);
+        // Download skill (tries public first, falls back to authenticated for private)
+        const skillData = await downloadSkillWithFallback(resolved, org, parsed.skill, parsed.version);
         if (!skillData.prompt) {
             throw new errors_1.CliError('Skill has no content');
         }

package/dist/lib/api.js

@@ -49,6 +49,11 @@ exports.searchAgents = searchAgents;
 exports.fetchLlmKeys = fetchLlmKeys;
 exports.downloadCodeBundle = downloadCodeBundle;
 exports.uploadCodeBundle = uploadCodeBundle;
+exports.getMyAgent = getMyAgent;
+exports.getAgentWithFallback = getAgentWithFallback;
+exports.downloadCodeBundleAuthenticated = downloadCodeBundleAuthenticated;
+exports.checkAgentDelete = checkAgentDelete;
+exports.deleteAgent = deleteAgent;
 class ApiError extends Error {
     status;
     payload;
@@ -166,7 +171,7 @@ async function downloadCodeBundle(config, org, agent, version) {
 /**
  * Upload a code bundle for a hosted code agent.
  */
-async function uploadCodeBundle(config, agentId, bundlePath) {
+async function uploadCodeBundle(config, agentId, bundlePath, entrypoint) {
     if (!config.apiKey) {
         throw new ApiError('Missing API key. Run `orchagent login` first.', 401);
     }
@@ -177,11 +182,16 @@ async function uploadCodeBundle(config, agentId, bundlePath) {
     // Create form data
     const formData = new FormData();
     formData.append('file', blob, 'bundle.zip');
+    // Build headers
+    const headers = {
+        Authorization: `Bearer ${config.apiKey}`,
+    };
+    if (entrypoint) {
+        headers['x-entrypoint'] = entrypoint;
+    }
     const response = await fetch(`${config.apiUrl.replace(/\/$/, '')}/agents/${agentId}/upload`, {
         method: 'POST',
-        headers: {
-            Authorization: `Bearer ${config.apiKey}`,
-        },
+        headers,
         body: formData,
     });
     if (!response.ok) {
@@ -189,3 +199,80 @@ async function uploadCodeBundle(config, agentId, bundlePath) {
     }
     return (await response.json());
 }
+/**
+ * Get single agent by name/version from authenticated endpoint.
+ */
+async function getMyAgent(config, agentName, version) {
+    const agents = await listMyAgents(config);
+    const matching = agents.filter(a => a.name === agentName);
+    if (matching.length === 0)
+        return null;
+    if (version === 'latest') {
+        return matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+    }
+    return matching.find(a => a.version === version) ?? null;
+}
+/**
+ * Try public endpoint first, fallback to authenticated for private agents.
+ */
+async function getAgentWithFallback(config, org, agentName, version) {
+    try {
+        return await getPublicAgent(config, org, agentName, version);
+    }
+    catch (err) {
+        if (!(err instanceof ApiError) || err.status !== 404)
+            throw err;
+    }
+    if (!config.apiKey) {
+        throw new ApiError(`Agent '${org}/${agentName}@${version}' not found`, 404);
+    }
+    const userOrg = await getOrg(config);
+    if (userOrg.slug !== org) {
+        throw new ApiError(`Agent '${org}/${agentName}@${version}' not found`, 404);
+    }
+    const myAgent = await getMyAgent(config, agentName, version);
+    if (!myAgent) {
+        throw new ApiError(`Agent '${org}/${agentName}@${version}' not found`, 404);
+    }
+    return myAgent;
+}
+/**
+ * Download a code bundle for a private agent using authenticated endpoint.
+ */
+async function downloadCodeBundleAuthenticated(config, agentId) {
+    if (!config.apiKey) {
+        throw new ApiError('Missing API key for authenticated bundle download', 401);
+    }
+    const response = await fetch(`${config.apiUrl.replace(/\/$/, '')}/agents/${agentId}/bundle`, {
+        headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        let message = response.statusText;
+        try {
+            const payload = JSON.parse(text);
+            message = payload.error?.message || payload.message || message;
+        }
+        catch {
+            // Use default message
+        }
+        throw new ApiError(message, response.status);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+}
+/**
+ * Check if an agent requires confirmation for deletion.
+ */
+async function checkAgentDelete(config, agentId) {
+    return request(config, 'GET', `/agents/${agentId}/delete-check`);
+}
+/**
+ * Soft delete an agent.
+ */
+async function deleteAgent(config, agentId, confirmationName) {
+    const params = confirmationName ? `?confirmation_name=${encodeURIComponent(confirmationName)}` : '';
+    return request(config, 'DELETE', `/agents/${agentId}${params}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Command-line interface for the OrchAgent AI agent marketplace",
   "license": "MIT",
   "author": "OrchAgent <hello@orchagent.io>",