@orchagent/cli 0.2.11 → 0.2.13

package/dist/commands/index.js

@@ -10,12 +10,14 @@ const whoami_1 = require("./whoami");
 const star_1 = require("./star");
 const fork_1 = require("./fork");
 const search_1 = require("./search");
-const llm_config_1 = require("./llm-config");
 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");
+const github_1 = require("./github");
+const doctor_1 = require("./doctor");
+const status_1 = require("./status");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, whoami_1.registerWhoamiCommand)(program);
@@ -28,8 +30,10 @@ function registerCommands(program) {
     (0, search_1.registerSearchCommand)(program);
     (0, star_1.registerStarCommand)(program);
     (0, fork_1.registerForkCommand)(program);
-    (0, llm_config_1.registerLlmConfigCommand)(program);
     (0, keys_1.registerKeysCommand)(program);
     (0, skill_1.registerSkillCommand)(program);
     (0, delete_1.registerDeleteCommand)(program);
+    (0, github_1.registerGitHubCommand)(program);
+    (0, doctor_1.registerDoctorCommand)(program);
+    (0, status_1.registerStatusCommand)(program);
 }

package/dist/commands/publish.js

@@ -68,6 +68,7 @@ function registerPublishCommand(program) {
         .option('--public', 'Make agent public (default: true)', true)
         .option('--private', 'Make agent private')
         .option('--profile <name>', 'Use API key from named profile')
+        .option('--dry-run', 'Show what would be published without making changes')
         .action(async (options) => {
         const config = await (0, config_1.getResolvedConfig)({}, options.profile);
         const cwd = process.cwd();
@@ -77,6 +78,29 @@ function registerPublishCommand(program) {
         if (skillData) {
             // Publish as a skill (server auto-assigns version)
             const org = await (0, api_1.getOrg)(config);
+            // Handle dry-run for skills
+            if (options.dryRun) {
+                const preview = await (0, api_1.previewAgentVersion)(config, skillData.frontmatter.name);
+                const skillBodyBytes = Buffer.byteLength(skillData.body, 'utf-8');
+                const versionInfo = preview.existing_versions.length > 0
+                    ? `${preview.next_version} (new version, ${preview.existing_versions[preview.existing_versions.length - 1]} exists)`
+                    : `${preview.next_version} (first version)`;
+                process.stderr.write('\nDRY RUN - No changes will be made\n\n');
+                process.stderr.write('Validating...\n');
+                process.stderr.write(`  ✓ SKILL.md found and valid\n`);
+                process.stderr.write(`  ✓ Skill prompt (${skillBodyBytes.toLocaleString()} bytes)\n`);
+                process.stderr.write(`  ✓ Authentication valid (org: ${org.slug})\n`);
+                process.stderr.write('\nSkill Preview:\n');
+                process.stderr.write(`  Name:        ${skillData.frontmatter.name}\n`);
+                process.stderr.write(`  Type:        skill\n`);
+                process.stderr.write(`  Version:     ${versionInfo}\n`);
+                process.stderr.write(`  Visibility:  ${options.private ? 'private' : 'public'}\n`);
+                process.stderr.write(`  Providers:   any\n`);
+                process.stderr.write(`\nWould publish: ${preview.org_slug}/${skillData.frontmatter.name}@${preview.next_version}\n`);
+                process.stderr.write(`API endpoint: POST ${config.apiUrl}/${preview.org_slug}/${skillData.frontmatter.name}/${preview.next_version}/run\n\n`);
+                process.stderr.write('No changes made (dry run)\n');
+                return;
+            }
             const skillResult = await (0, api_1.createAgent)(config, {
                 name: skillData.frontmatter.name,
                 type: 'skill',
@@ -118,7 +142,9 @@ function registerPublishCommand(program) {
             catch (err) {
                 if (err.code === 'ENOENT') {
                     const agentTypeName = manifest.type === 'skill' ? 'skill' : 'prompt-based agent';
-                    throw new errors_1.CliError(`No prompt.md found for ${agentTypeName}`);
+                    throw new errors_1.CliError(`No prompt.md found for ${agentTypeName}.\n\n` +
+                        'Create a prompt.md file in the current directory with your prompt template.\n' +
+                        'See: https://orchagent.io/docs/publishing');
                 }
                 throw err;
             }
@@ -164,10 +190,68 @@ function registerPublishCommand(program) {
         let sdkCompatible = false;
         if (manifest.type === 'code') {
             sdkCompatible = await detectSdkCompatible(cwd);
-            if (sdkCompatible) {
+            if (sdkCompatible && !options.dryRun) {
                 process.stdout.write(`SDK detected - agent will be marked as Local Ready\n`);
             }
         }
+        // Handle dry-run for agents
+        if (options.dryRun) {
+            const preview = await (0, api_1.previewAgentVersion)(config, manifest.name);
+            const versionInfo = preview.existing_versions.length > 0
+                ? `${preview.next_version} (new version, ${preview.existing_versions[preview.existing_versions.length - 1]} exists)`
+                : `${preview.next_version} (first version)`;
+            process.stderr.write('\nDRY RUN - No changes will be made\n\n');
+            process.stderr.write('Validating...\n');
+            process.stderr.write(`  ✓ orchagent.json found and valid\n`);
+            if (manifest.type === 'prompt') {
+                // Prompt agent validations
+                const promptBytes = prompt ? Buffer.byteLength(prompt, 'utf-8') : 0;
+                process.stderr.write(`  ✓ prompt.md found (${promptBytes.toLocaleString()} bytes)\n`);
+                if (inputSchema || outputSchema) {
+                    const schemaTypes = [inputSchema ? 'input' : null, outputSchema ? 'output' : null].filter(Boolean).join(' + ');
+                    process.stderr.write(`  ✓ schema.json found (${schemaTypes} schemas)\n`);
+                }
+            }
+            else if (manifest.type === 'code') {
+                // Code agent validations
+                const entrypoint = manifest.entrypoint || await (0, bundle_1.detectEntrypoint)(cwd);
+                process.stderr.write(`  ✓ Entrypoint: ${entrypoint}\n`);
+                if (sdkCompatible) {
+                    process.stderr.write(`  ✓ SDK detected (orchagent-sdk in requirements.txt)\n`);
+                }
+            }
+            process.stderr.write(`  ✓ Authentication valid (org: ${org.slug})\n`);
+            // For code agents with bundles, show bundle preview
+            if (shouldUploadBundle) {
+                const bundlePreview = await (0, bundle_1.previewBundle)(cwd, {
+                    entrypoint: manifest.entrypoint,
+                    exclude: manifest.bundle?.exclude,
+                    include: manifest.bundle?.include,
+                });
+                process.stderr.write(`\nBundle Preview:\n`);
+                process.stderr.write(`  Files:       ${bundlePreview.fileCount} files\n`);
+                process.stderr.write(`  Size:        ${(bundlePreview.totalSizeBytes / 1024).toFixed(1)} KB\n`);
+                process.stderr.write(`  Entrypoint:  ${bundlePreview.entrypoint}\n`);
+            }
+            process.stderr.write('\nAgent Preview:\n');
+            process.stderr.write(`  Name:        ${manifest.name}\n`);
+            process.stderr.write(`  Type:        ${manifest.type}${shouldUploadBundle ? ' (hosted)' : ''}\n`);
+            process.stderr.write(`  Version:     ${versionInfo}\n`);
+            process.stderr.write(`  Visibility:  ${options.private ? 'private' : 'public'}\n`);
+            process.stderr.write(`  Providers:   ${supportedProviders.join(', ')}\n`);
+            process.stderr.write(`\nWould publish: ${preview.org_slug}/${manifest.name}@${preview.next_version}\n`);
+            if (shouldUploadBundle) {
+                const bundlePreview = await (0, bundle_1.previewBundle)(cwd, {
+                    entrypoint: manifest.entrypoint,
+                    exclude: manifest.bundle?.exclude,
+                    include: manifest.bundle?.include,
+                });
+                process.stderr.write(`Would upload bundle: ${(bundlePreview.totalSizeBytes / 1024).toFixed(1)} KB\n`);
+            }
+            process.stderr.write(`API endpoint: POST ${config.apiUrl}/${preview.org_slug}/${manifest.name}/${preview.next_version}/run\n\n`);
+            process.stderr.write('No changes made (dry run)\n');
+            return;
+        }
         // Create the agent (server auto-assigns version)
         const result = await (0, api_1.createAgent)(config, {
             name: manifest.name,

package/dist/commands/run.js

@@ -339,7 +339,12 @@ async function installCodeAgent(agentData) {
     process.stderr.write(`Installing ${installSource}...\n`);
     const { code } = await runCommand('python3', ['-m', 'pip', 'install', '--quiet', installSource]);
     if (code !== 0) {
-        throw new errors_1.CliError(`Failed to install agent. Exit code: ${code}`);
+        throw new errors_1.CliError(`Failed to install agent (exit code ${code}).\n\n` +
+            'Troubleshooting:\n' +
+            '  - Check Python is installed: python3 --version\n' +
+            '  - Check pip is available: pip --version\n' +
+            '  - Check network connectivity\n' +
+            '  - Try installing manually: pip install <package>');
     }
     process.stderr.write(`Installation complete.\n`);
 }
@@ -446,7 +451,7 @@ async function executeBundleAgent(config, org, agentName, version, agentData, ar
                 inputJson = JSON.stringify(parsed);
             }
             catch {
-                throw new errors_1.CliError('Invalid JSON in --input option');
+                throw (0, errors_1.jsonInputError)('input');
             }
         }
         else if (args.length > 0) {

package/dist/commands/skill.js

@@ -79,18 +79,19 @@ async function downloadSkillWithFallback(config, org, skill, version) {
     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') {
+    let targetAgent;
+    if (version === 'latest') {
+        // For 'latest', get most recently created
+        targetAgent = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+    }
+    else {
+        // For any explicit version (v1, v2, etc.), find exact match
         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'})`);
@@ -169,7 +170,9 @@ Instructions and guidance for AI agents...
         // 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');
+            throw new errors_1.CliError('Skill has no content.\n\n' +
+                'The skill exists but has an empty prompt. This may be a publishing issue.\n' +
+                'Try re-publishing the skill or contact the skill author.');
         }
         // Determine base directory (home or current)
         const baseDir = options.global ? os_1.default.homedir() : process.cwd();

package/dist/commands/status.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStatusCommand = registerStatusCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const output_1 = require("../lib/output");
+const STATUS_URL = 'https://api.orchagent.io/health/detailed';
+const STATUS_PAGE_URL = 'https://status.orchagent.io';
+function getStatusIcon(status) {
+    switch (status) {
+        case 'operational':
+            return chalk_1.default.green('\u2713');
+        case 'degraded':
+            return chalk_1.default.yellow('\u26a0');
+        case 'outage':
+            return chalk_1.default.red('\u2717');
+        default:
+            return chalk_1.default.gray('?');
+    }
+}
+function getStatusLabel(status) {
+    switch (status) {
+        case 'operational':
+            return chalk_1.default.green('Operational');
+        case 'degraded':
+            return chalk_1.default.yellow('Degraded');
+        case 'outage':
+            return chalk_1.default.red('Outage');
+        default:
+            return chalk_1.default.gray('Unknown');
+    }
+}
+function getOverallStatus(services) {
+    const hasOutage = services.some((s) => s.status === 'outage');
+    const hasDegraded = services.some((s) => s.status === 'degraded');
+    if (hasOutage) {
+        return chalk_1.default.red('Service Outage');
+    }
+    if (hasDegraded) {
+        return chalk_1.default.yellow('Partial Outage');
+    }
+    return chalk_1.default.green('All Systems Operational');
+}
+function formatLatency(latencyMs) {
+    if (latencyMs === undefined) {
+        return '';
+    }
+    return chalk_1.default.gray(` (${latencyMs}ms)`);
+}
+function printHumanStatus(data) {
+    const overallStatus = getOverallStatus(data.services);
+    process.stdout.write(`\nOrchAgent Status: ${overallStatus}\n\n`);
+    for (const service of data.services) {
+        const icon = getStatusIcon(service.status);
+        const label = getStatusLabel(service.status);
+        const latency = formatLatency(service.latency_ms);
+        const paddedName = service.name.padEnd(18);
+        process.stdout.write(`  ${paddedName} ${icon} ${label}${latency}\n`);
+    }
+    process.stdout.write(`\nView details: ${chalk_1.default.cyan(STATUS_PAGE_URL)}\n`);
+}
+function registerStatusCommand(program) {
+    program
+        .command('status')
+        .description('Check OrchAgent service status')
+        .option('--json', 'Output raw JSON')
+        .action(async (options) => {
+        try {
+            const response = await fetch(STATUS_URL, {
+                headers: {
+                    Accept: 'application/json',
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = (await response.json());
+            if (options.json) {
+                (0, output_1.printJson)(data);
+                return;
+            }
+            printHumanStatus(data);
+        }
+        catch (err) {
+            if (options.json) {
+                (0, output_1.printJson)({ error: 'Unable to fetch status', details: String(err) });
+                process.exit(1);
+            }
+            process.stderr.write(chalk_1.default.red('\nUnable to fetch status\n\n') +
+                chalk_1.default.gray(`Error: ${err instanceof Error ? err.message : String(err)}\n\n`) +
+                `Check ${chalk_1.default.cyan(STATUS_PAGE_URL)} for current status.\n`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/workspace.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWorkspaceCommand = registerWorkspaceCommand;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+function registerWorkspaceCommand(program) {
+    const workspace = program
+        .command('workspace')
+        .description('Manage workspaces');
+    // List workspaces
+    workspace
+        .command('list')
+        .description('List all workspaces')
+        .action(async () => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const fileConfig = await (0, config_1.loadConfig)();
+        const workspaces = await (0, api_1.listWorkspaces)(config);
+        if (workspaces.length === 0) {
+            process.stdout.write('No workspaces found.\n');
+            return;
+        }
+        const currentId = fileConfig.current_workspace;
+        for (const ws of workspaces) {
+            const isCurrent = ws.id === currentId || ws.slug === currentId;
+            const marker = isCurrent ? '* ' : '  ';
+            const type = ws.type === 'team' ? '(team)' : '(personal)';
+            const members = ws.type === 'team' ? ` - ${ws.member_count} members` : '';
+            process.stdout.write(`${marker}${ws.slug} - ${ws.name} ${type}${members}\n`);
+        }
+    });
+    // Switch workspace
+    workspace
+        .command('use <slug>')
+        .description('Switch to a different workspace')
+        .action(async (slug) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const workspaces = await (0, api_1.listWorkspaces)(config);
+        const target = workspaces.find(ws => ws.slug === slug || ws.id === slug);
+        if (!target) {
+            process.stderr.write(`Workspace "${slug}" not found.\n`);
+            process.exit(1);
+        }
+        const fileConfig = await (0, config_1.loadConfig)();
+        fileConfig.current_workspace = target.id;
+        await (0, config_1.saveConfig)(fileConfig);
+        process.stdout.write(`Switched to workspace: ${target.name} (${target.slug})\n`);
+    });
+    // Create workspace
+    workspace
+        .command('create <name>')
+        .description('Create a new team workspace')
+        .option('--slug <slug>', 'Workspace URL slug')
+        .action(async (name, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        // Auto-generate slug from name if not provided
+        const slug = options.slug || name
+            .toLowerCase()
+            .replace(/\s+/g, '-')
+            .replace(/[^a-z0-9-]/g, '')
+            .replace(/-+/g, '-')
+            .slice(0, 30);
+        try {
+            const workspace = await (0, api_1.createWorkspace)(config, { name, slug });
+            // Switch to the new workspace
+            const fileConfig = await (0, config_1.loadConfig)();
+            fileConfig.current_workspace = workspace.id;
+            await (0, config_1.saveConfig)(fileConfig);
+            process.stdout.write(`Created workspace: ${workspace.name} (${workspace.slug})\n`);
+            process.stdout.write(`Switched to new workspace.\n`);
+        }
+        catch (err) {
+            process.stderr.write(`Failed to create workspace: ${err instanceof Error ? err.message : 'Unknown error'}\n`);
+            process.exit(1);
+        }
+    });
+    // Invite member
+    workspace
+        .command('invite <email>')
+        .description('Invite a member to the current workspace')
+        .option('--role <role>', 'Role: owner or member', 'member')
+        .action(async (email, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const fileConfig = await (0, config_1.loadConfig)();
+        if (!fileConfig.current_workspace) {
+            process.stderr.write('No workspace selected. Run `orch workspace use <slug>` first.\n');
+            process.exit(1);
+        }
+        const role = options.role;
+        if (role !== 'owner' && role !== 'member') {
+            process.stderr.write('Role must be "owner" or "member".\n');
+            process.exit(1);
+        }
+        try {
+            await (0, api_1.inviteToWorkspace)(config, fileConfig.current_workspace, { email, role });
+            process.stdout.write(`Invited ${email} as ${role}.\n`);
+        }
+        catch (err) {
+            process.stderr.write(`Failed to send invite: ${err instanceof Error ? err.message : 'Unknown error'}\n`);
+            process.exit(1);
+        }
+    });
+    // List members
+    workspace
+        .command('members')
+        .description('List members of the current workspace')
+        .action(async () => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const fileConfig = await (0, config_1.loadConfig)();
+        if (!fileConfig.current_workspace) {
+            process.stderr.write('No workspace selected. Run `orch workspace use <slug>` first.\n');
+            process.exit(1);
+        }
+        try {
+            const { members, invites } = await (0, api_1.getWorkspaceMembers)(config, fileConfig.current_workspace);
+            process.stdout.write('Members:\n');
+            for (const member of members) {
+                const roleLabel = member.role === 'owner' ? '[owner]' : '[member]';
+                process.stdout.write(`  ${member.clerk_user_id} ${roleLabel}\n`);
+            }
+            if (invites.length > 0) {
+                process.stdout.write('\nPending invites:\n');
+                for (const invite of invites) {
+                    const expires = new Date(invite.expires_at).toLocaleDateString();
+                    process.stdout.write(`  ${invite.email} (${invite.role}) - expires ${expires}\n`);
+                }
+            }
+        }
+        catch (err) {
+            process.stderr.write(`Failed to list members: ${err instanceof Error ? err.message : 'Unknown error'}\n`);
+            process.exit(1);
+        }
+    });
+}

package/dist/lib/api.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiError = void 0;
+exports.safeFetch = safeFetch;
 exports.request = request;
 exports.publicRequest = publicRequest;
 exports.getOrg = getOrg;
@@ -54,6 +55,24 @@ exports.getAgentWithFallback = getAgentWithFallback;
 exports.downloadCodeBundleAuthenticated = downloadCodeBundleAuthenticated;
 exports.checkAgentDelete = checkAgentDelete;
 exports.deleteAgent = deleteAgent;
+exports.previewAgentVersion = previewAgentVersion;
+const errors_1 = require("./errors");
+const DEFAULT_TIMEOUT_MS = 15000;
+async function safeFetch(url, options) {
+    try {
+        return await fetch(url, {
+            ...options,
+            signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+        });
+    }
+    catch (err) {
+        if (err instanceof Error && (err.name === 'AbortError' || err.name === 'TimeoutError')) {
+            throw new errors_1.NetworkError(url, err);
+        }
+        // Network errors (ECONNREFUSED, DNS failure, etc.)
+        throw new errors_1.NetworkError(url, err instanceof Error ? err : undefined);
+    }
+}
 class ApiError extends Error {
     status;
     payload;
@@ -88,7 +107,7 @@ async function request(config, method, path, options = {}) {
     if (!config.apiKey) {
         throw new ApiError('Missing API key. Run `orchagent login` first.', 401);
     }
-    const response = await fetch(buildUrl(config.apiUrl, path), {
+    const response = await safeFetch(buildUrl(config.apiUrl, path), {
         method,
         headers: {
             Authorization: `Bearer ${config.apiKey}`,
@@ -102,7 +121,7 @@ async function request(config, method, path, options = {}) {
     return (await response.json());
 }
 async function publicRequest(config, path) {
-    const response = await fetch(buildUrl(config.apiUrl, path));
+    const response = await safeFetch(buildUrl(config.apiUrl, path));
     if (!response.ok) {
         throw await parseError(response);
     }
@@ -161,7 +180,7 @@ async function fetchLlmKeys(config) {
  * Download a code bundle for local execution.
  */
 async function downloadCodeBundle(config, org, agent, version) {
-    const response = await fetch(`${config.apiUrl.replace(/\/$/, '')}/public/agents/${org}/${agent}/${version}/bundle`);
+    const response = await safeFetch(`${config.apiUrl.replace(/\/$/, '')}/public/agents/${org}/${agent}/${version}/bundle`);
     if (!response.ok) {
         throw await parseError(response);
     }
@@ -189,7 +208,7 @@ async function uploadCodeBundle(config, agentId, bundlePath, entrypoint) {
     if (entrypoint) {
         headers['x-entrypoint'] = entrypoint;
     }
-    const response = await fetch(`${config.apiUrl.replace(/\/$/, '')}/agents/${agentId}/upload`, {
+    const response = await safeFetch(`${config.apiUrl.replace(/\/$/, '')}/agents/${agentId}/upload`, {
         method: 'POST',
         headers,
         body: formData,
@@ -243,7 +262,7 @@ 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`, {
+    const response = await safeFetch(`${config.apiUrl.replace(/\/$/, '')}/agents/${agentId}/bundle`, {
         headers: {
             Authorization: `Bearer ${config.apiKey}`,
         },
@@ -276,3 +295,9 @@ async function deleteAgent(config, agentId, confirmationName) {
     const params = confirmationName ? `?confirmation_name=${encodeURIComponent(confirmationName)}` : '';
     return request(config, 'DELETE', `/agents/${agentId}${params}`);
 }
+/**
+ * Preview the next version number for an agent.
+ */
+async function previewAgentVersion(config, agentName) {
+    return request(config, 'GET', `/agents/preview?name=${encodeURIComponent(agentName)}`);
+}

package/dist/lib/auth-errors.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAuthError = parseAuthError;
+const errors_1 = require("./errors");
+const AUTH_MESSAGES = {
+    400: 'Invalid authentication request. Please try again.',
+    401: 'Authentication failed. Run `orchagent login` again.',
+    403: 'Access denied. You may not have permission for this organization.',
+    429: 'Too many attempts. Wait a moment and try again.',
+    500: 'Server error. Please try again later.',
+    502: 'Server temporarily unavailable. Try again later.',
+};
+async function parseAuthError(response, context) {
+    try {
+        const json = await response.json();
+        const msg = json?.error?.message || json?.message;
+        if (msg && typeof msg === 'string' && msg.length < 200) {
+            return new errors_1.CliError(msg);
+        }
+    }
+    catch { }
+    const ctx = context === 'init'
+        ? 'Failed to start authentication'
+        : 'Failed to complete authentication';
+    const action = AUTH_MESSAGES[response.status] || 'Please try again.';
+    return new errors_1.CliError(`${ctx}: ${action}`);
+}

package/dist/lib/browser-auth.js

@@ -8,6 +8,7 @@ exports.startBrowserAuth = startBrowserAuth;
 const http_1 = __importDefault(require("http"));
 const open_1 = __importDefault(require("open"));
 const errors_1 = require("./errors");
+const auth_errors_1 = require("./auth-errors");
 const DEFAULT_PORT = 8374;
 const AUTH_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 /**
@@ -26,8 +27,7 @@ async function browserAuthFlow(apiUrl, port = DEFAULT_PORT) {
         body: JSON.stringify({ redirect_port: port }),
     });
     if (!initResponse.ok) {
-        const error = await initResponse.json().catch(() => ({}));
-        throw new errors_1.CliError(error?.error?.message || `Failed to initialize auth: ${initResponse.statusText}`);
+        throw await (0, auth_errors_1.parseAuthError)(initResponse, 'init');
     }
     const { auth_url } = await initResponse.json();
     // Step 2: Start local server and wait for callback
@@ -39,8 +39,7 @@ async function browserAuthFlow(apiUrl, port = DEFAULT_PORT) {
         body: JSON.stringify({ token }),
     });
     if (!exchangeResponse.ok) {
-        const error = await exchangeResponse.json().catch(() => ({}));
-        throw new errors_1.CliError(error?.error?.message || `Failed to exchange token: ${exchangeResponse.statusText}`);
+        throw await (0, auth_errors_1.parseAuthError)(exchangeResponse, 'exchange');
     }
     const result = await exchangeResponse.json();
     // Step 4: Open browser (do this after server is ready but before waiting)
@@ -125,8 +124,7 @@ async function startBrowserAuth(apiUrl, port = DEFAULT_PORT) {
         body: JSON.stringify({ redirect_port: port }),
     });
     if (!initResponse.ok) {
-        const error = await initResponse.json().catch(() => ({}));
-        throw new errors_1.CliError(error?.error?.message || `Failed to initialize auth: ${initResponse.statusText}`);
+        throw await (0, auth_errors_1.parseAuthError)(initResponse, 'init');
     }
     const { auth_url } = await initResponse.json();
     // Step 2: Start local server to receive callback
@@ -148,8 +146,7 @@ async function startBrowserAuth(apiUrl, port = DEFAULT_PORT) {
         body: JSON.stringify({ token }),
     });
     if (!exchangeResponse.ok) {
-        const error = await exchangeResponse.json().catch(() => ({}));
-        throw new errors_1.CliError(error?.error?.message || `Failed to complete authentication: ${exchangeResponse.statusText}`);
+        throw await (0, auth_errors_1.parseAuthError)(exchangeResponse, 'exchange');
     }
     const result = await exchangeResponse.json();
     return {

package/dist/lib/bundle.js

@@ -10,11 +10,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCodeBundle = createCodeBundle;
 exports.detectEntrypoint = detectEntrypoint;
+exports.previewBundle = previewBundle;
 exports.validateBundle = validateBundle;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const archiver_1 = __importDefault(require("archiver"));
 const fs_1 = require("fs");
+const glob_1 = require("glob");
 /** Default patterns to exclude from bundles */
 const DEFAULT_EXCLUDES = [
     // Python
@@ -184,6 +186,52 @@ async function detectEntrypoint(projectDir) {
     }
     return null;
 }
+/**
+ * Preview what would be bundled without creating the actual bundle.
+ *
+ * @param sourceDir - The directory to analyze
+ * @param options - Bundle options
+ * @returns Preview information about the bundle
+ */
+async function previewBundle(sourceDir, options = {}) {
+    const excludePatterns = [...DEFAULT_EXCLUDES, ...(options.exclude || [])];
+    // Verify source directory exists
+    const stat = await promises_1.default.stat(sourceDir);
+    if (!stat.isDirectory()) {
+        throw new Error(`Source path is not a directory: ${sourceDir}`);
+    }
+    // Detect or use provided entrypoint
+    let entrypoint = options.entrypoint;
+    if (!entrypoint) {
+        const detected = await detectEntrypoint(sourceDir);
+        entrypoint = detected || 'main.py';
+    }
+    // Find all files that would be included (matching createCodeBundle's glob pattern)
+    const files = await (0, glob_1.glob)('**/*', {
+        cwd: sourceDir,
+        ignore: excludePatterns,
+        dot: false,
+        nodir: true,
+    });
+    // Calculate total size by reading file stats
+    let totalSizeBytes = 0;
+    for (const file of files) {
+        const filePath = path_1.default.join(sourceDir, file);
+        try {
+            const fileStat = await promises_1.default.stat(filePath);
+            totalSizeBytes += fileStat.size;
+        }
+        catch {
+            // Skip files that can't be stat'd (e.g., broken symlinks)
+        }
+    }
+    return {
+        fileCount: files.length,
+        totalSizeBytes,
+        entrypoint,
+        excludePatterns,
+    };
+}
 /**
  * Validate a bundle before upload.
  *