@respan/cli 0.2.0

package/dist/commands/whoami.js

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../lib/base-command.js';
+import { getActiveProfile, getCredential } from '../lib/config.js';
+class Whoami extends BaseCommand {
+    async run() {
+        const { flags } = await this.parse(Whoami);
+        this.globalFlags = flags;
+        const profile = getActiveProfile();
+        const cred = getCredential(profile);
+        if (!cred) {
+            this.log('Not authenticated.');
+            return;
+        }
+        this.log(`Profile: ${profile}`);
+        if (cred.type === 'jwt')
+            this.log(`Email: ${cred.email}`);
+        this.log(`Base URL: ${cred.baseUrl}`);
+    }
+}
+Whoami.description = 'Show current user information';
+Whoami.flags = { ...BaseCommand.baseFlags };
+export default Whoami;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/auth.d.ts

@@ -0,0 +1,16 @@
+import { Credential } from './config.js';
+export interface AuthConfig {
+    apiKey?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    baseUrl: string;
+}
+export declare function resolveAuth(flags: {
+    'api-key'?: string;
+    profile?: string;
+}): AuthConfig;
+export declare function refreshJwtToken(credential: Credential & {
+    type: 'jwt';
+}): Promise<{
+    access: string;
+}>;

package/dist/lib/auth.js

@@ -0,0 +1,40 @@
+import { getCredential } from './config.js';
+const DEFAULT_BASE_URL = 'https://api.respan.ai/api';
+export function resolveAuth(flags) {
+    if (flags['api-key']) {
+        return { apiKey: flags['api-key'], baseUrl: DEFAULT_BASE_URL };
+    }
+    if (process.env.RESPAN_API_KEY) {
+        return {
+            apiKey: process.env.RESPAN_API_KEY,
+            baseUrl: process.env.RESPAN_API_BASE_URL || DEFAULT_BASE_URL,
+        };
+    }
+    const credential = getCredential(flags.profile);
+    if (credential) {
+        return credentialToAuth(credential);
+    }
+    throw new Error('Not authenticated. Run `respan auth login` or set RESPAN_API_KEY.');
+}
+function credentialToAuth(cred) {
+    if (cred.type === 'api_key') {
+        return { apiKey: cred.apiKey, baseUrl: cred.baseUrl };
+    }
+    return {
+        accessToken: cred.accessToken,
+        refreshToken: cred.refreshToken,
+        baseUrl: cred.baseUrl,
+    };
+}
+export async function refreshJwtToken(credential) {
+    const origin = credential.baseUrl.replace(/\/api\/?$/, '');
+    const response = await fetch(`${origin}/auth/jwt/refresh/`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ refresh: credential.refreshToken }),
+    });
+    if (!response.ok) {
+        throw new Error('Token refresh failed. Please login again with `respan auth login`.');
+    }
+    return response.json();
+}

package/dist/lib/banner.d.ts

@@ -0,0 +1,2 @@
+export declare function printBanner(): void;
+export declare function printLoginSuccess(email?: string, profile?: string): Promise<void>;

package/dist/lib/banner.js

@@ -0,0 +1,117 @@
+const RESET = '\x1b[0m';
+const GRADIENT_STOPS = [
+    [170, 190, 255], // #AABEFF bright
+    [100, 131, 240], // #6483F0 primary
+    [40, 65, 180], // #2841B4 deep
+];
+function lerp(a, b, t) {
+    return Math.round(a + (b - a) * t);
+}
+function gradientColor(x, maxLen) {
+    const t = Math.min(x / Math.max(maxLen - 1, 1), 1);
+    const seg = t * (GRADIENT_STOPS.length - 1);
+    const idx = Math.min(Math.floor(seg), GRADIENT_STOPS.length - 2);
+    const lt = seg - idx;
+    const r = lerp(GRADIENT_STOPS[idx][0], GRADIENT_STOPS[idx + 1][0], lt);
+    const g = lerp(GRADIENT_STOPS[idx][1], GRADIENT_STOPS[idx + 1][1], lt);
+    const b = lerp(GRADIENT_STOPS[idx][2], GRADIENT_STOPS[idx + 1][2], lt);
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+// Layer 2: near black shadow
+const SHADOW_COLOR = '\x1b[38;2;5;5;10m';
+// Layer 3: gray shadow
+const SHADOW_BG = '\x1b[38;2;177;179;188m';
+// ASCII art from official Respan SVG logo: [.] Respan
+// Half-blocks for correct aspect ratio, fits 80-col Apple Terminal
+const BANNER_LINES = [
+    '▄████       █████     ▄▄▄▄▄▄',
+    '███           ███     ███▀████▄',
+    '███           ███     ███   ███  ▄███▄▄  ▄▄███▄  ██▄▄██▄▄  ▄▄███▄  ██▄▄███▄',
+    '███           ███     ███▄▄▄██▀ ██▀  ███ ██  ▀▀▀ ███  ▀██▄ ▀▀  ▀██ ███▀ ▀██',
+    '███           ███     ███▀▀██  █████████ ▀▀████▄ ██▄   ███ ▄██████ ███   ██',
+    '███      ██▄  ███     ███  ▀██  ██▄  ▄▄▄ ▄▄  ▄██ ███▄ ▄██▀███  ▄██ ███   ██',
+    '███▄▄     ▀ ▄▄███     ▀█▀   ▀██  ▀▀██▀▀  ▀▀███▀▀ ██▀▀██▀▀  ▀██▀▀██ ▀█▀   ▀█',
+    ' ▀▀▀▀       ▀▀▀▀▀                                ██',
+    '                                                 ▀▀',
+];
+function renderBanner(lines) {
+    const grid = lines.map(l => [...l]);
+    const maxLen = Math.max(...grid.map(r => r.length));
+    for (const row of grid)
+        while (row.length < maxLen)
+            row.push(' ');
+    const H = grid.length, W = maxLen;
+    // Layer 2: offset (1, 0) — right edge shadow
+    const off2X = 1, off2Y = 0;
+    // Layer 3: offset (2, 1) — further right and down
+    const off3X = 2, off3Y = 1;
+    const outW = W + Math.max(off2X, off3X);
+    const outH = H + Math.max(off2Y, off3Y);
+    const result = [];
+    for (let y = 0; y < outH; y++) {
+        let line = '';
+        let lastColor = '';
+        for (let x = 0; x < outW; x++) {
+            const hasFg = y < H && x < W && grid[y][x] !== ' ';
+            const s2R = y - off2Y, s2C = x - off2X;
+            const hasL2 = s2R >= 0 && s2R < H && s2C >= 0 && s2C < W && grid[s2R][s2C] !== ' ';
+            const s3R = y - off3Y, s3C = x - off3X;
+            const hasL3 = s3R >= 0 && s3R < H && s3C >= 0 && s3C < W && grid[s3R][s3C] !== ' ';
+            if (hasFg) {
+                const c = gradientColor(x, maxLen);
+                if (c !== lastColor) {
+                    line += c;
+                    lastColor = c;
+                }
+                line += grid[y][x];
+            }
+            else if (hasL2) {
+                if (lastColor !== 'L2') {
+                    line += SHADOW_COLOR;
+                    lastColor = 'L2';
+                }
+                line += grid[s2R][s2C];
+            }
+            else if (hasL3) {
+                if (lastColor !== 'L3') {
+                    line += SHADOW_BG;
+                    lastColor = 'L3';
+                }
+                line += grid[s3R][s3C];
+            }
+            else {
+                line += ' ';
+            }
+        }
+        result.push(line.replace(/\s+$/, '') + RESET);
+    }
+    while (result.length && result[result.length - 1].replace(/\x1b\[[^m]*m/g, '').trim() === '')
+        result.pop();
+    return result;
+}
+const PC = '\x1b[38;2;100;131;240m'; // primary color
+export function printBanner() {
+    if (!process.stdout.isTTY || process.env.NO_COLOR)
+        return;
+    console.log('');
+    for (const line of renderBanner(BANNER_LINES)) {
+        console.log(line);
+    }
+    console.log('');
+}
+export async function printLoginSuccess(email, profile) {
+    if (!process.stdout.isTTY || process.env.NO_COLOR) {
+        const msg = email ? `Logged in as ${email}.` : 'Logged in.';
+        const profileMsg = profile ? ` Profile "${profile}" saved.` : '';
+        console.log(`${msg}${profileMsg}`);
+        return;
+    }
+    console.log('');
+    if (email)
+        console.log(`  ${PC}\u2713${RESET} Logged in as ${email}`);
+    else
+        console.log(`  ${PC}\u2713${RESET} Logged in`);
+    if (profile)
+        console.log(`  ${PC}\u2713${RESET} Profile "${profile}" saved`);
+    console.log('');
+}

package/dist/lib/base-command.d.ts

@@ -0,0 +1,20 @@
+import { Command, Interfaces } from '@oclif/core';
+import { RespanClient } from '@respan/respan-api';
+import { AuthConfig } from './auth.js';
+export type GlobalFlags = Interfaces.InferredFlags<typeof BaseCommand.baseFlags>;
+export declare abstract class BaseCommand extends Command {
+    static baseFlags: {
+        'api-key': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        profile: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        json: Interfaces.BooleanFlag<boolean>;
+        csv: Interfaces.BooleanFlag<boolean>;
+        verbose: Interfaces.BooleanFlag<boolean>;
+    };
+    protected globalFlags: GlobalFlags;
+    protected getAuth(): AuthConfig;
+    protected getClient(): RespanClient;
+    protected getOutputFormat(): 'json' | 'csv' | 'table';
+    protected outputResult(data: unknown, columns?: string[]): void;
+    protected spin<T>(label: string, fn: () => Promise<T>): Promise<T>;
+    protected handleError(error: unknown): never;
+}

package/dist/lib/base-command.js

@@ -0,0 +1,74 @@
+import { Command, Flags } from '@oclif/core';
+import { RespanClient } from '@respan/respan-api';
+import { resolveAuth } from './auth.js';
+import { outputData } from './output.js';
+import { createSpinner } from './spinner.js';
+export class BaseCommand extends Command {
+    getAuth() {
+        return resolveAuth({
+            'api-key': this.globalFlags['api-key'],
+            profile: this.globalFlags.profile,
+        });
+    }
+    getClient() {
+        const auth = this.getAuth();
+        const token = auth.apiKey || auth.accessToken;
+        if (!token)
+            throw new Error('No API key or access token available.');
+        return new RespanClient({
+            token,
+            ...(auth.baseUrl ? { environment: auth.baseUrl } : {}),
+        });
+    }
+    getOutputFormat() {
+        if (this.globalFlags.json)
+            return 'json';
+        if (this.globalFlags.csv)
+            return 'csv';
+        return 'table';
+    }
+    outputResult(data, columns) {
+        this.log(outputData(data, this.getOutputFormat(), columns));
+    }
+    async spin(label, fn) {
+        const spinner = createSpinner(label);
+        spinner.start();
+        try {
+            const result = await fn();
+            spinner.succeed();
+            return result;
+        }
+        catch (error) {
+            spinner.fail();
+            throw error;
+        }
+    }
+    handleError(error) {
+        if (error instanceof Error) {
+            this.error(error.message, { exit: 1 });
+        }
+        this.error('An unexpected error occurred.', { exit: 1 });
+    }
+}
+BaseCommand.baseFlags = {
+    'api-key': Flags.string({
+        description: 'API key (env: RESPAN_API_KEY)',
+        env: 'RESPAN_API_KEY',
+    }),
+    profile: Flags.string({
+        description: 'Named profile to use',
+    }),
+    json: Flags.boolean({
+        description: 'Output as JSON',
+        default: false,
+    }),
+    csv: Flags.boolean({
+        description: 'Output as CSV',
+        default: false,
+    }),
+    verbose: Flags.boolean({
+        char: 'v',
+        description: 'Show verbose output',
+        default: false,
+    }),
+};

package/dist/lib/config.d.ts

@@ -0,0 +1,26 @@
+export interface ApiKeyCredential {
+    type: 'api_key';
+    apiKey: string;
+    baseUrl: string;
+}
+export interface JwtCredential {
+    type: 'jwt';
+    accessToken: string;
+    refreshToken: string;
+    email: string;
+    baseUrl: string;
+}
+export type Credential = ApiKeyCredential | JwtCredential;
+export interface Config {
+    activeProfile?: string;
+    defaults?: Record<string, string>;
+}
+export declare function getAllCredentials(): Record<string, Credential>;
+export declare function getCredential(profile?: string): Credential | undefined;
+export declare function setCredential(profile: string, credential: Credential): void;
+export declare function deleteCredential(profile: string): void;
+export declare function getConfig(): Config;
+export declare function getActiveProfile(): string;
+export declare function setActiveProfile(profile: string): void;
+export declare function getConfigValue(key: string): string | undefined;
+export declare function setConfigValue(key: string, value: string): void;

package/dist/lib/config.js

@@ -0,0 +1,81 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'respan');
+const CREDENTIALS_FILE = path.join(CONFIG_DIR, 'credentials.json');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+function readJson(filePath, fallback) {
+    try {
+        if (!fs.existsSync(filePath))
+            return fallback;
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeJson(filePath, data) {
+    ensureConfigDir();
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+// --- Credentials ---
+export function getAllCredentials() {
+    return readJson(CREDENTIALS_FILE, {});
+}
+export function getCredential(profile) {
+    const creds = getAllCredentials();
+    const name = profile || getActiveProfile();
+    return creds[name];
+}
+export function setCredential(profile, credential) {
+    const creds = getAllCredentials();
+    creds[profile] = credential;
+    writeJson(CREDENTIALS_FILE, creds);
+    // Set active profile if this is the first credential
+    const config = getConfig();
+    if (!config.activeProfile) {
+        setActiveProfile(profile);
+    }
+}
+export function deleteCredential(profile) {
+    const creds = getAllCredentials();
+    delete creds[profile];
+    writeJson(CREDENTIALS_FILE, creds);
+}
+// --- Config ---
+export function getConfig() {
+    return readJson(CONFIG_FILE, {});
+}
+export function getActiveProfile() {
+    const config = getConfig();
+    return config.activeProfile || 'default';
+}
+export function setActiveProfile(profile) {
+    const config = getConfig();
+    config.activeProfile = profile;
+    writeJson(CONFIG_FILE, config);
+}
+export function getConfigValue(key) {
+    const config = getConfig();
+    if (key === 'activeProfile')
+        return config.activeProfile;
+    return config.defaults?.[key];
+}
+export function setConfigValue(key, value) {
+    const config = getConfig();
+    if (key === 'activeProfile') {
+        config.activeProfile = value;
+    }
+    else {
+        if (!config.defaults)
+            config.defaults = {};
+        config.defaults[key] = value;
+    }
+    writeJson(CONFIG_FILE, config);
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Output formatting utilities for the CLI.
+ * Supports JSON, CSV, and table output formats.
+ */
+export type OutputFormat = 'json' | 'csv' | 'table';
+export declare function outputData(data: unknown, format: OutputFormat, columns?: string[]): string;

package/dist/lib/output.js

@@ -0,0 +1,95 @@
+/**
+ * Output formatting utilities for the CLI.
+ * Supports JSON, CSV, and table output formats.
+ */
+export function outputData(data, format, columns) {
+    switch (format) {
+        case 'json':
+            return formatJson(data);
+        case 'csv':
+            return formatCsv(data, columns);
+        case 'table':
+        default:
+            return formatTable(data, columns);
+    }
+}
+function formatJson(data) {
+    return JSON.stringify(data, null, 2);
+}
+function formatCsv(data, columns) {
+    const rows = normalizeToArray(data);
+    if (rows.length === 0)
+        return '';
+    const cols = columns || Object.keys(rows[0]);
+    const header = cols.join(',');
+    const body = rows
+        .map((row) => {
+        const record = row;
+        return cols.map((col) => escapeCsvValue(record[col])).join(',');
+    })
+        .join('\n');
+    return `${header}\n${body}`;
+}
+function escapeCsvValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    const str = String(value);
+    if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+        return `"${str.replace(/"/g, '""')}"`;
+    }
+    return str;
+}
+function formatTable(data, columns) {
+    const rows = normalizeToArray(data);
+    if (rows.length === 0)
+        return 'No data.';
+    const cols = columns || Object.keys(rows[0]);
+    const widths = {};
+    for (const col of cols) {
+        widths[col] = col.length;
+    }
+    const stringRows = rows.map((row) => {
+        const record = row;
+        const stringRow = {};
+        for (const col of cols) {
+            const val = truncate(formatValue(record[col]), 40);
+            stringRow[col] = val;
+            widths[col] = Math.max(widths[col], val.length);
+        }
+        return stringRow;
+    });
+    const header = cols.map((col) => col.padEnd(widths[col])).join('  ');
+    const separator = cols.map((col) => '-'.repeat(widths[col])).join('  ');
+    const body = stringRows
+        .map((row) => cols.map((col) => (row[col] || '').padEnd(widths[col])).join('  '))
+        .join('\n');
+    return `${header}\n${separator}\n${body}`;
+}
+function normalizeToArray(data) {
+    if (Array.isArray(data))
+        return data;
+    if (data && typeof data === 'object') {
+        const obj = data;
+        // Handle paginated responses
+        if ('results' in obj && Array.isArray(obj.results))
+            return obj.results;
+        if ('data' in obj && Array.isArray(obj.data))
+            return obj.data;
+        if ('items' in obj && Array.isArray(obj.items))
+            return obj.items;
+        return [data];
+    }
+    return [{ value: data }];
+}
+function formatValue(value) {
+    if (value === null || value === undefined)
+        return '-';
+    if (typeof value === 'object')
+        return JSON.stringify(value);
+    return String(value);
+}
+function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen - 3) + '...';
+}

package/dist/lib/pagination.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Pagination utilities for CLI list commands.
+ */
+export interface PaginationInfo {
+    page: number;
+    totalPages?: number;
+    totalCount?: number;
+    hasNext: boolean;
+    hasPrevious: boolean;
+}
+export declare function extractPagination(response: unknown, currentPage: number): PaginationInfo;
+export declare function formatPaginationInfo(info: PaginationInfo): string;

package/dist/lib/pagination.js

@@ -0,0 +1,34 @@
+/**
+ * Pagination utilities for CLI list commands.
+ */
+export function extractPagination(response, currentPage) {
+    if (!response || typeof response !== 'object') {
+        return { page: currentPage, hasNext: false, hasPrevious: currentPage > 1 };
+    }
+    const obj = response;
+    const count = typeof obj.count === 'number' ? obj.count : undefined;
+    const next = obj.next != null;
+    const previous = obj.previous != null;
+    const totalPages = typeof obj.total_pages === 'number'
+        ? obj.total_pages
+        : count && typeof obj.page_size === 'number'
+            ? Math.ceil(count / obj.page_size)
+            : undefined;
+    return {
+        page: currentPage,
+        totalPages,
+        totalCount: count,
+        hasNext: next,
+        hasPrevious: previous,
+    };
+}
+export function formatPaginationInfo(info) {
+    const parts = [`Page ${info.page}`];
+    if (info.totalPages)
+        parts[0] += ` of ${info.totalPages}`;
+    if (info.totalCount !== undefined)
+        parts.push(`Total: ${info.totalCount}`);
+    if (info.hasNext)
+        parts.push('(more results available)');
+    return parts.join('  |  ');
+}

package/dist/lib/spinner.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Simple TTY spinner for CLI feedback.
+ * Falls back to plain text when not in a TTY or NO_COLOR is set.
+ */
+export interface Spinner {
+    start(): void;
+    succeed(text?: string): void;
+    fail(text?: string): void;
+    stop(): void;
+}
+export declare function createSpinner(label: string): Spinner;

package/dist/lib/spinner.js

@@ -0,0 +1,56 @@
+/**
+ * Simple TTY spinner for CLI feedback.
+ * Falls back to plain text when not in a TTY or NO_COLOR is set.
+ */
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const INTERVAL = 80;
+export function createSpinner(label) {
+    const isTTY = process.stderr.isTTY && !process.env.NO_COLOR;
+    if (!isTTY) {
+        return {
+            start() {
+                process.stderr.write(`${label}...\n`);
+            },
+            succeed(text) {
+                process.stderr.write(`${text || label} done.\n`);
+            },
+            fail(text) {
+                process.stderr.write(`${text || label} failed.\n`);
+            },
+            stop() { },
+        };
+    }
+    let frameIndex = 0;
+    let timer = null;
+    function clear() {
+        process.stderr.write('\r\x1b[K');
+    }
+    function render() {
+        clear();
+        process.stderr.write(`${FRAMES[frameIndex]} ${label}`);
+        frameIndex = (frameIndex + 1) % FRAMES.length;
+    }
+    return {
+        start() {
+            render();
+            timer = setInterval(render, INTERVAL);
+        },
+        succeed(text) {
+            if (timer)
+                clearInterval(timer);
+            clear();
+            process.stderr.write(`\x1b[32m✓\x1b[0m ${text || label}\n`);
+        },
+        fail(text) {
+            if (timer)
+                clearInterval(timer);
+            clear();
+            process.stderr.write(`\x1b[31m✗\x1b[0m ${text || label}\n`);
+        },
+        stop() {
+            if (timer)
+                clearInterval(timer);
+            clear();
+        },
+    };
+}