@duvoai/cli 0.0.1

package/dist/commands/api.js

@@ -0,0 +1,98 @@
+import { buildFieldObject } from "../api/parse-fields.js";
+import { readInputJson } from "../api/read-input.js";
+import { httpRequest } from "../client/client.js";
+import { resolveConfig } from "../config/resolve.js";
+import { CliError, EXIT_CODE } from "../errors.js";
+import { renderApiResponse } from "./api-render.js";
+import { getProfileFlag } from "./shared/profile-flag.js";
+const METHODS_WITH_BODY = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+const VALID_METHODS = new Set([
+    "GET",
+    "HEAD",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+]);
+export function registerApi(program) {
+    program
+        .command("api <method> <path>")
+        .description("Make an authenticated request to the Duvo public API")
+        .option("-f, --field <key=value>", "string field; repeat for multiple (body on POST/PUT/PATCH/DELETE, query on GET/HEAD)", collect, [])
+        .option("-F, --raw-field <key=value>", "typed field (boolean, number, null, or @file for JSON); repeat for multiple", collect, [])
+        .option("--input <path>", 'raw JSON body from a file, or "-" for stdin (mutually exclusive with -f / -F)')
+        .option("--json", "output raw JSON instead of the formatted view")
+        .action(async function apiAction(method, path, options) {
+        await runApi({
+            method,
+            path,
+            options,
+        }, { profileFlag: getProfileFlag(this) });
+    });
+}
+async function runApi(args, resolveOptions) {
+    const resolved = await resolveConfig(resolveOptions);
+    if (!resolved.apiKey) {
+        throw new CliError("Not logged in. Run `duvo login` to save an API key.", EXIT_CODE.AUTH);
+    }
+    const method = args.method.toUpperCase();
+    if (!VALID_METHODS.has(method)) {
+        throw new CliError(`Invalid HTTP method "${args.method}". Expected one of: ${[...VALID_METHODS].join(", ")}.`);
+    }
+    const { body, searchParams } = prepareRequestData(method, args.options);
+    const response = await httpRequest({
+        method,
+        path: args.path,
+        apiKey: resolved.apiKey,
+        apiBaseUrl: resolved.apiBaseUrl,
+        body,
+        searchParams,
+    });
+    renderApiResponse(response, args.options.json ?? false);
+}
+function prepareRequestData(method, options) {
+    const hasFieldArgs = (options.field?.length ?? 0) > 0 || (options.rawField?.length ?? 0) > 0;
+    if (options.input !== undefined && hasFieldArgs) {
+        throw new CliError("Cannot combine --input with -f / -F flags.");
+    }
+    if (options.input !== undefined) {
+        if (!METHODS_WITH_BODY.has(method)) {
+            throw new CliError(`--input is only supported for ${[...METHODS_WITH_BODY].join(", ")} requests.`);
+        }
+        return { body: readInputJson(options.input), searchParams: undefined };
+    }
+    if (!hasFieldArgs) {
+        return { body: undefined, searchParams: undefined };
+    }
+    const fields = buildFieldObject(options.field, options.rawField);
+    if (METHODS_WITH_BODY.has(method)) {
+        return { body: fields, searchParams: undefined };
+    }
+    return { body: undefined, searchParams: fieldsToSearchParams(fields) };
+}
+function collect(value, previous) {
+    return [...previous, value];
+}
+/**
+ * Encodes typed fields as query string values. Scalars pass through as
+ * their string form; objects and arrays are JSON-stringified so an
+ * `-F filter=@file.json` round-trips to a usable `?filter=…` rather
+ * than `[object Object]`. `null` / `undefined` keys are dropped — query
+ * strings have no native null encoding.
+ */
+function fieldsToSearchParams(fields) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(fields)) {
+        if (value === null || value === undefined) {
+            continue;
+        }
+        if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            params.append(key, String(value));
+            continue;
+        }
+        params.append(key, JSON.stringify(value));
+    }
+    return params;
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerLogin(program: Command): void;

package/dist/commands/login.js

@@ -0,0 +1,80 @@
+import { isCancel, password, text } from "@clack/prompts";
+import { DEFAULT_API_BASE_URL } from "../config/defaults.js";
+import { addProfile, isValidProfileName } from "../config/profiles.js";
+import { readConfig, writeConfig } from "../config/store.js";
+import { AuthCliError, CancelCliError, CliError } from "../errors.js";
+export function registerLogin(program) {
+    program
+        .command("login")
+        .description("Store an API key under a named profile")
+        .option("--name <profile>", "profile name to store this key under (prompted if omitted)")
+        .option("--api-key <key>", "API key (non-interactive; skips the masked prompt)")
+        .option("--base-url <url>", `API base URL for this profile (default: ${DEFAULT_API_BASE_URL})`)
+        .action(async (options) => {
+        await runLogin(options);
+    });
+}
+async function runLogin(options) {
+    const config = await readConfig();
+    const existingCount = Object.keys(config.profiles).length;
+    const name = await resolveProfileName(options.name, existingCount);
+    const apiKey = await resolveApiKey(options.apiKey);
+    const apiBaseUrl = options.baseUrl ?? DEFAULT_API_BASE_URL;
+    const next = addProfile(config, name, { apiKey, apiBaseUrl });
+    await writeConfig(next);
+    const isNew = !(name in config.profiles);
+    const verb = isNew ? "Saved" : "Updated";
+    console.log(`${verb} profile "${name}".`);
+    if (next.defaultProfile === name && config.defaultProfile !== name) {
+        console.log(`Set "${name}" as the default profile.`);
+    }
+}
+async function resolveProfileName(flag, existingCount) {
+    if (flag !== undefined) {
+        if (!isValidProfileName(flag)) {
+            throw new CliError(`Invalid profile name "${flag}". Use lowercase letters, digits, ` +
+                `".", "-" or "_", max 40 chars.`);
+        }
+        return flag;
+    }
+    const placeholder = existingCount === 0 ? "default" : "";
+    const answer = await text({
+        message: "Profile name",
+        placeholder: placeholder || "e.g. acme",
+        defaultValue: placeholder,
+        validate: (value) => {
+            if (!value || value.length === 0) {
+                return "Profile name is required.";
+            }
+            if (!isValidProfileName(value)) {
+                return 'Use lowercase letters, digits, ".", "-" or "_" only (max 40 chars).';
+            }
+            return undefined;
+        },
+    });
+    if (isCancel(answer)) {
+        throw new CancelCliError("Login cancelled.");
+    }
+    return answer;
+}
+async function resolveApiKey(flag) {
+    if (flag !== undefined) {
+        if (flag.length === 0) {
+            throw new AuthCliError("--api-key cannot be empty.");
+        }
+        return flag;
+    }
+    const answer = await password({
+        message: "API key",
+        validate: (value) => {
+            if (!value || value.length === 0) {
+                return "API key is required.";
+            }
+            return undefined;
+        },
+    });
+    if (isCancel(answer)) {
+        throw new CancelCliError("Login cancelled.");
+    }
+    return answer;
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerLogout(program: Command): void;

package/dist/commands/logout.js

@@ -0,0 +1,38 @@
+import { removeProfile } from "../config/profiles.js";
+import { readConfig, writeConfig } from "../config/store.js";
+import { confirmDestructive } from "./shared/confirm.js";
+export function registerLogout(program) {
+    program
+        .command("logout")
+        .description("Remove a stored profile (default: the default one)")
+        .option("--name <profile>", "profile to remove (defaults to the default profile)")
+        .option("-y, --yes", "skip the confirmation prompt")
+        .action(async (options) => {
+        await runLogout(options);
+    });
+}
+async function runLogout(options) {
+    const config = await readConfig();
+    const target = options.name ?? config.defaultProfile;
+    if (!target) {
+        console.log("No profile to remove — you are not logged in.");
+        return;
+    }
+    if (!(target in config.profiles)) {
+        console.log(`Profile "${target}" does not exist.`);
+        return;
+    }
+    await confirmDestructive({
+        message: `Remove profile "${target}"?`,
+        skip: options.yes ?? false,
+    });
+    const next = removeProfile(config, target);
+    await writeConfig(next);
+    console.log(`Removed profile "${target}".`);
+    if (next.defaultProfile && next.defaultProfile !== config.defaultProfile) {
+        console.log(`Default profile is now "${next.defaultProfile}".`);
+    }
+    else if (!next.defaultProfile) {
+        console.log("No profiles remaining.");
+    }
+}

package/dist/commands/profiles/index.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerProfiles(program: Command): void;

package/dist/commands/profiles/index.js

@@ -0,0 +1,13 @@
+import { registerList } from "./list.js";
+import { registerRemove } from "./remove.js";
+import { registerRename } from "./rename.js";
+import { registerUse } from "./use.js";
+export function registerProfiles(program) {
+    const profiles = program
+        .command("profiles")
+        .description("Manage stored API-key profiles");
+    registerList(profiles);
+    registerUse(profiles);
+    registerRename(profiles);
+    registerRemove(profiles);
+}

package/dist/commands/profiles/list.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerList(profiles: Command): void;

package/dist/commands/profiles/list.js

@@ -0,0 +1,22 @@
+import { listProfiles } from "../../config/profiles.js";
+import { readConfig } from "../../config/store.js";
+import { renderProfileJson, renderProfileTable } from "./render-list.js";
+export function registerList(profiles) {
+    profiles
+        .command("list", { isDefault: true })
+        .description("List stored profiles; mark the default one with ▶")
+        .option("--json", "output raw JSON")
+        .action(async (options) => {
+        const config = await readConfig();
+        const items = listProfiles(config);
+        if (options.json) {
+            console.log(renderProfileJson(items));
+            return;
+        }
+        if (items.length === 0) {
+            console.log("No profiles stored. Run `duvo login` to add one.");
+            return;
+        }
+        console.log(renderProfileTable(items));
+    });
+}

package/dist/commands/profiles/remove.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerRemove(profiles: Command): void;

package/dist/commands/profiles/remove.js

@@ -0,0 +1,30 @@
+import { removeProfile } from "../../config/profiles.js";
+import { readConfig, writeConfig } from "../../config/store.js";
+import { confirmDestructive } from "../shared/confirm.js";
+export function registerRemove(profiles) {
+    profiles
+        .command("remove <name>")
+        .description("Remove a stored profile (alias of `duvo logout --name`)")
+        .option("-y, --yes", "skip the confirmation prompt")
+        .action(async (name, options) => {
+        const config = await readConfig();
+        if (!(name in config.profiles)) {
+            console.log(`Profile "${name}" does not exist.`);
+            return;
+        }
+        await confirmDestructive({
+            message: `Remove profile "${name}"?`,
+            skip: options.yes ?? false,
+        });
+        const next = removeProfile(config, name);
+        await writeConfig(next);
+        console.log(`Removed profile "${name}".`);
+        if (next.defaultProfile &&
+            next.defaultProfile !== config.defaultProfile) {
+            console.log(`Default profile is now "${next.defaultProfile}".`);
+        }
+        else if (!next.defaultProfile) {
+            console.log("No profiles remaining.");
+        }
+    });
+}

package/dist/commands/profiles/rename.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerRename(profiles: Command): void;

package/dist/commands/profiles/rename.js

@@ -0,0 +1,20 @@
+import { renameProfile } from "../../config/profiles.js";
+import { readConfig, writeConfig } from "../../config/store.js";
+import { CliError, EXIT_CODE } from "../../errors.js";
+export function registerRename(profiles) {
+    profiles
+        .command("rename <old> <new>")
+        .description("Rename a stored profile, preserving its credentials")
+        .action(async (oldName, newName) => {
+        const config = await readConfig();
+        try {
+            const next = renameProfile(config, oldName, newName);
+            await writeConfig(next);
+            console.log(`Renamed profile "${oldName}" to "${newName}".`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new CliError(message, EXIT_CODE.GENERIC);
+        }
+    });
+}

package/dist/commands/profiles/render-list.d.ts

@@ -0,0 +1,12 @@
+import { type ProfileSummary } from "../../config/profiles.js";
+/**
+ * Format the profile list as an aligned text table. Header sits behind
+ * two spaces so it lines up with the single-char marker + space that
+ * prefixes each data row.
+ */
+export declare function renderProfileTable(items: readonly ProfileSummary[]): string;
+/**
+ * JSON output mirrors the text view's masked keys — never emit raw
+ * credentials from a listing command.
+ */
+export declare function renderProfileJson(items: readonly ProfileSummary[]): string;

package/dist/commands/profiles/render-list.js

@@ -0,0 +1,37 @@
+import { padRight, truncateApiKey } from "../../output/format.js";
+const DEFAULT_MARKER = "▶";
+const NON_DEFAULT_MARKER = " ";
+function toRow(item) {
+    return {
+        marker: item.isDefault ? DEFAULT_MARKER : NON_DEFAULT_MARKER,
+        name: item.name,
+        apiKey: truncateApiKey(item.apiKey),
+        apiBaseUrl: item.apiBaseUrl,
+    };
+}
+/**
+ * Format the profile list as an aligned text table. Header sits behind
+ * two spaces so it lines up with the single-char marker + space that
+ * prefixes each data row.
+ */
+export function renderProfileTable(items) {
+    const rows = items.map(toRow);
+    const nameWidth = Math.max(4, ...rows.map((r) => r.name.length));
+    const keyWidth = Math.max(7, ...rows.map((r) => r.apiKey.length));
+    const lines = [];
+    lines.push(`  ${padRight("NAME", nameWidth)}  ${padRight("KEY", keyWidth)}  BASE URL`);
+    for (const row of rows) {
+        lines.push(`${row.marker} ${padRight(row.name, nameWidth)}  ${padRight(row.apiKey, keyWidth)}  ${row.apiBaseUrl}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * JSON output mirrors the text view's masked keys — never emit raw
+ * credentials from a listing command.
+ */
+export function renderProfileJson(items) {
+    const masked = items.map((item) => {
+        return { ...item, apiKey: truncateApiKey(item.apiKey) };
+    });
+    return JSON.stringify(masked, null, 2);
+}

package/dist/commands/profiles/use.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerUse(profiles: Command): void;

package/dist/commands/profiles/use.js

@@ -0,0 +1,17 @@
+import { setDefaultProfile } from "../../config/profiles.js";
+import { readConfig, writeConfig } from "../../config/store.js";
+import { AuthCliError } from "../../errors.js";
+export function registerUse(profiles) {
+    profiles
+        .command("use <name>")
+        .description("Switch the default profile")
+        .action(async (name) => {
+        const config = await readConfig();
+        if (!(name in config.profiles)) {
+            throw new AuthCliError(`Profile "${name}" does not exist. Run \`duvo profiles list\` to see available profiles.`);
+        }
+        const next = setDefaultProfile(config, name);
+        await writeConfig(next);
+        console.log(`Default profile is now "${name}".`);
+    });
+}

package/dist/commands/shared/confirm.d.ts

@@ -0,0 +1,19 @@
+type ConfirmOptions = {
+    /** Question shown to the user, e.g. `Remove profile "acme"?`. */
+    message: string;
+    /** Caller already collected consent (e.g. via `--yes`). */
+    skip: boolean;
+};
+/**
+ * Prompt for [y/N] confirmation on a destructive action. Skipped when
+ * the caller passes `skip: true` (typically from a `--yes` flag).
+ *
+ * In non-interactive shells (no TTY on stdin) we refuse rather than
+ * silently treat piped input as consent. The caller must opt in via
+ * `--yes` to proceed without a prompt.
+ *
+ * Throws instead of calling `process.exit` so the top-level error
+ * handler remains the single chokepoint for process termination.
+ */
+export declare function confirmDestructive(options: ConfirmOptions): Promise<void>;
+export {};

package/dist/commands/shared/confirm.js

@@ -0,0 +1,28 @@
+import { confirm, isCancel } from "@clack/prompts";
+import { CancelCliError, CliError } from "../../errors.js";
+/**
+ * Prompt for [y/N] confirmation on a destructive action. Skipped when
+ * the caller passes `skip: true` (typically from a `--yes` flag).
+ *
+ * In non-interactive shells (no TTY on stdin) we refuse rather than
+ * silently treat piped input as consent. The caller must opt in via
+ * `--yes` to proceed without a prompt.
+ *
+ * Throws instead of calling `process.exit` so the top-level error
+ * handler remains the single chokepoint for process termination.
+ */
+export async function confirmDestructive(options) {
+    if (options.skip) {
+        return;
+    }
+    if (!process.stdin.isTTY) {
+        throw new CliError(`${options.message} Pass --yes to confirm without an interactive prompt.`);
+    }
+    const answer = await confirm({
+        message: options.message,
+        initialValue: false,
+    });
+    if (isCancel(answer) || !answer) {
+        throw new CancelCliError();
+    }
+}

package/dist/commands/shared/pagination.d.ts

@@ -0,0 +1,8 @@
+type ParseLimitOptions = {
+    defaultValue: number;
+    min: number;
+    max: number;
+};
+export declare function parseLimit(raw: string | undefined, { defaultValue, min, max }: ParseLimitOptions): number;
+export declare function parseOffset(raw: string | undefined): number;
+export {};

package/dist/commands/shared/pagination.js

@@ -0,0 +1,24 @@
+import { CliError } from "../../errors.js";
+const POSITIVE_INT = /^\d+$/;
+export function parseLimit(raw, { defaultValue, min, max }) {
+    if (raw === undefined) {
+        return defaultValue;
+    }
+    if (!POSITIVE_INT.test(raw)) {
+        throw new CliError(`--limit must be an integer between ${min} and ${max}`);
+    }
+    const n = Number(raw);
+    if (n < min || n > max) {
+        throw new CliError(`--limit must be an integer between ${min} and ${max}`);
+    }
+    return n;
+}
+export function parseOffset(raw) {
+    if (raw === undefined) {
+        return 0;
+    }
+    if (!POSITIVE_INT.test(raw)) {
+        throw new CliError("--offset must be a non-negative integer");
+    }
+    return Number(raw);
+}

package/dist/commands/shared/profile-flag.d.ts

@@ -0,0 +1,8 @@
+import { type Command } from "commander";
+/**
+ * Pulls the global `--profile` option off the root command. Commander
+ * merges parent options into `opts()` for subcommands, but the value
+ * lives on the root — this helper walks up to find it regardless of how
+ * deep the subcommand sits.
+ */
+export declare function getProfileFlag(command: Command): string | undefined;

package/dist/commands/shared/profile-flag.js

@@ -0,0 +1,17 @@
+/**
+ * Pulls the global `--profile` option off the root command. Commander
+ * merges parent options into `opts()` for subcommands, but the value
+ * lives on the root — this helper walks up to find it regardless of how
+ * deep the subcommand sits.
+ */
+export function getProfileFlag(command) {
+    let node = command;
+    while (node) {
+        const opts = node.opts();
+        if (opts.profile) {
+            return opts.profile;
+        }
+        node = node.parent ?? null;
+    }
+    return undefined;
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from "commander";
+export declare function registerWhoami(program: Command): void;

package/dist/commands/whoami.js

@@ -0,0 +1,21 @@
+import { resolveConfig } from "../config/resolve.js";
+import { AuthCliError } from "../errors.js";
+import { truncateApiKey } from "../output/format.js";
+import { getProfileFlag } from "./shared/profile-flag.js";
+export function registerWhoami(program) {
+    program
+        .command("whoami")
+        .description("Print the default profile, truncated API key, and base URL")
+        .action(async function whoamiAction() {
+        const resolved = await resolveConfig({
+            profileFlag: getProfileFlag(this),
+        });
+        if (!resolved.apiKey) {
+            throw new AuthCliError("Not logged in. Run `duvo login` to save an API key.");
+        }
+        const profileLabel = resolved.profileName ?? "(env-only, no stored profile)";
+        console.log(`Profile  ${profileLabel}`);
+        console.log(`API key  ${truncateApiKey(resolved.apiKey)}`);
+        console.log(`Base URL ${resolved.apiBaseUrl}`);
+    });
+}

package/dist/config/defaults.d.ts

@@ -0,0 +1,3 @@
+import { type Config } from "../config/types.js";
+export declare const DEFAULT_API_BASE_URL = "https://api.duvo.ai";
+export declare function emptyConfig(): Config;

package/dist/config/defaults.js

@@ -0,0 +1,4 @@
+export const DEFAULT_API_BASE_URL = "https://api.duvo.ai";
+export function emptyConfig() {
+    return { defaultProfile: null, profiles: {} };
+}

package/dist/config/env.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+declare const CliEnvSchema: z.ZodObject<{
+    DUVO_PROFILE: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    DUVO_API_KEY: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    DUVO_API_BASE_URL: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+}, "strip", z.ZodTypeAny, {
+    DUVO_PROFILE?: string | undefined;
+    DUVO_API_KEY?: string | undefined;
+    DUVO_API_BASE_URL?: string | undefined;
+}, {
+    DUVO_PROFILE?: string | undefined;
+    DUVO_API_KEY?: string | undefined;
+    DUVO_API_BASE_URL?: string | undefined;
+}>;
+export type CliEnv = z.output<typeof CliEnvSchema>;
+export declare function parseCliEnv(env: NodeJS.ProcessEnv): CliEnv;
+export {};

package/dist/config/env.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+const optionalEnvString = z
+    .string()
+    .optional()
+    .transform((value) => value === undefined || value === "" ? undefined : value);
+const CliEnvSchema = z.object({
+    DUVO_PROFILE: optionalEnvString,
+    DUVO_API_KEY: optionalEnvString,
+    DUVO_API_BASE_URL: optionalEnvString,
+});
+export function parseCliEnv(env) {
+    return CliEnvSchema.parse(env);
+}

package/dist/config/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function getConfigDir(): string;
+export declare function getConfigPath(): string;

package/dist/config/paths.js

@@ -0,0 +1,14 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CONFIG_DIR_NAME = "duvo";
+const CONFIG_FILE_NAME = "config.json";
+export function getConfigDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    if (xdg && xdg.length > 0) {
+        return join(xdg, CONFIG_DIR_NAME);
+    }
+    return join(homedir(), ".config", CONFIG_DIR_NAME);
+}
+export function getConfigPath() {
+    return join(getConfigDir(), CONFIG_FILE_NAME);
+}

package/dist/config/profiles.d.ts

@@ -0,0 +1,24 @@
+import { type Config, type Profile } from "../config/types.js";
+export declare function isValidProfileName(name: string): boolean;
+export declare function assertValidProfileName(name: string): void;
+/**
+ * Add (or replace) a profile. The first profile added becomes the
+ * default automatically. Returns the updated config without mutating
+ * the input.
+ */
+export declare function addProfile(config: Config, name: string, profile: Profile): Config;
+/**
+ * Remove a profile. If the removed profile was the default, picks
+ * another profile alphabetically as the new default, or clears it if
+ * none remain.
+ */
+export declare function removeProfile(config: Config, name: string): Config;
+export declare function renameProfile(config: Config, oldName: string, newName: string): Config;
+export declare function setDefaultProfile(config: Config, name: string): Config;
+export type ProfileSummary = {
+    name: string;
+    apiKey: string;
+    apiBaseUrl: string;
+    isDefault: boolean;
+};
+export declare function listProfiles(config: Config): readonly ProfileSummary[];