@orchagent/cli 0.3.56 → 0.3.58

package/dist/commands/fork.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerForkCommand = registerForkCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const agent_ref_1 = require("../lib/agent-ref");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+const output_1 = require("../lib/output");
+function getWorkspaceAuthError(err) {
+    if (!(err instanceof api_1.ApiError) || (err.status !== 401 && err.status !== 403)) {
+        return null;
+    }
+    const message = err.message.toLowerCase();
+    if (message.includes('workspace targeting') ||
+        message.includes('specified workspace') ||
+        message.includes('user authentication') ||
+        message.includes('clerk')) {
+        return new errors_1.CliError('Forking into a specific workspace requires a user session key. Run `orch login` (browser sign-in, without `--key`) and retry.');
+    }
+    return null;
+}
+async function resolveWorkspace(config, workspaceSlug) {
+    const response = await (0, api_1.request)(config, 'GET', '/workspaces');
+    const workspace = response.workspaces.find((w) => w.slug === workspaceSlug);
+    if (!workspace) {
+        throw new errors_1.CliError(`Workspace '${workspaceSlug}' not found. Run \`orchagent workspace list\` to see available workspaces.`);
+    }
+    return workspace;
+}
+function registerForkCommand(program) {
+    program
+        .command('fork <agent>')
+        .description('Fork a public agent into your workspace')
+        .option('--name <new-name>', 'Rename the forked agent')
+        .option('-w, --workspace <workspace-slug>', 'Target workspace slug')
+        .option('--json', 'Output raw JSON')
+        .addHelpText('after', `
+Examples:
+  orch fork orchagent/my-discord-agent
+  orch fork orchagent/my-discord-agent --workspace acme-corp
+  orch fork orchagent/my-discord-agent --name customer-support-bot
+  orch fork orchagent/my-discord-agent@v2 --json
+`)
+        .action(async (agentRef, options) => {
+        const write = (message) => {
+            if (!options.json)
+                process.stdout.write(message);
+        };
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Not logged in. Run `orchagent login` first.');
+        }
+        const { org, agent, version } = (0, agent_ref_1.parseAgentRef)(agentRef);
+        write('Resolving source agent...\n');
+        const source = await (0, api_1.getPublicAgent)(config, org, agent, version);
+        if (!source.id) {
+            throw new errors_1.CliError(`Could not resolve source agent ID for '${org}/${agent}@${version}'.`);
+        }
+        let targetWorkspace = null;
+        if (options.workspace) {
+            write('Resolving target workspace...\n');
+            targetWorkspace = await resolveWorkspace(config, options.workspace);
+        }
+        write('Forking agent...\n');
+        const payload = {};
+        if (targetWorkspace)
+            payload.workspace_id = targetWorkspace.id;
+        const requestedName = options.name?.trim();
+        if (requestedName)
+            payload.new_name = requestedName;
+        let result;
+        try {
+            result = await (0, api_1.forkAgent)(config, source.id, payload);
+        }
+        catch (err) {
+            const authErr = getWorkspaceAuthError(err);
+            if (authErr)
+                throw authErr;
+            throw err;
+        }
+        await (0, analytics_1.track)('cli_fork', {
+            source_org: org,
+            source_agent: agent,
+            source_version: version,
+            target_workspace: targetWorkspace?.slug ?? null,
+        });
+        if (options.json) {
+            (0, output_1.printJson)(result);
+            return;
+        }
+        const forked = result.agent;
+        const targetOrgSlug = forked.org_slug ?? targetWorkspace?.slug ?? 'current-workspace';
+        write(`\n${chalk_1.default.green('\u2713')} Forked ${org}/${agent}@${version}\n`);
+        write(`  New agent: ${targetOrgSlug}/${forked.name}@${forked.version}\n`);
+        if (targetWorkspace) {
+            write(`  Workspace: ${targetWorkspace.name} (${targetWorkspace.slug})\n`);
+        }
+        if (result.service_key) {
+            write(`\nService key (save this - shown only once):\n`);
+            write(`  ${result.service_key}\n`);
+        }
+    });
+}

package/dist/commands/index.js

@@ -12,6 +12,7 @@ const run_1 = require("./run");
 const info_1 = require("./info");
 const skill_1 = require("./skill");
 const delete_1 = require("./delete");
+const fork_1 = require("./fork");
 const github_1 = require("./github");
 const doctor_1 = require("./doctor");
 const status_1 = require("./status");
@@ -31,6 +32,7 @@ const agent_keys_1 = require("./agent-keys");
 const schedule_1 = require("./schedule");
 const service_1 = require("./service");
 const transfer_1 = require("./transfer");
+const pull_1 = require("./pull");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, whoami_1.registerWhoamiCommand)(program);
@@ -43,6 +45,7 @@ function registerCommands(program) {
     (0, keys_1.registerKeysCommand)(program);
     (0, skill_1.registerSkillCommand)(program);
     (0, delete_1.registerDeleteCommand)(program);
+    (0, fork_1.registerForkCommand)(program);
     (0, github_1.registerGitHubCommand)(program);
     (0, doctor_1.registerDoctorCommand)(program);
     (0, status_1.registerStatusCommand)(program);
@@ -62,4 +65,5 @@ function registerCommands(program) {
     (0, schedule_1.registerScheduleCommand)(program);
     (0, service_1.registerServiceCommand)(program);
     (0, transfer_1.registerTransferCommand)(program);
+    (0, pull_1.registerPullCommand)(program);
 }

package/dist/commands/pull.js

@@ -0,0 +1,419 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPullCommand = registerPullCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+const output_1 = require("../lib/output");
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function parsePullRef(value) {
+    const [ref, versionPart] = value.split('@');
+    const version = versionPart?.trim() || 'latest';
+    const segments = ref.split('/');
+    if (segments.length === 1) {
+        return { agent: segments[0], version };
+    }
+    if (segments.length === 2) {
+        return { org: segments[0], agent: segments[1], version };
+    }
+    throw new errors_1.CliError('Invalid agent reference. Use org/agent[@version] or agent[@version] format.');
+}
+function canonicalType(typeValue) {
+    const normalized = (typeValue || 'agent').toLowerCase();
+    return normalized === 'skill' ? 'skill' : 'agent';
+}
+function resolveEngine(data) {
+    const ee = data.execution_engine;
+    if (ee === 'direct_llm' || ee === 'managed_loop' || ee === 'code_runtime') {
+        return ee;
+    }
+    const normalized = (data.type || '').toLowerCase();
+    if (normalized === 'tool' || normalized === 'code')
+        return 'code_runtime';
+    if (normalized === 'agentic')
+        return 'managed_loop';
+    return 'direct_llm';
+}
+// ─── Agent Resolution ───────────────────────────────────────────────────────
+async function resolveAgent(config, org, agent, version) {
+    // 1. Try public download endpoint
+    try {
+        const data = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${agent}/${version}/download`);
+        return {
+            name: data.name,
+            version: data.version,
+            description: data.description,
+            type: data.type || 'agent',
+            run_mode: data.run_mode,
+            execution_engine: data.execution_engine,
+            callable: data.callable,
+            prompt: data.prompt,
+            input_schema: data.input_schema,
+            output_schema: data.output_schema,
+            supported_providers: data.supported_providers,
+            default_models: data.default_models,
+            default_skills: data.default_skills,
+            skills_locked: data.skills_locked,
+            source_url: data.source_url,
+            pip_package: data.pip_package,
+            run_command: data.run_command,
+            entrypoint: data.entrypoint,
+            has_bundle: data.has_bundle,
+            source: 'public_download',
+        };
+    }
+    catch (err) {
+        // 2. Handle 403 (server-only / download-disabled)
+        if (err instanceof api_1.ApiError && err.status === 403) {
+            const payload = err.payload;
+            const errorCode = payload?.error?.code;
+            if (errorCode === 'PAID_AGENT_SERVER_ONLY' || errorCode === 'DOWNLOAD_DISABLED') {
+                // Try authenticated owner path
+                if (config.apiKey) {
+                    const ownerData = await tryOwnerFallback(config, org, agent, version);
+                    if (ownerData)
+                        return { ...ownerData, source: 'owner_authenticated' };
+                }
+                // Not owner - block with message
+                if (errorCode === 'PAID_AGENT_SERVER_ONLY') {
+                    throw new errors_1.CliError(`This agent is paid and runs on server only.\n\n` +
+                        `Use cloud execution: orch run ${org}/${agent}@${version} --data '{...}'`);
+                }
+                throw new errors_1.CliError(`This agent is server-only and cannot be downloaded.\n\n` +
+                    `Use cloud execution: orch run ${org}/${agent}@${version} --data '{...}'`);
+            }
+        }
+        // 3. Handle 404 - try private authenticated fallback
+        if (!(err instanceof api_1.ApiError) || err.status !== 404)
+            throw err;
+    }
+    // 4. Private agent fallback (authenticated)
+    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);
+    }
+    const data = await resolveFromMyAgents(config, agent, version, org);
+    if (!data) {
+        throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+    }
+    return { ...data, source: 'private_authenticated' };
+}
+async function tryOwnerFallback(config, org, agent, version) {
+    try {
+        const myAgents = await (0, api_1.listMyAgents)(config);
+        let match;
+        if (version === 'latest') {
+            match = myAgents
+                .filter(a => a.name === agent && a.org_slug === org)
+                .sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+        }
+        else {
+            match = myAgents.find(a => a.name === agent && a.version === version && a.org_slug === org);
+        }
+        if (!match)
+            return null;
+        const agentData = await (0, api_1.request)(config, 'GET', `/agents/${match.id}`);
+        return mapAgentToPullData(agentData);
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveFromMyAgents(config, agent, version, org) {
+    const agents = await (0, api_1.listMyAgents)(config);
+    const matching = agents.filter(a => a.name === agent);
+    if (matching.length === 0)
+        return null;
+    let target;
+    if (version === 'latest') {
+        target = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+    }
+    else {
+        const found = matching.find(a => a.version === version);
+        if (!found)
+            return null;
+        target = found;
+    }
+    const agentData = await (0, api_1.request)(config, 'GET', `/agents/${target.id}`);
+    return mapAgentToPullData(agentData);
+}
+function mapAgentToPullData(agent) {
+    return {
+        name: agent.name,
+        version: agent.version,
+        description: agent.description,
+        type: agent.type,
+        run_mode: agent.run_mode ?? null,
+        execution_engine: agent.execution_engine ?? null,
+        callable: agent.callable,
+        prompt: agent.prompt,
+        input_schema: agent.input_schema,
+        output_schema: agent.output_schema,
+        supported_providers: agent.supported_providers,
+        default_models: agent.default_models,
+        tags: agent.tags,
+        default_skills: agent.default_skills,
+        skills_locked: agent.skills_locked,
+        source_url: agent.source_url,
+        pip_package: agent.pip_package,
+        run_command: agent.run_command,
+        entrypoint: agent.entrypoint,
+        has_bundle: !!agent.code_bundle_url,
+        manifest: agent.manifest,
+        agentId: agent.id,
+    };
+}
+// ─── Manifest Reconstruction ────────────────────────────────────────────────
+function buildManifest(data) {
+    const manifest = {
+        name: data.name,
+        description: data.description || '',
+        type: canonicalType(data.type) === 'skill' ? 'skill' : 'agent',
+    };
+    if (data.run_mode)
+        manifest.run_mode = data.run_mode;
+    if (data.callable !== undefined)
+        manifest.callable = data.callable;
+    if (data.tags && data.tags.length > 0)
+        manifest.tags = data.tags;
+    if (data.supported_providers && data.supported_providers.length > 0) {
+        // Don't include if it's just ['any'] (the default)
+        if (!(data.supported_providers.length === 1 && data.supported_providers[0] === 'any')) {
+            manifest.supported_providers = data.supported_providers;
+        }
+    }
+    if (data.default_models && Object.keys(data.default_models).length > 0) {
+        manifest.default_models = data.default_models;
+    }
+    // Skills
+    if (data.default_skills && data.default_skills.length > 0) {
+        manifest.default_skills = data.default_skills;
+    }
+    if (data.skills_locked !== undefined && data.skills_locked) {
+        manifest.skills_locked = true;
+    }
+    // Engine-specific fields
+    const engine = resolveEngine(data);
+    if (engine === 'code_runtime') {
+        if (data.entrypoint && data.entrypoint !== 'sandbox_main.py') {
+            manifest.entrypoint = data.entrypoint;
+        }
+        if (data.source_url)
+            manifest.source_url = data.source_url;
+        if (data.pip_package)
+            manifest.pip_package = data.pip_package;
+        if (data.run_command)
+            manifest.run_command = data.run_command;
+    }
+    // Include orchestration manifest if present (for dependencies, etc.)
+    if (data.manifest && typeof data.manifest === 'object') {
+        const m = { ...data.manifest };
+        // Clean up fields that are already top-level
+        delete m.runtime;
+        delete m.loop;
+        if (Object.keys(m).length > 0) {
+            manifest.manifest = m;
+        }
+    }
+    return manifest;
+}
+// ─── Bundle Download + Extraction ───────────────────────────────────────────
+async function downloadBundle(config, org, agent, version, agentId) {
+    try {
+        return await (0, api_1.downloadCodeBundle)(config, org, agent, version);
+    }
+    catch (err) {
+        if (!(err instanceof api_1.ApiError) || err.status !== 404)
+            throw err;
+    }
+    if (config.apiKey && agentId) {
+        try {
+            return await (0, api_1.downloadCodeBundleAuthenticated)(config, agentId);
+        }
+        catch (err) {
+            if (!(err instanceof api_1.ApiError) || err.status !== 404)
+                throw err;
+        }
+    }
+    return null;
+}
+async function unzipBundle(zipPath, destDir) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)('unzip', ['-q', zipPath, '-d', destDir], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        proc.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                const detail = stderr.trim() || `exit code ${code}`;
+                reject(new errors_1.CliError(`Failed to extract bundle: ${detail}`));
+            }
+            else {
+                resolve();
+            }
+        });
+        proc.on('error', (err) => {
+            reject(new errors_1.CliError(`Failed to run unzip: ${err.message}. Make sure unzip is installed.`));
+        });
+    });
+}
+// ─── Command ────────────────────────────────────────────────────────────────
+function registerPullCommand(program) {
+    program
+        .command('pull <agent>')
+        .description('Pull a published agent into a local project directory')
+        .option('-o, --output <path>', 'Output directory (default: ./<agent-name>/)')
+        .option('--overwrite', 'Replace existing output directory contents')
+        .option('--json', 'Print machine-readable result summary')
+        .addHelpText('after', `
+Examples:
+  orch pull acme/my-agent
+  orch pull acme/my-agent@v2
+  orch pull my-agent --output ./custom-dir
+  orch pull acme/my-agent --overwrite
+  orch pull acme/my-agent --json
+`)
+        .action(async (agentRef, options) => {
+        const write = (message) => {
+            if (!options.json)
+                process.stdout.write(message);
+        };
+        const config = await (0, config_1.getResolvedConfig)();
+        const parsed = parsePullRef(agentRef);
+        // Resolve org from workspace / defaultOrg fallback
+        const configFile = await (0, config_1.loadConfig)();
+        const org = parsed.org ?? configFile.workspace ?? config.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/agent[@version] format, or set a default org with:\n' +
+                '  orch config set default-org <org>');
+        }
+        write(`Resolving ${org}/${parsed.agent}@${parsed.version}...\n`);
+        // Resolve agent data
+        const data = await resolveAgent(config, org, parsed.agent, parsed.version);
+        // Reject skills
+        if (canonicalType(data.type) === 'skill') {
+            throw new errors_1.CliError("This is a skill. Use 'orch skill install <ref>' instead.");
+        }
+        // Resolve output path
+        const outputDir = path_1.default.resolve(options.output || `./${data.name}`);
+        // Check if output path already exists
+        try {
+            const stat = await promises_1.default.stat(outputDir);
+            if (stat.isFile()) {
+                throw new errors_1.CliError(`Output path '${outputDir}' is a file. Please specify a directory.`);
+            }
+            if (!options.overwrite) {
+                throw new errors_1.CliError(`Output directory '${outputDir}' already exists.\n` +
+                    `Use --overwrite to replace its contents.`);
+            }
+            // Overwrite: clear and recreate
+            await promises_1.default.rm(outputDir, { recursive: true });
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                if (err instanceof errors_1.CliError)
+                    throw err;
+                throw err;
+            }
+        }
+        await promises_1.default.mkdir(outputDir, { recursive: true });
+        const engine = resolveEngine(data);
+        const filesWritten = [];
+        const warnings = [];
+        let bundleExtracted = false;
+        // Write orchagent.json
+        const manifest = buildManifest(data);
+        await promises_1.default.writeFile(path_1.default.join(outputDir, 'orchagent.json'), JSON.stringify(manifest, null, 2) + '\n');
+        filesWritten.push('orchagent.json');
+        // Write prompt.md (for prompt-driven engines)
+        if (data.prompt && (engine === 'direct_llm' || engine === 'managed_loop')) {
+            await promises_1.default.writeFile(path_1.default.join(outputDir, 'prompt.md'), data.prompt);
+            filesWritten.push('prompt.md');
+        }
+        // Write schema.json (if schemas exist)
+        if (data.input_schema || data.output_schema) {
+            const schema = {};
+            if (data.input_schema)
+                schema.input = data.input_schema;
+            if (data.output_schema)
+                schema.output = data.output_schema;
+            await promises_1.default.writeFile(path_1.default.join(outputDir, 'schema.json'), JSON.stringify(schema, null, 2) + '\n');
+            filesWritten.push('schema.json');
+        }
+        // Bundle download for code_runtime agents
+        if (engine === 'code_runtime' && data.has_bundle) {
+            write('Downloading code bundle...\n');
+            const bundle = await downloadBundle(config, org, data.name, data.version, data.agentId);
+            if (bundle) {
+                const tempDir = path_1.default.join(os_1.default.tmpdir(), `orchagent-pull-${Date.now()}`);
+                const zipPath = path_1.default.join(tempDir, 'bundle.zip');
+                try {
+                    await promises_1.default.mkdir(tempDir, { recursive: true });
+                    await promises_1.default.writeFile(zipPath, bundle);
+                    await unzipBundle(zipPath, outputDir);
+                    bundleExtracted = true;
+                    write('Bundle extracted.\n');
+                }
+                finally {
+                    await promises_1.default.rm(tempDir, { recursive: true, force: true }).catch(() => { });
+                }
+            }
+            else {
+                warnings.push('No downloadable bundle available for this version.');
+            }
+        }
+        else if (engine === 'code_runtime' && !data.has_bundle) {
+            warnings.push('No downloadable bundle available for this version.');
+        }
+        // Track analytics
+        await (0, analytics_1.track)('cli_pull', {
+            org,
+            agent: parsed.agent,
+            version: data.version,
+            engine,
+            source: data.source,
+        });
+        // Output
+        const resolvedRef = `${org}/${data.name}@${data.version}`;
+        if (options.json) {
+            const result = {
+                success: true,
+                requested_ref: `${org}/${parsed.agent}@${parsed.version}`,
+                resolved_ref: resolvedRef,
+                output_dir: outputDir,
+                engine,
+                source: data.source,
+                files_written: filesWritten,
+                bundle_extracted: bundleExtracted,
+                warnings,
+            };
+            (0, output_1.printJson)(result);
+            return;
+        }
+        write(`\n${chalk_1.default.green('\u2713')} Pulled ${resolvedRef}\n`);
+        write(`  Output: ${outputDir}\n`);
+        write(`  Engine: ${engine}\n`);
+        write(`  Files:  ${filesWritten.join(', ')}\n`);
+        if (bundleExtracted) {
+            write(`  Bundle: extracted\n`);
+        }
+        for (const w of warnings) {
+            write(`  ${chalk_1.default.yellow('Warning:')} ${w}\n`);
+        }
+    });
+}

package/dist/index.js

@@ -61,6 +61,7 @@ program
 Quick Reference:
   run   Run an agent (cloud by default, --local for local execution)
   info  Show agent details and input/output schemas
+  fork  Fork a public template into your workspace
 
 Installation:
   npm install -g @orchagent/cli   Install globally (then use: orch)

package/dist/lib/api.js

@@ -54,6 +54,7 @@ exports.getAgentWithFallback = getAgentWithFallback;
 exports.downloadCodeBundleAuthenticated = downloadCodeBundleAuthenticated;
 exports.checkAgentDelete = checkAgentDelete;
 exports.deleteAgent = deleteAgent;
+exports.forkAgent = forkAgent;
 exports.checkAgentTransfer = checkAgentTransfer;
 exports.transferAgent = transferAgent;
 exports.previewAgentVersion = previewAgentVersion;
@@ -368,6 +369,15 @@ async function deleteAgent(config, agentId, confirmationName) {
     const params = confirmationName ? `?confirmation_name=${encodeURIComponent(confirmationName)}` : '';
     return request(config, 'DELETE', `/agents/${agentId}${params}`);
 }
+/**
+ * Fork a public agent into the caller's workspace (or an explicit workspace_id).
+ */
+async function forkAgent(config, sourceAgentId, data = {}) {
+    return request(config, 'POST', `/agents/${sourceAgentId}/fork`, {
+        body: JSON.stringify(data),
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
 /**
  * Check if an agent can be transferred to another workspace.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.3.56",
+  "version": "0.3.58",
   "description": "Command-line interface for orchagent — deploy and run AI agents for your team",
   "license": "MIT",
   "author": "orchagent <hello@orchagent.io>",