@orchagent/cli 0.3.99 → 0.3.101

package/dist/commands/transfer.js

@@ -8,6 +8,7 @@ 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 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");
@@ -34,7 +35,7 @@ async function promptText(message) {
 }
 function registerTransferCommand(program) {
     program
-        .command('transfer <agent-name>')
+        .command('transfer <agent>')
         .description('Transfer an agent to another workspace')
         .requiredOption('--to <workspace-slug>', 'Target workspace slug')
         .option('-w, --workspace <workspace-slug>', 'Source workspace slug (defaults to active workspace)')
@@ -43,12 +44,13 @@ function registerTransferCommand(program) {
         .option('--json', 'Output result as JSON')
         .addHelpText('after', `
 Examples:
-  orch transfer my-agent --to team-workspace           # Transfer agent to another workspace
+  orch transfer my-agent --to team-workspace           # Transfer by name
+  orch transfer my-org/my-agent --to team-workspace    # Transfer using org/agent format
   orch transfer my-agent --to team-workspace --workspace my-team
   orch transfer my-agent --to team-workspace --dry-run  # Preview transfer
   orch transfer my-agent --to team-workspace --yes      # Skip confirmation
 `)
-        .action(async (agentName, options) => {
+        .action(async (agentArg, options) => {
         const write = (message) => {
             if (!options.json)
                 process.stdout.write(message);
@@ -58,6 +60,14 @@ Examples:
         if (!config.apiKey) {
             throw new errors_1.CliError('Not logged in. Run `orchagent login` first.');
         }
+        // Parse org/agent[@version] or bare agent name
+        const parsed = (0, agent_ref_1.parseAgentRef)(agentArg);
+        const agentName = parsed.agent;
+        // If org was provided via org/agent format, use it as source workspace
+        // --workspace flag takes precedence if both are given
+        if (parsed.org && options.workspace && parsed.org !== options.workspace) {
+            throw new errors_1.CliError(`Conflicting source workspace: '${parsed.org}' (from agent ref) vs '${options.workspace}' (from --workspace flag).`);
+        }
         write('Finding agent and workspaces...\n');
         // Fetch workspace list first (needed to resolve source/target IDs).
         const workspacesResponse = await (0, api_1.request)(config, 'GET', '/workspaces');
@@ -66,8 +76,8 @@ Examples:
         if (!targetWorkspace) {
             throw new errors_1.CliError(`Workspace '${options.to}' not found. Run \`orchagent workspace list\` to see available workspaces.`);
         }
-        // Resolve source workspace (optional). If set, list agents from that workspace.
-        const sourceWorkspaceSlug = options.workspace ?? configFile.workspace;
+        // Resolve source workspace: --workspace flag > org from ref > config workspace
+        const sourceWorkspaceSlug = options.workspace ?? parsed.org ?? configFile.workspace;
         const sourceWorkspace = sourceWorkspaceSlug
             ? workspacesResponse.workspaces.find((w) => w.slug === sourceWorkspaceSlug)
             : null;

package/dist/commands/tree.js

@@ -27,7 +27,21 @@ function registerTreeCommand(program) {
             throw new errors_1.CliError('Missing org. Use org/agent format or set default org.');
         }
         const { agent, version } = parsed;
-        const tree = await (0, api_1.request)(config, 'GET', `/agents/${org}/${agent}/${version}/tree`);
+        // Public-first fallback: try public tree endpoint (works for any public
+        // agent regardless of caller context), then fall back to authenticated
+        // endpoint with workspace header for private agents. Matches the pattern
+        // used by info/fork/estimate commands. (T12-04)
+        let tree;
+        try {
+            tree = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${agent}/${version}/tree`);
+        }
+        catch (err) {
+            if (!(err instanceof api_1.ApiError) || err.status !== 404)
+                throw err;
+            // Public endpoint returned 404 — try authenticated endpoint for private agents
+            const workspaceId = await (0, api_1.resolveWorkspaceIdForOrg)(config, org);
+            tree = await (0, api_1.request)(config, 'GET', `/agents/${org}/${agent}/${version}/tree`, workspaceId ? { headers: { 'X-Workspace-Id': workspaceId } } : undefined);
+        }
         if (options.json) {
             console.log(JSON.stringify(tree, null, 2));
             return;

package/dist/lib/api.js

@@ -284,8 +284,14 @@ async function updateOrg(config, payload) {
 async function getPublicAgent(config, org, agent, version) {
     return publicRequest(config, `/public/agents/${org}/${agent}/${version}`);
 }
-async function getAgentCostEstimate(config, org, agent, version) {
-    return publicRequest(config, `/public/agents/${org}/${agent}/${version}/cost-estimate`);
+async function getAgentCostEstimate(config, org, agent, version, workspaceId) {
+    const path = `/public/agents/${org}/${agent}/${version}/cost-estimate`;
+    if (workspaceId && config.apiKey) {
+        return request(config, 'GET', path, {
+            headers: { 'X-Workspace-Id': workspaceId },
+        });
+    }
+    return publicRequest(config, path);
 }
 async function listMyAgents(config, workspaceId) {
     const headers = {};
@@ -402,15 +408,16 @@ async function resolveWorkspaceIdForOrg(config, orgSlug) {
 /**
  * Download a tool bundle for a private agent using authenticated endpoint.
  */
-async function downloadCodeBundleAuthenticated(config, agentId) {
+async function downloadCodeBundleAuthenticated(config, agentId, workspaceId) {
     if (!config.apiKey) {
         throw new ApiError('Missing API key for authenticated bundle download', 401);
     }
-    const response = await safeFetch(`${config.apiUrl.replace(/\/$/, '')}/agents/${agentId}/bundle`, {
-        headers: {
-            Authorization: `Bearer ${config.apiKey}`,
-        },
-    });
+    const headers = {
+        Authorization: `Bearer ${config.apiKey}`,
+    };
+    if (workspaceId)
+        headers['X-Workspace-Id'] = workspaceId;
+    const response = await safeFetch(`${config.apiUrl.replace(/\/$/, '')}/agents/${agentId}/bundle`, { headers });
     if (!response.ok) {
         const text = await response.text();
         let message = response.statusText;
@@ -548,12 +555,21 @@ async function setWorkspaceDefaultEnvironment(config, workspaceId, environmentId
         headers: { 'Content-Type': 'application/json' },
     });
 }
-async function listAgentKeys(config, agentId) {
-    return request(config, 'GET', `/agents/${agentId}/keys`);
+async function listAgentKeys(config, agentId, workspaceId) {
+    const headers = {};
+    if (workspaceId)
+        headers['X-Workspace-Id'] = workspaceId;
+    return request(config, 'GET', `/agents/${agentId}/keys`, { headers });
 }
-async function createAgentKey(config, agentId) {
-    return request(config, 'POST', `/agents/${agentId}/keys`);
+async function createAgentKey(config, agentId, workspaceId) {
+    const headers = {};
+    if (workspaceId)
+        headers['X-Workspace-Id'] = workspaceId;
+    return request(config, 'POST', `/agents/${agentId}/keys`, { headers });
 }
-async function deleteAgentKey(config, agentId, keyId) {
-    return request(config, 'DELETE', `/agents/${agentId}/keys/${keyId}`);
+async function deleteAgentKey(config, agentId, keyId, workspaceId) {
+    const headers = {};
+    if (workspaceId)
+        headers['X-Workspace-Id'] = workspaceId;
+    return request(config, 'DELETE', `/agents/${agentId}/keys/${keyId}`, { headers });
 }

package/dist/lib/bundle.js

@@ -137,18 +137,23 @@ async function createCodeBundle(sourceDir, outputPath, options = {}) {
         const output = (0, fs_1.createWriteStream)(outputPath);
         const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
         let fileCount = 0;
+        const files = [];
         output.on('close', () => {
             resolve({
                 path: outputPath,
                 sizeBytes: archive.pointer(),
                 fileCount,
+                files,
             });
         });
         archive.on('error', (err) => {
             reject(err);
         });
-        archive.on('entry', () => {
+        archive.on('entry', (entry) => {
             fileCount++;
+            if (entry.name) {
+                files.push(entry.name);
+            }
         });
         archive.pipe(output);
         // Add directory contents with exclusions
@@ -235,6 +240,7 @@ async function previewBundle(sourceDir, options = {}) {
         totalSizeBytes,
         entrypoint,
         excludePatterns,
+        files,
     };
 }
 /**

package/dist/lib/resolve-agent.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOrg = resolveOrg;
+exports.resolveAgentContext = resolveAgentContext;
+const agent_ref_1 = require("./agent-ref");
+const config_1 = require("./config");
+const api_1 = require("./api");
+const errors_1 = require("./errors");
+/**
+ * Resolve the org from a parsed AgentRef using the standard fallback chain:
+ *   1. Explicit org from ref (org/agent@version)
+ *   2. Workspace from config file
+ *   3. defaultOrg from resolved config
+ *
+ * Throws CliError if no org can be determined.
+ */
+async function resolveOrg(parsed, config, options) {
+    if (parsed.org)
+        return parsed.org;
+    const configFile = await (0, config_1.loadConfig)();
+    const org = configFile.workspace ?? config.defaultOrg;
+    if (!org) {
+        throw new errors_1.CliError(options?.missingOrgMessage ??
+            'Missing org. Use org/agent format or set default org.');
+    }
+    return org;
+}
+/**
+ * Central agent-reference resolution pipeline used by all commands.
+ *
+ * Takes a raw agent reference string (e.g., "org/agent@v2", "agent", "agent@latest")
+ * and resolves it to a full context with org, agent name, version, and workspace ID.
+ *
+ * Resolution steps:
+ *   1. Parse the ref string into { org?, agent, version }
+ *   2. Resolve org via fallback chain: ref → config workspace → defaultOrg
+ *   3. Resolve workspace ID for team workspace context (optional)
+ *
+ * @example
+ *   const ctx = await resolveAgentContext('acme/my-agent@v2', config)
+ *   // ctx = { org: 'acme', agent: 'my-agent', version: 'v2', workspaceId: 'ws-123' }
+ *
+ * @example
+ *   const ctx = await resolveAgentContext('my-agent', config)
+ *   // ctx = { org: 'default-org', agent: 'my-agent', version: 'latest', workspaceId: undefined }
+ */
+async function resolveAgentContext(agentRefString, config, options) {
+    const parsed = (0, agent_ref_1.parseAgentRef)(agentRefString);
+    const org = await resolveOrg(parsed, config, {
+        missingOrgMessage: options?.missingOrgMessage,
+    });
+    let workspaceId;
+    if (!options?.skipWorkspaceResolution) {
+        workspaceId = await (0, api_1.resolveWorkspaceIdForOrg)(config, org);
+    }
+    return {
+        org,
+        agent: parsed.agent,
+        version: parsed.version,
+        workspaceId,
+    };
+}

package/package.json

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