@j-256/ccam 0.1.0

package/dist/output/default-columns.js

@@ -0,0 +1,16 @@
+export const DEFAULT_COLUMNS = {
+    user: ['mail', 'firstName', 'lastName', 'userState', 'primaryOrganization', 'lastLoginDate', 'roles'],
+    userDetail: ['id', 'mail', 'firstName', 'lastName', 'displayName', 'userState', 'primaryOrganization', 'organizations', 'roles', 'lastLoginDate', 'createdAt', 'lastModified'],
+    role: ['description', 'id', 'serviceType', 'scope', 'targetType', 'privileged', 'twoFAEnabled'],
+    roleDetail: ['description', 'id', 'serviceType', 'scope', 'targetType', 'privileged', 'twoFAEnabled', 'permissions'],
+    org: ['name', 'id', 'type', 'twoFAEnabled'],
+    orgDetail: ['name', 'id', 'type', 'twoFAEnabled', 'emailDomains', 'sfAccountIds', 'realms'],
+    client: ['id', 'name', 'active', 'organizationCount', 'tokenEndpointAuthMethod', 'lastAuthenticatedDate'],
+    clientDetail: ['id', 'name', 'description', 'active', 'organizations', 'roles', 'scopes', 'tokenEndpointAuthMethod', 'lastAuthenticatedDate', 'createdAt'],
+    instance: ['id', 'description', 'podId', 'tenantType'],
+    realm: ['id', 'description', 'customerName', 'organizationId'],
+    permission: ['name', 'adminPermission'],
+    serviceType: ['id', 'description'],
+    auditLog: ['timestamp', 'eventType', 'eventMessage', 'authorDisplayName', 'authorEmail'],
+};
+//# sourceMappingURL=default-columns.js.map

package/dist/output/detect.d.ts

@@ -0,0 +1,4 @@
+import type { OutputFormat } from './types.js';
+export type { OutputFormat };
+export declare function resolveFormat(explicit: string | undefined, isTTY: boolean): OutputFormat;
+//# sourceMappingURL=detect.d.ts.map

package/dist/output/detect.js

@@ -0,0 +1,6 @@
+export function resolveFormat(explicit, isTTY) {
+    if (explicit)
+        return explicit;
+    return isTTY ? 'table' : 'json';
+}
+//# sourceMappingURL=detect.js.map

package/dist/output/index.d.ts

@@ -0,0 +1,15 @@
+export type { OutputFormat } from './types.js';
+export { resolveFormat } from './detect.js';
+export { formatJson } from './json.js';
+export { formatCsv, formatTsv } from './csv.js';
+export { formatYaml } from './yaml-fmt.js';
+export { formatTable } from './table.js';
+export { DEFAULT_COLUMNS } from './default-columns.js';
+import type { OutputFormat } from './types.js';
+export interface RenderOptions {
+    format: OutputFormat;
+    fields?: string[];
+    defaultFields?: string[];
+}
+export declare function renderOutput(data: unknown, options: RenderOptions): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/output/index.js

@@ -0,0 +1,34 @@
+export { resolveFormat } from './detect.js';
+export { formatJson } from './json.js';
+export { formatCsv, formatTsv } from './csv.js';
+export { formatYaml } from './yaml-fmt.js';
+export { formatTable } from './table.js';
+export { DEFAULT_COLUMNS } from './default-columns.js';
+import { formatJson } from './json.js';
+import { formatCsv, formatTsv } from './csv.js';
+import { formatYaml } from './yaml-fmt.js';
+import { formatTable } from './table.js';
+export function renderOutput(data, options) {
+    let output;
+    switch (options.format) {
+        case 'json':
+            output = formatJson(data, options.fields);
+            break;
+        case 'csv':
+            output = formatCsv(data, options.fields);
+            break;
+        case 'tsv':
+            output = formatTsv(data, options.fields);
+            break;
+        case 'yaml':
+            output = formatYaml(data, options.fields);
+            break;
+        case 'table':
+            output = formatTable(data, options.fields ?? options.defaultFields);
+            break;
+        default:
+            throw new Error(`Unsupported format: ${options.format}`);
+    }
+    process.stdout.write(output + '\n');
+}
+//# sourceMappingURL=index.js.map

package/dist/output/json.d.ts

@@ -0,0 +1,2 @@
+export declare function formatJson(data: unknown, fields?: string[]): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/output/json.js

@@ -0,0 +1,10 @@
+import { applyFieldSelection } from './shared.js';
+export function formatJson(data, fields) {
+    if (!fields) {
+        return JSON.stringify(data, null, 2);
+    }
+    // Apply field selection
+    const filtered = applyFieldSelection(data, fields);
+    return JSON.stringify(filtered, null, 2);
+}
+//# sourceMappingURL=json.js.map

package/dist/output/shared.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared utilities for output formatters.
+ */
+/** Collect the union of top-level keys across a list of objects. */
+export declare function extractColumns(data: unknown[]): string[];
+/** Return the top-level property of an object by key. */
+export declare function getNestedValue(obj: unknown, path: string): unknown;
+/**
+ * Apply a field allowlist to a single object or an array of objects.
+ * Used by JSON/YAML formatters where the goal is to drop un-requested fields.
+ */
+export declare function applyFieldSelection(data: unknown, fields: string[]): unknown;
+//# sourceMappingURL=shared.d.ts.map

package/dist/output/shared.js

@@ -0,0 +1,41 @@
+/**
+ * Shared utilities for output formatters.
+ */
+/** Collect the union of top-level keys across a list of objects. */
+export function extractColumns(data) {
+    const columns = new Set();
+    for (const item of data) {
+        if (typeof item === 'object' && item !== null) {
+            Object.keys(item).forEach((key) => columns.add(key));
+        }
+    }
+    return Array.from(columns);
+}
+/** Return the top-level property of an object by key. */
+export function getNestedValue(obj, path) {
+    if (typeof obj !== 'object' || obj === null)
+        return undefined;
+    return obj[path];
+}
+/**
+ * Apply a field allowlist to a single object or an array of objects.
+ * Used by JSON/YAML formatters where the goal is to drop un-requested fields.
+ */
+export function applyFieldSelection(data, fields) {
+    if (Array.isArray(data)) {
+        return data.map((item) => pickFields(item, fields));
+    }
+    return pickFields(data, fields);
+}
+function pickFields(obj, fields) {
+    if (typeof obj !== 'object' || obj === null)
+        return obj;
+    const result = {};
+    for (const field of fields) {
+        if (field in obj) {
+            result[field] = obj[field];
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=shared.js.map

package/dist/output/table.d.ts

@@ -0,0 +1,2 @@
+export declare function formatTable(data: unknown, fields?: string[]): string;
+//# sourceMappingURL=table.d.ts.map

package/dist/output/table.js

@@ -0,0 +1,72 @@
+import Table from 'cli-table3';
+import chalk from 'chalk';
+import { extractColumns, getNestedValue } from './shared.js';
+const MAX_CELL_LENGTH = 60;
+export function formatTable(data, fields) {
+    let items;
+    if (!Array.isArray(data)) {
+        items = [data];
+    }
+    else {
+        items = data;
+    }
+    if (items.length === 0) {
+        return 'No results.';
+    }
+    // Determine columns
+    const columns = fields || extractColumns(items);
+    if (columns.length === 0) {
+        return 'No results.';
+    }
+    // Create table with styled headers
+    const table = new Table({
+        head: columns.map((col) => chalk.gray(col)),
+        style: {
+            head: [],
+            border: [],
+        },
+    });
+    // Add data rows
+    for (const item of items) {
+        const row = columns.map((col) => {
+            const value = getNestedValue(item, col);
+            return formatCell(value);
+        });
+        table.push(row);
+    }
+    return table.toString();
+}
+function formatCell(value) {
+    if (value === null || value === undefined) {
+        return chalk.dim('-');
+    }
+    let stringValue;
+    if (Array.isArray(value)) {
+        stringValue = value.join(', ');
+    }
+    else if (typeof value === 'object') {
+        stringValue = JSON.stringify(value);
+    }
+    else {
+        stringValue = String(value);
+    }
+    // Truncate long values before colorizing so ANSI escapes aren't split.
+    if (stringValue.length > MAX_CELL_LENGTH) {
+        stringValue = stringValue.slice(0, MAX_CELL_LENGTH - 3) + '...';
+    }
+    // Apply color coding for known status values after truncation.
+    return colorizeStatus(stringValue);
+}
+function colorizeStatus(value) {
+    if (value === 'ENABLED' || value === 'true') {
+        return chalk.green(value);
+    }
+    if (value === 'DELETED') {
+        return chalk.red(value);
+    }
+    if (value === 'false') {
+        return chalk.dim(value);
+    }
+    return value;
+}
+//# sourceMappingURL=table.js.map

package/dist/output/types.d.ts

@@ -0,0 +1,2 @@
+export type OutputFormat = 'table' | 'json' | 'csv' | 'tsv' | 'yaml';
+//# sourceMappingURL=types.d.ts.map

package/dist/output/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/output/yaml-fmt.d.ts

@@ -0,0 +1,2 @@
+export declare function formatYaml(data: unknown, fields?: string[]): string;
+//# sourceMappingURL=yaml-fmt.d.ts.map

package/dist/output/yaml-fmt.js

@@ -0,0 +1,11 @@
+import { stringify } from 'yaml';
+import { applyFieldSelection } from './shared.js';
+export function formatYaml(data, fields) {
+    if (!fields) {
+        return stringify(data);
+    }
+    // Apply field selection
+    const filtered = applyFieldSelection(data, fields);
+    return stringify(filtered);
+}
+//# sourceMappingURL=yaml-fmt.js.map

package/dist/program.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const program: Command;
+//# sourceMappingURL=program.d.ts.map

package/dist/program.js

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { registerAuthCommands } from './commands/auth.js';
+import { registerUserCommands } from './commands/user.js';
+import { registerOrgCommands } from './commands/org.js';
+import { registerClientCommands } from './commands/client.js';
+import { registerRoleCommands } from './commands/role.js';
+import { registerRealmCommands } from './commands/realm.js';
+import { registerPermissionCommands } from './commands/permission.js';
+import { registerServiceTypeCommands } from './commands/service-type.js';
+import { registerInstanceCommands } from './commands/instance.js';
+import { registerOrgConfigCommands } from './commands/org-config.js';
+export const program = new Command()
+    .name('ccam')
+    .description('CLI for the Salesforce Commerce Cloud Account Manager API')
+    .version('0.1.0')
+    .option('-i, --interactive', 'Launch interactive TUI')
+    .action(async (options) => {
+    if (options.interactive || process.stdout.isTTY) {
+        const { startTui } = await import('./tui/index.js');
+        await startTui();
+    }
+    else {
+        program.help();
+    }
+});
+// Register all command groups
+registerAuthCommands(program);
+registerUserCommands(program);
+registerOrgCommands(program);
+registerClientCommands(program);
+registerRoleCommands(program);
+registerRealmCommands(program);
+registerPermissionCommands(program);
+registerServiceTypeCommands(program);
+registerInstanceCommands(program);
+registerOrgConfigCommands(program);
+//# sourceMappingURL=program.js.map

package/dist/shared.d.ts

@@ -0,0 +1,46 @@
+import { Command } from 'commander';
+import type { OutputFormat } from './output/index.js';
+export interface GlobalOptions {
+    format?: string;
+    fields?: string;
+    page?: string;
+    size?: string;
+    sort?: string;
+    profile?: string;
+    host?: string;
+    json?: boolean;
+}
+export interface ParsedSort {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+export interface ResolvedGlobalOptions {
+    format?: OutputFormat;
+    fields?: string[];
+    page?: number;
+    size?: number;
+    sort?: ParsedSort;
+    profile?: string;
+    host?: string;
+}
+export declare function parseFields(value: string | undefined): string[] | undefined;
+export declare function parseSort(value: string | undefined): ParsedSort | undefined;
+export declare function parsePageSize(value: string | undefined, defaultValue?: number): number | undefined;
+/**
+ * Parse and validate a user-provided --expand flag against an allowed set.
+ * Throws with a clear message on unknown values, so the user gets a CLI error
+ * instead of the AM server silently ignoring the parameter.
+ *
+ * @param input - raw --expand value (e.g. 'organizations')
+ * @param allowed - array of allowed expand tokens for this endpoint
+ * @returns the validated expand value, or undefined if input was undefined
+ */
+export declare function parseExpand<T extends string>(input: string | undefined, allowed: readonly T[]): T | undefined;
+export declare function addGlobalOptions(cmd: Command): Command;
+/**
+ * Write "Page X of Y (N total)" to stderr if the format is 'table' and the
+ * result has page metadata. No-op otherwise.
+ */
+export declare function writePageInfoIfTable(format: string, result: unknown): void;
+export declare function resolveGlobalOptions(opts: GlobalOptions): ResolvedGlobalOptions;
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.js

@@ -0,0 +1,96 @@
+export function parseFields(value) {
+    if (!value)
+        return undefined;
+    return value.split(',').map((field) => field.trim()).filter((field) => field.length > 0);
+}
+export function parseSort(value) {
+    if (!value)
+        return undefined;
+    const [field, direction = 'asc'] = value.split(':');
+    if (!field) {
+        throw new Error(`Invalid sort field: empty. Use "field:asc" or "field:desc"`);
+    }
+    if (direction !== 'asc' && direction !== 'desc') {
+        throw new Error(`Invalid sort direction: "${direction}". Use "asc" or "desc"`);
+    }
+    return { field, direction };
+}
+export function parsePageSize(value, defaultValue) {
+    if (!value)
+        return defaultValue;
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed) || parsed < 0) {
+        throw new Error(`Invalid number: ${value}`);
+    }
+    return parsed;
+}
+/**
+ * Parse and validate a user-provided --expand flag against an allowed set.
+ * Throws with a clear message on unknown values, so the user gets a CLI error
+ * instead of the AM server silently ignoring the parameter.
+ *
+ * @param input - raw --expand value (e.g. 'organizations')
+ * @param allowed - array of allowed expand tokens for this endpoint
+ * @returns the validated expand value, or undefined if input was undefined
+ */
+export function parseExpand(input, allowed) {
+    if (input === undefined)
+        return undefined;
+    if (!allowed.includes(input)) {
+        throw new Error(`Invalid --expand value: "${input}". Allowed: ${allowed.join(', ')}`);
+    }
+    return input;
+}
+export function addGlobalOptions(cmd) {
+    return cmd
+        .option('--format <format>', 'Output format: table, json, csv, tsv, yaml')
+        .option('--fields <fields>', 'Comma-separated list of fields to include')
+        .option('--page <page>', 'Page number for pagination', '0')
+        .option('--size <size>', 'Page size for pagination', '25')
+        .option('--sort <sort>', 'Sort field and direction (e.g., name:asc)')
+        .option('--profile <profile>', 'Profile name from config')
+        .option('--host <host>', 'API host URL (default: https://account.demandware.com)')
+        .option('-j, --json', 'Shorthand for --format json');
+}
+/**
+ * Write "Page X of Y (N total)" to stderr if the format is 'table' and the
+ * result has page metadata. No-op otherwise.
+ */
+export function writePageInfoIfTable(format, result) {
+    if (format !== 'table')
+        return;
+    if (!result || typeof result !== 'object')
+        return;
+    if (!('page' in result))
+        return;
+    const page = result.page;
+    process.stderr.write(`Page ${page.number + 1} of ${page.totalPages} (${page.totalElements} total)\n`);
+}
+export function resolveGlobalOptions(opts) {
+    const resolved = {
+        profile: opts.profile,
+    };
+    // -j flag overrides format
+    if (opts.json) {
+        resolved.format = 'json';
+    }
+    else if (opts.format) {
+        resolved.format = opts.format;
+    }
+    // Parse fields
+    if (opts.fields) {
+        resolved.fields = parseFields(opts.fields);
+    }
+    // Parse page and size
+    resolved.page = parsePageSize(opts.page, 0);
+    resolved.size = parsePageSize(opts.size, 25);
+    // Parse sort
+    if (opts.sort) {
+        resolved.sort = parseSort(opts.sort);
+    }
+    if (opts.host) {
+        resolved.host = opts.host;
+    }
+    return resolved;
+}
+//# sourceMappingURL=shared.js.map

package/dist/tui/App.d.ts

@@ -0,0 +1,7 @@
+import type { CcamClient } from 'ccam-sdk';
+export interface AppProps {
+    client: CcamClient;
+    host?: string;
+}
+export declare function App({ client, host }: AppProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=App.d.ts.map

package/dist/tui/App.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useApp, useInput } from 'ink';
+import { ClientProvider } from './context/client.js';
+import { TerminalSizeProvider } from './context/terminal-size.js';
+import { NavigationProvider, useNav } from './context/navigation.js';
+import { FullScreenLayout } from './components/FullScreenLayout.js';
+import { ViewRouter } from './views/ViewRouter.js';
+function AppInner({ host }) {
+    const nav = useNav();
+    const { exit } = useApp();
+    useInput((input, key) => {
+        if (input === 'q' && nav.current.view === 'resource-picker') {
+            exit();
+            return;
+        }
+        if (key.escape || input === 'q') {
+            if (nav.canGoBack) {
+                nav.pop();
+            }
+            else {
+                exit();
+            }
+        }
+    });
+    return (_jsx(FullScreenLayout, { host: host, children: _jsx(ViewRouter, {}) }));
+}
+export function App({ client, host }) {
+    return (_jsx(ClientProvider, { client: client, children: _jsx(TerminalSizeProvider, { children: _jsx(NavigationProvider, { initial: { view: 'resource-picker', label: 'Home' }, children: _jsx(AppInner, { host: host }) }) }) }));
+}
+//# sourceMappingURL=App.js.map

package/dist/tui/components/AuditTab.d.ts

@@ -0,0 +1,8 @@
+import type { ColumnDef } from '../types.js';
+import type { AuditLogRecord, ContentResponse } from 'ccam-sdk';
+export interface AuditTabProps {
+    fetchFn: (querySize?: number) => Promise<ContentResponse<AuditLogRecord>>;
+    columns?: ColumnDef[];
+}
+export declare function AuditTab({ fetchFn, columns }: AuditTabProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AuditTab.d.ts.map

package/dist/tui/components/AuditTab.js

@@ -0,0 +1,80 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useCallback } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useAuditLog } from '../hooks/use-audit-log.js';
+import { useScrollWindow } from '../hooks/use-scroll-window.js';
+import { useTerminalSize } from '../context/terminal-size.js';
+import { Table } from './Table.js';
+import { HintText } from './FooterBar.js';
+const BORDER_INSET = 2;
+const DEFAULT_COLUMNS = [
+    { key: 'timestamp', label: 'Time', width: 2 },
+    { key: 'authorDisplayName', label: 'Author', width: 2 },
+    { key: 'eventType', label: 'Event', width: 2 },
+    { key: 'eventMessage', label: 'Message', width: 4 },
+];
+export function AuditTab({ fetchFn, columns }) {
+    const { cols } = useTerminalSize();
+    const [highlight, setHighlight] = useState(0);
+    const { data, loading, error, canLoadMore, needsConfirmation, loadMore, confirmLoadAll, retry, } = useAuditLog(fetchFn);
+    const scroll = useScrollWindow(highlight, data.length);
+    const handleLoadMore = useCallback(() => {
+        if (needsConfirmation) {
+            confirmLoadAll();
+        }
+        else {
+            loadMore();
+        }
+    }, [needsConfirmation, confirmLoadAll, loadMore]);
+    useInput((input, key) => {
+        if (loading)
+            return;
+        if (error) {
+            if (input === 'r')
+                retry();
+            return;
+        }
+        // Vertical movement
+        if (input === 'j' || key.downArrow) {
+            setHighlight((i) => Math.min(i + 1, data.length - 1));
+        }
+        if (input === 'k' || key.upArrow) {
+            setHighlight((i) => Math.max(i - 1, 0));
+        }
+        // Jump to first/last
+        if (input === 'g')
+            setHighlight(0);
+        if (input === 'G')
+            setHighlight(Math.max(0, data.length - 1));
+        // Load more
+        if (input === 'm' && canLoadMore) {
+            handleLoadMore();
+        }
+        // Scroll
+        if (input === 'n') {
+            setHighlight((i) => Math.min(i + scroll.visibleRows, data.length - 1));
+        }
+        if (input === 'p') {
+            setHighlight((i) => Math.max(i - scroll.visibleRows, 0));
+        }
+        // Refresh (resets to initial querySize)
+        if (input === 'r')
+            retry();
+    });
+    if (error) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", children: ["Error: ", error.message] }), _jsx(Text, { dimColor: true, children: "r:retry" })] }));
+    }
+    if (loading && data.length === 0) {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Loading audit log..." })] }));
+    }
+    // Footer hints
+    const hintParts = ['[j/k:nav]'];
+    if (canLoadMore) {
+        hintParts.push(needsConfirmation ? '[m:load all]' : '[m:more]');
+    }
+    hintParts.push('[r:refresh]');
+    const hints = hintParts.join(' ');
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Table, { columns: columns ?? DEFAULT_COLUMNS, data: data, highlightIndex: highlight, visibleRows: scroll.visibleRows, scrollOffset: scroll.scrollOffset, contentWidth: cols - BORDER_INSET }), _jsxs(Box, { justifyContent: "space-between", children: [_jsx(HintText, { hints: hints }), _jsxs(Text, { dimColor: true, children: [data.length, " records", loading ? ' (loading...)' : ''] })] })] }));
+}
+//# sourceMappingURL=AuditTab.js.map

package/dist/tui/components/FooterBar.d.ts

@@ -0,0 +1,17 @@
+export interface FooterBarProps {
+    hints?: string;
+    pageInfo?: string;
+    loading?: boolean;
+    sortLabel?: string;
+    statsLabel?: string;
+}
+/**
+ * Format hint strings in bracket notation.
+ * Input format: "[j/k:nav] [Enter:open] [Esc:back]"
+ * Each segment: "[key:description]"
+ */
+export declare function HintText({ hints }: {
+    hints: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function FooterBar({ hints, pageInfo, loading, sortLabel, statsLabel }: FooterBarProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FooterBar.d.ts.map

package/dist/tui/components/FooterBar.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+/**
+ * Format hint strings in bracket notation.
+ * Input format: "[j/k:nav] [Enter:open] [Esc:back]"
+ * Each segment: "[key:description]"
+ */
+export function HintText({ hints }) {
+    const segments = hints.match(/\[[^\]]+\]/g) || [];
+    return (_jsx(Text, { children: segments.map((seg, i) => {
+            // Strip brackets, split on first colon
+            const inner = seg.slice(1, -1);
+            const colonIdx = inner.indexOf(':');
+            const key = colonIdx > 0 ? inner.slice(0, colonIdx) : inner;
+            const desc = colonIdx > 0 ? inner.slice(colonIdx) : '';
+            return (_jsxs(Text, { children: [i > 0 && _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "[" }), _jsx(Text, { bold: true, color: "cyan", children: key }), _jsxs(Text, { dimColor: true, children: [desc, "]"] })] }, i));
+        }) }));
+}
+export function FooterBar({ hints, pageInfo, loading, sortLabel, statsLabel }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", children: [(loading || sortLabel || statsLabel) && (_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { children: [loading && (_jsxs(Text, { color: "cyan", children: [_jsx(Spinner, { type: "dots" }), ' '] })), sortLabel && _jsx(Text, { dimColor: true, children: sortLabel })] }), statsLabel && _jsx(Text, { dimColor: true, children: statsLabel })] })), _jsxs(Box, { justifyContent: "space-between", children: [hints && _jsx(HintText, { hints: hints }), pageInfo && _jsx(Text, { dimColor: true, children: pageInfo })] })] }));
+}
+//# sourceMappingURL=FooterBar.js.map

package/dist/tui/components/FullScreenLayout.d.ts

@@ -0,0 +1,6 @@
+import type { HeaderBarProps } from './HeaderBar.js';
+export interface FullScreenLayoutProps extends HeaderBarProps {
+    children: React.ReactNode;
+}
+export declare function FullScreenLayout({ children, host, }: FullScreenLayoutProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FullScreenLayout.d.ts.map

package/dist/tui/components/FullScreenLayout.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from 'ink';
+import { useTerminalSize } from '../context/terminal-size.js';
+import { HeaderBar } from './HeaderBar.js';
+export function FullScreenLayout({ children, host, }) {
+    const { rows } = useTerminalSize();
+    // Header: 1 line top border + 1 line breadcrumb + 1 line bottom border = 3
+    const contentHeight = rows - 3;
+    return (_jsxs(Box, { flexDirection: "column", height: rows, children: [_jsx(HeaderBar, { host: host }), _jsx(Box, { height: contentHeight, children: children })] }));
+}
+//# sourceMappingURL=FullScreenLayout.js.map

package/dist/tui/components/HeaderBar.d.ts

@@ -0,0 +1,5 @@
+export interface HeaderBarProps {
+    host?: string;
+}
+export declare function HeaderBar({ host }: HeaderBarProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=HeaderBar.d.ts.map

package/dist/tui/components/HeaderBar.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useNav } from '../context/navigation.js';
+export function HeaderBar({ host }) {
+    const { breadcrumbs } = useNav();
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "gray", justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "ccam" }), breadcrumbs.map((crumb, i) => (_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [" ", '>', " "] }), i === breadcrumbs.length - 1
+                                ? _jsx(Text, { bold: true, color: "white", children: crumb })
+                                : _jsx(Text, { children: crumb })] }, i)))] }), host && _jsx(Text, { dimColor: true, children: host })] }));
+}
+//# sourceMappingURL=HeaderBar.js.map