@pitcher/cli-scripts 2.1.1 → 2.2.0

package/dist/index.js

@@ -1,19 +1,20 @@
 #!/usr/bin/env node
-import { Command } from "commander";
-import { createPublishAppCommand } from "./src/publishApp.js";
-import { createDevSyncCommand } from "./src/devSync.js";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { createPublishAppCommand } from './src/commands/publishApp.js';
+import { createDevSyncCommand } from './src/commands/devSync.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf8"));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
 const program = new Command();
 program
-    .name("p")
-    .description("The Pitcher CLI for various tasks in its ecosystem.")
-    .version(pkg.version);
-// Add subcommands
+    .name('p')
+    .description('The Pitcher CLI for various tasks in its ecosystem.')
+    .version(pkg.version)
+    .option('--output <format>', 'Output format: "text" or "json" (auto-json when stdout is not a TTY)')
+    .option('--quiet', 'Suppress non-essential (progress) output');
 program.addCommand(createPublishAppCommand());
 program.addCommand(createDevSyncCommand());
-program.parse(process.argv);
+program.parseAsync(process.argv);

package/dist/src/commands/devSync.d.ts

@@ -0,0 +1,35 @@
+import { Command } from 'commander';
+import type { AxiosInstance } from 'axios';
+import { type Envelope } from '../core/envelope.js';
+interface AppJson {
+    name: string;
+    version: string;
+    [key: string]: unknown;
+}
+interface SyncResponse {
+    success: boolean;
+    message: string;
+    dev_version: string;
+    original_version: string;
+    files_uploaded: number;
+    s3_prefix: string;
+}
+interface DevSyncOptions {
+    fileId: string;
+    apiKey?: string;
+    org?: string;
+    quiet?: boolean;
+    output?: string;
+}
+interface DevSyncDeps {
+    client?: AxiosInstance;
+    cwd?: string;
+}
+export declare function findDistPath(cwd?: string): string;
+export declare function readAppJson(distPath: string): AppJson;
+export declare function runDevSync(opts: DevSyncOptions, deps?: DevSyncDeps): Promise<Envelope<SyncResponse>>;
+export declare function runRevert(opts: DevSyncOptions, deps?: DevSyncDeps): Promise<Envelope<{
+    restored_version?: string;
+}>>;
+export declare function createDevSyncCommand(): Command;
+export {};

package/dist/src/commands/devSync.js

@@ -0,0 +1,191 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import FormData from 'form-data';
+import chokidar from 'chokidar';
+import { resolveApiKey } from '../core/auth.js';
+import { resolveBaseUrl } from '../core/baseUrl.js';
+import { makeClient, toCliError } from '../core/http.js';
+import { zipDirectoryToBuffer } from '../core/archive.js';
+import { ok, fail } from '../core/envelope.js';
+import { createCliError } from '../core/errors.js';
+import { emitEnvelope, log } from '../core/output.js';
+const SYNC_ENDPOINT = '/core/api/protected/development/s3-app-sync';
+export function findDistPath(cwd = process.cwd()) {
+    if (fs.existsSync(path.join(cwd, 'app.json')))
+        return cwd;
+    const distPath = path.join(cwd, 'dist');
+    if (fs.existsSync(path.join(distPath, 'app.json')))
+        return distPath;
+    throw createCliError('VALIDATION', 'Could not find app.json in the current directory or ./dist. Run from the app folder or its project root.');
+}
+export function readAppJson(distPath) {
+    const appJsonPath = path.join(distPath, 'app.json');
+    if (!fs.existsSync(appJsonPath)) {
+        throw createCliError('VALIDATION', `app.json not found in ${distPath}`);
+    }
+    const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'));
+    if (!appJson.name) {
+        throw createCliError('VALIDATION', 'app.json must contain a "name" field');
+    }
+    return appJson;
+}
+export async function runDevSync(opts, deps = {}) {
+    try {
+        const apiKey = resolveApiKey(opts);
+        const baseUrl = resolveBaseUrl(opts);
+        const distPath = findDistPath(deps.cwd);
+        const appJson = readAppJson(distPath);
+        const client = deps.client ?? makeClient(baseUrl, apiKey);
+        log(`Syncing ${appJson.name} from ${distPath}...`, { quiet: opts.quiet });
+        const zip = await zipDirectoryToBuffer(distPath);
+        log(`Zip created: ${(zip.length / 1024).toFixed(2)} KB`, { quiet: opts.quiet });
+        const form = new FormData();
+        form.append('app_name', appJson.name);
+        form.append('file_id', opts.fileId);
+        form.append('zip', zip, { filename: 'app.zip', contentType: 'application/zip' });
+        const res = await client.post(SYNC_ENDPOINT, form, {
+            headers: form.getHeaders(),
+            maxBodyLength: Infinity,
+            maxContentLength: Infinity,
+        });
+        return ok(res.data);
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export async function runRevert(opts, deps = {}) {
+    try {
+        const apiKey = resolveApiKey(opts);
+        const baseUrl = resolveBaseUrl(opts);
+        const client = deps.client ?? makeClient(baseUrl, apiKey);
+        const res = await client.delete(SYNC_ENDPOINT, {
+            headers: { 'Content-Type': 'application/json' },
+            data: { file_id: opts.fileId },
+        });
+        return ok({ restored_version: res.data?.restored_version });
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+async function watchDevSync(opts, debounceMs) {
+    const quiet = opts.quiet;
+    let distPath;
+    let appJson;
+    try {
+        distPath = findDistPath();
+        appJson = readAppJson(distPath);
+    }
+    catch (e) {
+        emitEnvelope(fail(toCliError(e)), opts);
+        return;
+    }
+    log(`Watching ${distPath} for changes (app: ${appJson.name}, debounce ${debounceMs}ms)...`, { quiet });
+    let syncTimeout = null;
+    let isSyncing = false;
+    let isShuttingDown = false;
+    const doSync = async () => {
+        if (isShuttingDown)
+            return;
+        if (isSyncing) {
+            syncTimeout = setTimeout(doSync, debounceMs);
+            return;
+        }
+        isSyncing = true;
+        const env = await runDevSync(opts);
+        if (env.ok) {
+            log(`Synced — ${env.data?.files_uploaded} files`, { quiet });
+        }
+        else {
+            log(`Sync failed [${env.error?.code}]: ${env.error?.message}`, { quiet });
+        }
+        isSyncing = false;
+    };
+    const watcher = chokidar.watch(distPath, {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 },
+    });
+    watcher.on('all', (_event, filePath) => {
+        if (syncTimeout)
+            clearTimeout(syncTimeout);
+        log(`Change detected: ${path.relative(distPath, filePath)}`, { quiet });
+        syncTimeout = setTimeout(doSync, debounceMs);
+    });
+    const shutdown = async (signal) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        log(`${signal} received — reverting dev override...`, { quiet });
+        await watcher.close();
+        if (syncTimeout)
+            clearTimeout(syncTimeout);
+        while (isSyncing)
+            await new Promise((r) => setTimeout(r, 100));
+        const env = await runRevert(opts);
+        if (!env.ok)
+            log(`Failed to revert [${env.error?.code}]: ${env.error?.message}`, { quiet });
+        else
+            log('Dev override reverted', { quiet });
+        process.exit(env.error?.exitCode ?? 0);
+    };
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    log('Initial sync...', { quiet });
+    await doSync();
+}
+export function createDevSyncCommand() {
+    const program = new Command('dev-sync').description('Sync a marketplace app to S3 for live development testing');
+    program
+        .command('sync')
+        .description('One-time sync of the app to S3')
+        .requiredOption('--file-id <id>', 'File ID of the installed app (pitcher_file.id)')
+        .option('--api-key <apiKey>', 'API Key for authentication')
+        .option('--org <organization>', 'Organization subdomain', 'dev')
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        const env = await runDevSync({
+            fileId: options.fileId,
+            apiKey: options.apiKey,
+            org: options.org,
+            quiet: globals.quiet,
+        });
+        emitEnvelope(env, globals);
+    });
+    program
+        .command('watch')
+        .description('Watch the dist folder and sync on changes')
+        .requiredOption('--file-id <id>', 'File ID of the installed app (pitcher_file.id)')
+        .option('--api-key <apiKey>', 'API Key for authentication')
+        .option('--org <organization>', 'Organization subdomain', 'dev')
+        .option('--debounce <ms>', 'Debounce time in milliseconds', '2500')
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        await watchDevSync({
+            fileId: options.fileId,
+            apiKey: options.apiKey,
+            org: options.org,
+            quiet: globals.quiet,
+            output: globals.output,
+        }, parseInt(options.debounce, 10));
+    });
+    program
+        .command('revert')
+        .description('Revert the dev override and restore the original version')
+        .requiredOption('--file-id <id>', 'File ID of the installed app (pitcher_file.id)')
+        .option('--api-key <apiKey>', 'API Key for authentication')
+        .option('--org <organization>', 'Organization subdomain', 'dev')
+        .action(async (options, command) => {
+        const globals = command.optsWithGlobals();
+        const env = await runRevert({
+            fileId: options.fileId,
+            apiKey: options.apiKey,
+            org: options.org,
+            quiet: globals.quiet,
+        });
+        emitEnvelope(env, globals);
+    });
+    return program;
+}

package/dist/src/commands/publishApp.d.ts

@@ -0,0 +1,30 @@
+import { Command } from 'commander';
+import type { AxiosInstance } from 'axios';
+import { type Envelope } from '../core/envelope.js';
+interface PublishResult {
+    app?: {
+        name?: string;
+        version?: string;
+    };
+    installed?: string[];
+    dryRun?: boolean;
+    publishUrl?: string;
+}
+interface PublishOptions {
+    folder?: string;
+    apiKey?: string;
+    org?: string;
+    url?: string;
+    incrementVersion?: boolean;
+    dryRun?: boolean;
+    installTo?: string;
+    installToEnvName?: string;
+    quiet?: boolean;
+}
+interface PublishDeps {
+    client?: AxiosInstance;
+    tmpDir?: string;
+}
+export declare function runPublishApp(opts: PublishOptions, deps?: PublishDeps): Promise<Envelope<PublishResult>>;
+export declare function createPublishAppCommand(): Command;
+export {};

package/dist/src/commands/publishApp.js

@@ -0,0 +1,181 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { randomUUID } from 'crypto';
+import FormData from 'form-data';
+import { resolveApiKey } from '../core/auth.js';
+import { resolveBaseUrl } from '../core/baseUrl.js';
+import { makeClient, toCliError } from '../core/http.js';
+import { zipDirectoryToFile } from '../core/archive.js';
+import { ok, fail } from '../core/envelope.js';
+import { createCliError } from '../core/errors.js';
+import { emitEnvelope, log } from '../core/output.js';
+const PUBLISH_PATH = '/api/v1/apps/publish/';
+const INSTANCES_PATH = '/api/v1/instances';
+function buildVersion(now) {
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    return `${year}.${month}.${day}.${now.getTime()}`;
+}
+async function fetchAllInstances(client, warnings, quiet) {
+    const pageSize = 100;
+    const maxPages = 50;
+    const first = await client.get(INSTANCES_PATH, { params: { page_size: pageSize, page: 1 } });
+    const firstInstances = first.data.results || [];
+    if (firstInstances.length === 0)
+        return [];
+    const totalCount = first.data.count || firstInstances.length;
+    const totalPagesRaw = Math.ceil(totalCount / pageSize);
+    const totalPages = Math.min(totalPagesRaw, maxPages);
+    if (totalPagesRaw > maxPages) {
+        warnings.push(`Reached the ${maxPages}-page instance limit (${maxPages * pageSize}); there may be more instances not considered for installation.`);
+    }
+    if (totalPages === 1)
+        return firstInstances;
+    const pages = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
+    log(`Fetching ${totalPages - 1} more instance page(s)...`, { quiet });
+    const responses = await Promise.all(pages.map((page) => client.get(INSTANCES_PATH, { params: { page_size: pageSize, page } })));
+    return [...firstInstances, ...responses.flatMap((r) => r.data.results || [])];
+}
+function selectTargetInstances(all, opts) {
+    const byId = new Map(all.map((i) => [i.id, i]));
+    const targets = [];
+    const warnings = [];
+    if (opts.installTo) {
+        const requested = opts.installTo.split(',').map((s) => s.trim()).filter(Boolean);
+        for (const id of requested) {
+            const inst = byId.get(id);
+            if (inst)
+                targets.push(inst);
+            else
+                warnings.push(`Unknown instance id skipped: ${id}`);
+        }
+    }
+    if (opts.installToEnvName) {
+        const env = opts.installToEnvName.toLowerCase();
+        const matched = all.filter((i) => i.environment?.name?.toLowerCase() === env);
+        if (matched.length === 0)
+            warnings.push(`No instances found for environment "${opts.installToEnvName}"`);
+        targets.push(...matched);
+    }
+    const unique = Array.from(new Map(targets.map((i) => [i.id, i])).values());
+    return { targets: unique, warnings };
+}
+async function installToInstances(client, appName, instances, quiet) {
+    if (instances.length === 0)
+        return [];
+    const instanceIds = instances.map((i) => i.id);
+    log(`Installing "${appName}" to ${instances.length} instance(s)...`, { quiet });
+    await client.post(`/api/v1/apps/${appName}/install/`, { instance_ids: instanceIds });
+    return instanceIds;
+}
+export async function runPublishApp(opts, deps = {}) {
+    try {
+        const apiKey = resolveApiKey(opts);
+        const baseUrl = resolveBaseUrl({ org: opts.org, url: opts.url });
+        const folderPath = path.resolve(opts.folder ?? '.');
+        const appJsonPath = path.join(folderPath, 'app.json');
+        const warnings = [];
+        const existingAppJson = fs.existsSync(appJsonPath)
+            ? JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'))
+            : undefined;
+        // --increment-version requires app.json — validate on BOTH dry-run and real
+        // paths so dry-run can't report a false success when the file is missing.
+        if (opts.incrementVersion && !existingAppJson) {
+            return fail(createCliError('VALIDATION', `app.json not found in ${folderPath}`));
+        }
+        const nextVersion = opts.incrementVersion ? buildVersion(new Date()) : existingAppJson?.version;
+        // Preserve original --publish-url semantics: POST to the exact URL given
+        // (full path included). Otherwise POST to the canonical publish path
+        // relative to the client baseURL (the resolved org origin).
+        const publishTarget = opts.url ?? PUBLISH_PATH;
+        const displayPublishUrl = opts.url ?? `${baseUrl}${PUBLISH_PATH}`;
+        if (opts.dryRun) {
+            // Dry run is read-only: report the version that WOULD be written, don't touch disk.
+            return ok({
+                dryRun: true,
+                publishUrl: displayPublishUrl,
+                app: existingAppJson ? { name: existingAppJson.name, version: nextVersion } : undefined,
+            });
+        }
+        if (opts.incrementVersion && existingAppJson) {
+            existingAppJson.version = nextVersion;
+            fs.writeFileSync(appJsonPath, JSON.stringify(existingAppJson, null, 2));
+            log(`Updated app.json version to ${nextVersion}`, { quiet: opts.quiet });
+        }
+        const client = deps.client ?? makeClient(baseUrl, apiKey);
+        const zipPath = path.join(deps.tmpDir ?? os.tmpdir(), `cli-publish-${process.pid}-${randomUUID()}.zip`);
+        try {
+            log(`Zipping ${folderPath}...`, { quiet: opts.quiet });
+            await zipDirectoryToFile(folderPath, zipPath);
+            const form = new FormData();
+            form.append('file', fs.createReadStream(zipPath));
+            const res = await client.post(publishTarget, form, {
+                headers: form.getHeaders(),
+                maxBodyLength: Infinity,
+                maxContentLength: Infinity,
+            });
+            const app = res.data?.app;
+            const result = { app };
+            if (!app?.name) {
+                warnings.push('Could not determine app name from publish response');
+            }
+            else if (opts.installTo || opts.installToEnvName) {
+                // Best-effort install: the app is already published (non-idempotent),
+                // so a post-publish install error must NOT fail the command and lose
+                // the publish result — it would invite a double-publish on retry.
+                try {
+                    const all = await fetchAllInstances(client, warnings, opts.quiet);
+                    if (all.length === 0) {
+                        warnings.push('No instances available; skipped installation');
+                    }
+                    else {
+                        const { targets, warnings: selWarnings } = selectTargetInstances(all, opts);
+                        warnings.push(...selWarnings);
+                        result.installed = await installToInstances(client, app.name, targets, opts.quiet);
+                    }
+                }
+                catch (installError) {
+                    warnings.push(`Install failed after successful publish: ${toCliError(installError).message}`);
+                }
+            }
+            return ok(result, warnings);
+        }
+        finally {
+            if (fs.existsSync(zipPath))
+                fs.unlinkSync(zipPath);
+        }
+    }
+    catch (e) {
+        return fail(toCliError(e));
+    }
+}
+export function createPublishAppCommand() {
+    return new Command('publish-app')
+        .arguments('[folder]')
+        .option('--api-key <apiKey>', 'API Key for authentication')
+        .option('--org <organization>', 'Organization subdomain', 'dev')
+        .option('--increment-version', 'Increment version in app.json')
+        .option('--dry-run', 'Perform a dry run without publishing')
+        .option('--publish-url <url>', 'Explicit publish URL')
+        .option('--install-to <instanceIds>', 'Comma-separated instance IDs to install to after publishing')
+        .option('--install-to-env-name <envName>', 'Environment name to install to after publishing')
+        .description('zip a folder and publish it as an app to a Pitcher org')
+        .action(async (folder, options, command) => {
+        const globals = command.optsWithGlobals();
+        const env = await runPublishApp({
+            folder,
+            apiKey: options.apiKey,
+            org: options.org,
+            url: options.publishUrl,
+            incrementVersion: options.incrementVersion,
+            dryRun: options.dryRun,
+            installTo: options.installTo,
+            installToEnvName: options.installToEnvName,
+            quiet: globals.quiet,
+        });
+        emitEnvelope(env, globals);
+    });
+}

package/dist/src/core/archive.d.ts

@@ -0,0 +1,2 @@
+export declare function zipDirectoryToBuffer(dir: string): Promise<Buffer>;
+export declare function zipDirectoryToFile(dir: string, outPath: string): Promise<number>;

package/dist/src/core/archive.js

@@ -0,0 +1,25 @@
+import archiver from 'archiver';
+import fs from 'fs';
+export async function zipDirectoryToBuffer(dir) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        archive.on('data', (chunk) => chunks.push(chunk));
+        archive.on('end', () => resolve(Buffer.concat(chunks)));
+        archive.on('error', reject);
+        archive.directory(dir, false);
+        archive.finalize();
+    });
+}
+export async function zipDirectoryToFile(dir, outPath) {
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(outPath);
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        output.on('close', () => resolve(archive.pointer()));
+        output.on('error', reject);
+        archive.on('error', reject);
+        archive.pipe(output);
+        archive.directory(dir, false);
+        archive.finalize();
+    });
+}

package/dist/src/core/auth.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveApiKey(opts: {
+    apiKey?: string;
+}, env?: NodeJS.ProcessEnv): string;

package/dist/src/core/auth.js

@@ -0,0 +1,10 @@
+import { createCliError } from './errors.js';
+export function resolveApiKey(opts, env = process.env) {
+    const flagKey = opts.apiKey?.trim();
+    if (flagKey)
+        return flagKey;
+    const envKey = env.NG_API_KEY?.trim();
+    if (envKey)
+        return envKey;
+    throw createCliError('AUTH', 'API key is required. Provide --api-key or set the NG_API_KEY environment variable.');
+}

package/dist/src/core/baseUrl.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveBaseUrl(opts: {
+    org?: string;
+    url?: string;
+}): string;

package/dist/src/core/baseUrl.js

@@ -0,0 +1,18 @@
+import { createCliError } from './errors.js';
+export function resolveBaseUrl(opts) {
+    if (opts.url) {
+        let parsed;
+        try {
+            parsed = new URL(opts.url);
+        }
+        catch {
+            throw createCliError('VALIDATION', `Invalid --publish-url: ${opts.url}`);
+        }
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            throw createCliError('VALIDATION', `--publish-url must be an http(s) URL: ${opts.url}`);
+        }
+        return parsed.origin;
+    }
+    const org = opts.org || 'dev';
+    return `https://${org}.my.pitcher.com`;
+}

package/dist/src/core/envelope.d.ts

@@ -0,0 +1,13 @@
+import type { CliError, ErrorCodeName } from './errors.js';
+export interface Envelope<T> {
+    ok: boolean;
+    data?: T;
+    error?: {
+        code: ErrorCodeName;
+        exitCode: number;
+        message: string;
+    };
+    warnings?: string[];
+}
+export declare function ok<T>(data: T, warnings?: string[]): Envelope<T>;
+export declare function fail(error: CliError, warnings?: string[]): Envelope<never>;

package/dist/src/core/envelope.js

@@ -0,0 +1,10 @@
+export function ok(data, warnings) {
+    return { ok: true, data, ...(warnings?.length ? { warnings } : {}) };
+}
+export function fail(error, warnings) {
+    return {
+        ok: false,
+        error: { code: error.code, exitCode: error.exitCode, message: error.message },
+        ...(warnings?.length ? { warnings } : {}),
+    };
+}

package/dist/src/core/errors.d.ts

@@ -0,0 +1,18 @@
+export declare const ERROR_CODES: {
+    readonly OK: 0;
+    readonly UNKNOWN: 1;
+    readonly AUTH: 2;
+    readonly VALIDATION: 3;
+    readonly NETWORK: 4;
+    readonly NOT_FOUND: 5;
+    readonly CONFLICT: 6;
+};
+export type ErrorCodeName = keyof typeof ERROR_CODES;
+export interface CliError {
+    __cliError: true;
+    code: ErrorCodeName;
+    exitCode: number;
+    message: string;
+}
+export declare function createCliError(code: ErrorCodeName, message: string): CliError;
+export declare function isCliError(e: unknown): e is CliError;

package/dist/src/core/errors.js

@@ -0,0 +1,25 @@
+export const ERROR_CODES = {
+    OK: 0,
+    UNKNOWN: 1,
+    AUTH: 2,
+    VALIDATION: 3,
+    NETWORK: 4,
+    NOT_FOUND: 5,
+    CONFLICT: 6,
+};
+export function createCliError(code, message) {
+    return { __cliError: true, code, exitCode: ERROR_CODES[code], message };
+}
+export function isCliError(e) {
+    if (typeof e !== 'object' || e === null)
+        return false;
+    const c = e;
+    if (c.__cliError !== true || typeof c.code !== 'string' || typeof c.message !== 'string') {
+        return false;
+    }
+    // Own key only (reject inherited names like 'toString') and the exit code
+    // must match the canonical value for that code.
+    if (!Object.prototype.hasOwnProperty.call(ERROR_CODES, c.code))
+        return false;
+    return c.exitCode === ERROR_CODES[c.code];
+}

package/dist/src/core/http.d.ts

@@ -0,0 +1,4 @@
+import { type AxiosInstance } from 'axios';
+import { type CliError } from './errors.js';
+export declare function makeClient(baseUrl: string, apiKey: string): AxiosInstance;
+export declare function toCliError(e: unknown): CliError;

package/dist/src/core/http.js

@@ -0,0 +1,33 @@
+import axios from 'axios';
+import { createCliError, isCliError } from './errors.js';
+export function makeClient(baseUrl, apiKey) {
+    return axios.create({
+        baseURL: baseUrl,
+        headers: {
+            accept: 'application/json',
+            'x-api-key': apiKey,
+        },
+    });
+}
+export function toCliError(e) {
+    if (isCliError(e))
+        return e;
+    const err = (e ?? {});
+    const data = err.response?.data;
+    const apiMessage = data?.detail || data?.error || err.message || 'Request failed';
+    const status = err.response?.status;
+    if (typeof status === 'number') {
+        if (status === 401 || status === 403)
+            return createCliError('AUTH', apiMessage);
+        if (status === 404)
+            return createCliError('NOT_FOUND', apiMessage);
+        if (status === 409)
+            return createCliError('CONFLICT', apiMessage);
+        if (status >= 400 && status < 500)
+            return createCliError('VALIDATION', apiMessage);
+        return createCliError('NETWORK', apiMessage);
+    }
+    if (err.isAxiosError)
+        return createCliError('NETWORK', apiMessage);
+    return createCliError('UNKNOWN', apiMessage);
+}