@orchagent/cli 0.2.8 → 0.2.10

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/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

@@ -48,6 +48,13 @@ const output_1 = require("../lib/output");
 const llm_1 = require("../lib/llm");
 const DEFAULT_VERSION = 'latest';
 const AGENTS_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent', 'agents');
+// Local execution environment variables
+const LOCAL_EXECUTION_ENV = 'ORCHAGENT_LOCAL_EXECUTION';
+const AGENTS_DIR_ENV = 'ORCHAGENT_AGENTS_DIR';
+const CALL_CHAIN_ENV = 'ORCHAGENT_CALL_CHAIN';
+const DEADLINE_MS_ENV = 'ORCHAGENT_DEADLINE_MS';
+const MAX_HOPS_ENV = 'ORCHAGENT_MAX_HOPS';
+const DOWNSTREAM_REMAINING_ENV = 'ORCHAGENT_DOWNSTREAM_REMAINING';
 function parseAgentRef(value) {
     const [ref, versionPart] = value.split('@');
     const version = versionPart?.trim() || DEFAULT_VERSION;
@@ -61,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 = [];
@@ -70,7 +142,7 @@ async function checkDependencies(config, dependencies) {
         const [org, agent] = dep.id.split('/');
         try {
             const agentData = await downloadAgent(config, org, agent, dep.version);
-            const downloadable = !!(agentData.source_url || agentData.pip_package || agentData.type === 'prompt');
+            const downloadable = !!(agentData.source_url || agentData.pip_package || agentData.has_bundle || agentData.type === 'prompt');
             results.push({ dep, downloadable, agentData });
         }
         catch {
@@ -117,6 +189,12 @@ async function promptUserForDeps(depStatuses) {
         });
     });
 }
+async function downloadSkillDependency(config, ref, defaultOrg) {
+    const parsed = parseSkillRef(ref);
+    const org = parsed.org ?? defaultOrg;
+    const skillData = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${parsed.skill}/${parsed.version}/download`);
+    await saveAgentLocally(org, parsed.skill, skillData);
+}
 async function downloadDependenciesRecursively(config, depStatuses, visited = new Set()) {
     for (const status of depStatuses) {
         if (!status.downloadable || !status.agentData)
@@ -127,12 +205,27 @@ async function downloadDependenciesRecursively(config, depStatuses, visited = ne
         visited.add(depRef);
         const [org, agent] = status.dep.id.split('/');
         process.stderr.write(`\nDownloading dependency: ${depRef}...\n`);
-        // Save the dependency locally
+        // Save the dependency metadata locally
         await saveAgentLocally(org, agent, status.agentData);
-        // Install if it's a code agent
+        // For bundle-based agents, also extract the bundle
+        if (status.agentData.has_bundle) {
+            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)) {
             await installCodeAgent(status.agentData);
         }
+        // Download default skills
+        const defaultSkills = status.agentData.default_skills || [];
+        for (const skillRef of defaultSkills) {
+            try {
+                await downloadSkillDependency(config, skillRef, org);
+            }
+            catch {
+                // Skill download failed - not critical, continue
+                process.stderr.write(`  Warning: Failed to download skill ${skillRef}\n`);
+            }
+        }
         // Recursively download its dependencies
         if (status.agentData.dependencies && status.agentData.dependencies.length > 0) {
             const nestedStatuses = await checkDependencies(config, status.agentData.dependencies);
@@ -300,7 +393,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
@@ -393,9 +486,32 @@ async function executeBundleAgent(config, org, agentName, version, agentData, ar
         }
         // Run the entrypoint with input via stdin
         process.stderr.write(`\nRunning: python3 ${entrypoint}\n\n`);
+        // Pass auth credentials to subprocess for orchestrator agents calling sub-agents
+        const subprocessEnv = { ...process.env };
+        if (config.apiKey) {
+            subprocessEnv.ORCHAGENT_SERVICE_KEY = config.apiKey;
+            subprocessEnv.ORCHAGENT_API_URL = config.apiUrl;
+        }
+        // For orchestrator agents with dependencies, enable local execution mode
+        if (agentData.dependencies && agentData.dependencies.length > 0) {
+            subprocessEnv[LOCAL_EXECUTION_ENV] = 'true';
+            subprocessEnv[AGENTS_DIR_ENV] = AGENTS_DIR;
+            // Initialize call chain with this agent
+            const agentRef = `${org}/${agentName}@${version}`;
+            subprocessEnv[CALL_CHAIN_ENV] = agentRef;
+            // Set deadline from manifest timeout (default 120s)
+            const manifest = agentData;
+            const timeoutMs = manifest.manifest?.timeout_ms || 120000;
+            subprocessEnv[DEADLINE_MS_ENV] = String(Date.now() + timeoutMs);
+            // Set max hops from manifest (default 10)
+            subprocessEnv[MAX_HOPS_ENV] = String(manifest.manifest?.max_hops || 10);
+            // Set downstream cap
+            subprocessEnv[DOWNSTREAM_REMAINING_ENV] = String(manifest.manifest?.per_call_downstream_cap || 100);
+        }
         const proc = (0, child_process_1.spawn)('python3', [entrypointPath], {
             cwd: extractDir,
             stdio: ['pipe', 'pipe', 'pipe'],
+            env: subprocessEnv,
         });
         // Send input JSON via stdin
         proc.stdin.write(inputJson);
@@ -484,6 +600,51 @@ async function saveAgentLocally(org, agent, agentData) {
     }
     return agentDir;
 }
+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
+    const metaPath = path_1.default.join(agentDir, 'agent.json');
+    try {
+        const existingMeta = await promises_1.default.readFile(metaPath, 'utf-8');
+        const existing = JSON.parse(existingMeta);
+        if (existing.version === version) {
+            // Check if bundle dir exists
+            try {
+                await promises_1.default.access(bundleDir);
+                return bundleDir; // Already cached
+            }
+            catch {
+                // Bundle dir doesn't exist, need to extract
+            }
+        }
+    }
+    catch {
+        // Metadata doesn't exist, need to download
+    }
+    // Download and extract bundle
+    process.stderr.write(`Downloading bundle for ${org}/${agent}@${version}...\n`);
+    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
+    try {
+        await promises_1.default.rm(bundleDir, { recursive: true, force: true });
+    }
+    catch {
+        // Directory might not exist
+    }
+    await promises_1.default.mkdir(bundleDir, { recursive: true });
+    await unzipBundle(tempZip, bundleDir);
+    // Clean up temp file
+    try {
+        await promises_1.default.rm(tempZip);
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+    return bundleDir;
+}
 function registerRunCommand(program) {
     program
         .command('run <agent> [args...]')

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,9 @@ exports.searchAgents = searchAgents;
 exports.fetchLlmKeys = fetchLlmKeys;
 exports.downloadCodeBundle = downloadCodeBundle;
 exports.uploadCodeBundle = uploadCodeBundle;
+exports.getMyAgent = getMyAgent;
+exports.getAgentWithFallback = getAgentWithFallback;
+exports.downloadCodeBundleAuthenticated = downloadCodeBundleAuthenticated;
 class ApiError extends Error {
     status;
     payload;
@@ -166,7 +169,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 +180,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 +197,67 @@ 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);
+}

package/package.json

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