@eve-horizon/cli 0.0.1

package/dist/commands/workflow.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWorkflow = handleWorkflow;
+const args_1 = require("../lib/args");
+const client_1 = require("../lib/client");
+const output_1 = require("../lib/output");
+async function handleWorkflow(subcommand, positionals, flags, context) {
+    const json = Boolean(flags.json);
+    switch (subcommand) {
+        case 'list':
+            return handleList(positionals, flags, context, json);
+        case 'show':
+            return handleShow(positionals, flags, context, json);
+        case 'run':
+            return handleRun(positionals, flags, context, json);
+        case 'invoke':
+            return handleInvoke(positionals, flags, context, json);
+        case 'logs':
+            return handleLogs(positionals, flags, context, json);
+        default:
+            throw new Error('Usage: eve workflow <list|show|run|invoke|logs>\n' +
+                '  list [project]                         - list workflows for a project\n' +
+                '  show <project> <name>                  - show workflow definition\n' +
+                '  run [project] <workflow-name>          - fire-and-forget workflow invocation\n' +
+                '                                           Options: --input <json>\n' +
+                '  invoke [project] <workflow-name>       - invoke workflow and wait for result\n' +
+                '                                           Options: --input <json>, --no-wait\n' +
+                '  logs <job-id>                          - show logs for a workflow job');
+    }
+}
+async function handleList(positionals, flags, context, json) {
+    const projectId = positionals[0] ?? (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
+    if (!projectId) {
+        throw new Error('Usage: eve workflow list [project] [--project=<id>]');
+    }
+    const response = await (0, client_1.requestJson)(context, `/projects/${projectId}/workflows`);
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+        return;
+    }
+    if (response.data.length === 0) {
+        console.log('No workflows found.');
+        return;
+    }
+    formatWorkflows(response.data);
+}
+async function handleShow(positionals, flags, context, json) {
+    const projectId = positionals[0] ?? (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
+    const name = positionals[1] ?? (0, args_1.getStringFlag)(flags, ['name']);
+    if (!projectId || !name) {
+        throw new Error('Usage: eve workflow show <project> <name> [--project=<id>] [--name=<name>]');
+    }
+    const response = await (0, client_1.requestJson)(context, `/projects/${projectId}/workflows/${name}`);
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+        return;
+    }
+    formatWorkflow(response);
+}
+function formatWorkflows(workflows) {
+    console.log('Workflows:');
+    for (const workflow of workflows) {
+        const stepCount = Array.isArray(workflow.definition?.steps)
+            ? workflow.definition.steps.length
+            : null;
+        const suffix = stepCount === null ? '' : ` (${stepCount} steps)`;
+        console.log(`- ${workflow.name}${suffix}`);
+    }
+}
+function formatWorkflow(workflow) {
+    console.log(`Workflow: ${workflow.name}`);
+    console.log('Definition:');
+    console.log(JSON.stringify(workflow.definition, null, 2));
+}
+/**
+ * eve workflow run [project] <workflow-name> [--input=<json>]
+ * Fire-and-forget workflow invocation (no waiting)
+ */
+async function handleRun(positionals, flags, context, json) {
+    let projectId;
+    let workflowName;
+    // Parse positionals: either "workflow-name" or "project workflow-name"
+    if (positionals.length === 1) {
+        projectId = (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
+        workflowName = positionals[0];
+    }
+    else if (positionals.length >= 2) {
+        projectId = positionals[0];
+        workflowName = positionals[1];
+    }
+    else {
+        projectId = (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
+        workflowName = (0, args_1.getStringFlag)(flags, ['workflow', 'name']);
+    }
+    if (!projectId || !workflowName) {
+        throw new Error('Usage: eve workflow run [project] <workflow-name> [--input=<json>]');
+    }
+    // Parse input JSON
+    const inputRaw = (0, args_1.getStringFlag)(flags, ['input', 'i']);
+    let input;
+    if (inputRaw) {
+        try {
+            input = JSON.parse(inputRaw);
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON for --input: ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+    }
+    // Call invoke endpoint with wait=false
+    const response = await (0, client_1.requestJson)(context, `/projects/${projectId}/workflows/${workflowName}/invoke?wait=false`, {
+        method: 'POST',
+        body: input ?? {},
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+        return;
+    }
+    console.log(`Workflow invoked: ${workflowName}`);
+    console.log(`  Job ID:  ${response.job_id}`);
+    console.log(`  Status:  ${response.status}`);
+    console.log('');
+    console.log(`Use 'eve workflow logs ${response.job_id}' to view logs`);
+}
+/**
+ * eve workflow invoke [project] <workflow-name> [--input=<json>] [--no-wait]
+ * Invoke workflow and wait for result (default behavior)
+ */
+async function handleInvoke(positionals, flags, context, json) {
+    let projectId;
+    let workflowName;
+    // Parse positionals: either "workflow-name" or "project workflow-name"
+    if (positionals.length === 1) {
+        projectId = (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
+        workflowName = positionals[0];
+    }
+    else if (positionals.length >= 2) {
+        projectId = positionals[0];
+        workflowName = positionals[1];
+    }
+    else {
+        projectId = (0, args_1.getStringFlag)(flags, ['project']) ?? context.projectId;
+        workflowName = (0, args_1.getStringFlag)(flags, ['workflow', 'name']);
+    }
+    if (!projectId || !workflowName) {
+        throw new Error('Usage: eve workflow invoke [project] <workflow-name> [--input=<json>] [--no-wait]');
+    }
+    // Parse input JSON
+    const inputRaw = (0, args_1.getStringFlag)(flags, ['input', 'i']);
+    let input;
+    if (inputRaw) {
+        try {
+            input = JSON.parse(inputRaw);
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON for --input: ${error instanceof Error ? error.message : 'unknown error'}`);
+        }
+    }
+    // Check if --no-wait is set (inverse logic: wait by default)
+    const wait = !flags['no-wait'];
+    // Call invoke endpoint
+    const response = await (0, client_1.requestJson)(context, `/projects/${projectId}/workflows/${workflowName}/invoke?wait=${wait}`, {
+        method: 'POST',
+        body: input ?? {},
+    });
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+        return;
+    }
+    console.log(`Workflow invoked: ${workflowName}`);
+    console.log(`  Job ID:  ${response.job_id}`);
+    console.log(`  Status:  ${response.status}`);
+    if (response.result !== undefined) {
+        console.log('');
+        console.log('Result:');
+        if (typeof response.result === 'string') {
+            console.log(response.result);
+        }
+        else {
+            console.log(JSON.stringify(response.result, null, 2));
+        }
+    }
+    else if (!wait) {
+        console.log('');
+        console.log(`Use 'eve workflow logs ${response.job_id}' to view logs`);
+    }
+}
+/**
+ * eve workflow logs <job-id> [--attempt=N] [--after=N]
+ * Show logs for a workflow job
+ */
+async function handleLogs(positionals, flags, context, json) {
+    const jobId = positionals[0];
+    if (!jobId) {
+        throw new Error('Usage: eve workflow logs <job-id> [--attempt=N] [--after=N]');
+    }
+    // Get attempt number (default to latest)
+    const attemptStr = (0, args_1.getStringFlag)(flags, ['attempt']);
+    let attemptNum;
+    if (attemptStr) {
+        attemptNum = parseInt(attemptStr, 10);
+    }
+    else {
+        // Find the latest attempt
+        const attemptsResponse = await (0, client_1.requestJson)(context, `/jobs/${jobId}/attempts`);
+        if (attemptsResponse.attempts.length === 0) {
+            console.log('No attempts found for this job.');
+            return;
+        }
+        attemptNum = Math.max(...attemptsResponse.attempts.map(a => a.attempt_number));
+    }
+    const afterStr = (0, args_1.getStringFlag)(flags, ['after']);
+    const afterQuery = afterStr ? `?after=${afterStr}` : '';
+    const response = await (0, client_1.requestJson)(context, `/jobs/${jobId}/attempts/${attemptNum}/logs${afterQuery}`);
+    if (json) {
+        (0, output_1.outputJson)(response, json);
+        return;
+    }
+    if (response.logs.length === 0) {
+        console.log(`No logs found for attempt #${attemptNum}.`);
+        return;
+    }
+    console.log(`Logs for job ${jobId}, attempt #${attemptNum}:`);
+    console.log('');
+    for (const log of response.logs) {
+        formatLogEntry(log);
+    }
+    console.log('');
+    console.log(`Total: ${response.logs.length} log entries`);
+}
+/**
+ * Format a single log entry for display
+ */
+function formatLogEntry(log) {
+    const line = log.line;
+    const timestamp = new Date(log.timestamp).toLocaleTimeString();
+    // Common log line formats from harnesses
+    const type = log.type || line.type || 'log';
+    // If type starts with 'lifecycle_', format as lifecycle event
+    if (type.startsWith('lifecycle_')) {
+        const content = line;
+        const phase = content.phase || 'unknown';
+        const action = content.action || 'unknown';
+        const duration = content.duration_ms;
+        const success = content.success;
+        const error = content.error;
+        const meta = content.meta || {};
+        if (action === 'start') {
+            const detail = formatLifecycleMeta(phase, meta);
+            console.log(`[${timestamp}] ${getLifecycleIcon(phase)} Starting ${phase}${detail}...`);
+        }
+        else if (action === 'end') {
+            const durationStr = duration ? ` (${duration}ms)` : '';
+            if (success === false && error) {
+                console.log(`[${timestamp}] ${getLifecycleIcon(phase)} ${capitalize(phase)} failed${durationStr}: ${error}`);
+            }
+            else {
+                console.log(`[${timestamp}] ${getLifecycleIcon(phase)} ${capitalize(phase)} completed${durationStr}`);
+            }
+        }
+        else if (action === 'log') {
+            const msg = meta.message || JSON.stringify(meta);
+            console.log(`[${timestamp}]   > ${msg}`);
+        }
+        return;
+    }
+    const message = line.message || line.text || '';
+    const tool = line.tool;
+    const toolInput = line.tool_input;
+    const toolResult = line.tool_result;
+    // Format based on log type
+    switch (type) {
+        case 'assistant':
+        case 'text':
+            console.log(`[${timestamp}] ${message || JSON.stringify(line)}`);
+            break;
+        case 'tool_use':
+            console.log(`[${timestamp}] Tool: ${tool || 'tool'}: ${toolInput || JSON.stringify(line)}`);
+            break;
+        case 'tool_result':
+            const resultPreview = (toolResult || '').substring(0, 100);
+            console.log(`[${timestamp}]    → ${resultPreview}${(toolResult?.length || 0) > 100 ? '...' : ''}`);
+            break;
+        case 'error':
+            console.log(`[${timestamp}] Error: ${message || JSON.stringify(line)}`);
+            break;
+        case 'status':
+            console.log(`[${timestamp}] ${message || JSON.stringify(line)}`);
+            break;
+        default:
+            // Generic JSON output for unknown types
+            console.log(`[${timestamp}] ${JSON.stringify(line)}`);
+    }
+}
+/**
+ * Get icon for lifecycle phase
+ */
+function getLifecycleIcon(phase) {
+    switch (phase) {
+        case 'workspace': return '📁';
+        case 'hook': return '🪝';
+        case 'secrets': return '🔐';
+        case 'services': return '🐳';
+        case 'harness': return '🤖';
+        case 'runner': return '☸️';
+        default: return '⚙️';
+    }
+}
+/**
+ * Capitalize first letter of string
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Format lifecycle metadata for display
+ */
+function formatLifecycleMeta(phase, meta) {
+    switch (phase) {
+        case 'workspace':
+            const repoUrl = meta.repo_url || '';
+            const branch = meta.branch || '';
+            return branch ? ` (${repoUrl}@${branch})` : repoUrl ? ` (${repoUrl})` : '';
+        case 'hook':
+            return meta.hook_name ? ` "${meta.hook_name}"` : '';
+        case 'secrets':
+            return '';
+        case 'services':
+            const svcName = meta.service_name || '';
+            return svcName ? ` "${svcName}"` : '';
+        case 'harness':
+            return meta.harness ? ` ${meta.harness}` : '';
+        case 'runner':
+            return meta.pod_name ? ` (${meta.pod_name})` : '';
+        default:
+            return '';
+    }
+}

package/dist/index.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const args_1 = require("./lib/args");
+const config_1 = require("./lib/config");
+const context_1 = require("./lib/context");
+const help_1 = require("./lib/help");
+const org_1 = require("./commands/org");
+const project_1 = require("./commands/project");
+const job_1 = require("./commands/job");
+const profile_1 = require("./commands/profile");
+const auth_1 = require("./commands/auth");
+const harness_1 = require("./commands/harness");
+const secrets_1 = require("./commands/secrets");
+const system_1 = require("./commands/system");
+const env_1 = require("./commands/env");
+const pipeline_1 = require("./commands/pipeline");
+const workflow_1 = require("./commands/workflow");
+const api_1 = require("./commands/api");
+const db_1 = require("./commands/db");
+const event_1 = require("./commands/event");
+async function main() {
+    const { flags, positionals } = (0, args_1.parseArgs)(process.argv.slice(2));
+    const command = positionals[0];
+    const subcommand = positionals[1];
+    const rest = positionals.slice(2);
+    // Top-level help: no command or explicit --help without command
+    if (!command || command === '-h' || command === '--help') {
+        (0, help_1.showMainHelp)();
+        return;
+    }
+    // Command-level help: "eve profile --help" or "eve profile" with no subcommand
+    // flags.help means --help appeared somewhere; without subcommand = command help
+    if (flags.help && !subcommand) {
+        (0, help_1.showCommandHelp)(command);
+        return;
+    }
+    // Subcommand-level help: "eve profile set --help"
+    if (flags.help && subcommand) {
+        (0, help_1.showSubcommandHelp)(command, subcommand);
+        return;
+    }
+    const config = (0, config_1.loadConfig)();
+    const credentials = (0, config_1.loadCredentials)();
+    const context = (0, context_1.resolveContext)(flags, config, credentials);
+    switch (command) {
+        case 'org':
+            await (0, org_1.handleOrg)(subcommand, rest, flags, context);
+            return;
+        case 'project':
+            await (0, project_1.handleProject)(subcommand, rest, flags, context);
+            return;
+        case 'job':
+            await (0, job_1.handleJob)(subcommand, rest, flags, context);
+            return;
+        case 'profile':
+            (0, profile_1.handleProfile)(subcommand, rest, flags, config);
+            return;
+        case 'auth':
+            await (0, auth_1.handleAuth)(subcommand, flags, context, credentials);
+            return;
+        case 'harness':
+            await (0, harness_1.handleHarness)(subcommand, rest, flags, context);
+            return;
+        case 'secrets':
+            await (0, secrets_1.handleSecrets)(subcommand, rest, flags, context);
+            return;
+        case 'system':
+            await (0, system_1.handleSystem)(subcommand, rest, flags, context);
+            return;
+        case 'env':
+            await (0, env_1.handleEnv)(subcommand, rest, flags, context);
+            return;
+        case 'pipeline':
+            await (0, pipeline_1.handlePipeline)(subcommand, rest, flags, context);
+            return;
+        case 'workflow':
+            await (0, workflow_1.handleWorkflow)(subcommand, rest, flags, context);
+            return;
+        case 'api':
+            await (0, api_1.handleApi)(subcommand, rest, flags, context);
+            return;
+        case 'db':
+            await (0, db_1.handleDb)(subcommand, rest, flags, context);
+            return;
+        case 'event':
+            await (0, event_1.handleEvent)(subcommand, rest, flags, context);
+            return;
+        default:
+            (0, help_1.showMainHelp)();
+    }
+}
+main().catch((error) => {
+    // eslint-disable-next-line no-console
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/lib/args.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.toBoolean = toBoolean;
+exports.getStringFlag = getStringFlag;
+exports.getBooleanFlag = getBooleanFlag;
+function parseArgs(args) {
+    const flags = {};
+    const positionals = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const trimmed = arg.slice(2);
+            const eqIndex = trimmed.indexOf('=');
+            if (eqIndex >= 0) {
+                const key = trimmed.slice(0, eqIndex);
+                const value = trimmed.slice(eqIndex + 1);
+                flags[key] = value;
+                continue;
+            }
+            const next = args[i + 1];
+            if (next && !next.startsWith('--')) {
+                flags[trimmed] = next;
+                i += 1;
+                continue;
+            }
+            flags[trimmed] = true;
+        }
+        else {
+            positionals.push(arg);
+        }
+    }
+    return { flags, positionals };
+}
+function toBoolean(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'boolean')
+        return value;
+    return ['true', '1', 'yes', 'y', 'on'].includes(value.toLowerCase());
+}
+function getStringFlag(flags, keys) {
+    for (const key of keys) {
+        const value = flags[key];
+        if (typeof value === 'string')
+            return value;
+    }
+    return undefined;
+}
+function getBooleanFlag(flags, keys) {
+    for (const key of keys) {
+        if (flags[key] !== undefined) {
+            return toBoolean(flags[key]);
+        }
+    }
+    return undefined;
+}

package/dist/lib/client.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestJson = requestJson;
+exports.requestRaw = requestRaw;
+const config_1 = require("./config");
+async function requestJson(context, path, options = {}) {
+    const response = await requestRaw(context, path, options);
+    if (response.status === 401 && options.tokenOverride === undefined) {
+        const refreshed = await attemptRefresh(context);
+        if (refreshed?.access_token) {
+            context.token = refreshed.access_token;
+            context.refreshToken = refreshed.refresh_token;
+            context.expiresAt = refreshed.expires_at;
+            const retry = await requestRaw(context, path, {
+                ...options,
+                tokenOverride: refreshed.access_token,
+            });
+            if (!retry.ok && !options.allowError) {
+                const message = typeof retry.data === 'string' ? retry.data : retry.text;
+                throw new Error(`HTTP ${retry.status}: ${message}`);
+            }
+            return retry.data;
+        }
+    }
+    if (!response.ok && !options.allowError) {
+        const message = typeof response.data === 'string' ? response.data : response.text;
+        // Check for "Project not found" error and provide actionable guidance
+        if ((response.status === 404 || response.status === 500) && message.includes('Project not found')) {
+            const projectIdMatch = message.match(/Project not found: (proj_[a-z0-9]+)/);
+            const projectId = projectIdMatch?.[1] ?? 'unknown';
+            throw new Error(`Project not found: ${projectId}\n\n` +
+                `The configured project_id does not exist in the connected Eve API.\n` +
+                `This often happens when connecting to a different environment (e.g., K8s vs local).\n\n` +
+                `To fix this, either:\n` +
+                `  1. Clear the default project: eve profile set --project=""\n` +
+                `  2. Set a valid project: eve profile set --project=<valid-project-id>\n` +
+                `  3. Specify project per-command: eve job create --project=<id> ...\n\n` +
+                `To list available projects: eve project list`);
+        }
+        throw new Error(`HTTP ${response.status}: ${message}`);
+    }
+    return response.data;
+}
+async function requestRaw(context, path, options = {}) {
+    const headers = {
+        ...options.headers,
+    };
+    if (options.body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const token = options.tokenOverride ?? context.token;
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    const response = await fetch(`${context.apiUrl}${path}`, {
+        method: options.method ?? 'GET',
+        headers,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+    });
+    const text = await response.text();
+    let data = null;
+    if (text) {
+        try {
+            data = JSON.parse(text);
+        }
+        catch {
+            data = text;
+        }
+    }
+    return { status: response.status, ok: response.ok, data, text };
+}
+async function attemptRefresh(context) {
+    if (!context.refreshToken)
+        return undefined;
+    if (!context.profile.supabase_url || !context.profile.supabase_anon_key)
+        return undefined;
+    const refreshResponse = await fetch(`${context.profile.supabase_url}/auth/v1/token?grant_type=refresh_token`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            apikey: context.profile.supabase_anon_key,
+            Authorization: `Bearer ${context.profile.supabase_anon_key}`,
+        },
+        body: JSON.stringify({ refresh_token: context.refreshToken }),
+    });
+    const refreshText = await refreshResponse.text();
+    let refreshData = null;
+    if (refreshText) {
+        try {
+            refreshData = JSON.parse(refreshText);
+        }
+        catch {
+            refreshData = refreshText;
+        }
+    }
+    if (!refreshResponse.ok || !refreshData || typeof refreshData !== 'object') {
+        return undefined;
+    }
+    const payload = refreshData;
+    if (!payload.access_token) {
+        return undefined;
+    }
+    const expiresAt = payload.expires_in
+        ? Math.floor(Date.now() / 1000) + payload.expires_in
+        : undefined;
+    const nextToken = {
+        access_token: payload.access_token,
+        refresh_token: payload.refresh_token ?? context.refreshToken,
+        expires_at: expiresAt,
+        token_type: payload.token_type,
+    };
+    const credentials = (0, config_1.loadCredentials)();
+    credentials.profiles[context.profileName] = nextToken;
+    (0, config_1.saveCredentials)(credentials);
+    return nextToken;
+}

package/dist/lib/config.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.loadCredentials = loadCredentials;
+exports.saveCredentials = saveCredentials;
+exports.getDefaultProfileName = getDefaultProfileName;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const DEFAULT_PROFILE = 'default';
+const CONFIG_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), '.eve');
+const CONFIG_PATH = (0, node_path_1.join)(CONFIG_DIR, 'config.json');
+const CREDENTIALS_PATH = (0, node_path_1.join)(CONFIG_DIR, 'credentials.json');
+function ensureConfigDir() {
+    if (!(0, node_fs_1.existsSync)(CONFIG_DIR)) {
+        (0, node_fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    }
+}
+function readJsonFile(path, fallback) {
+    if (!(0, node_fs_1.existsSync)(path))
+        return fallback;
+    const raw = (0, node_fs_1.readFileSync)(path, 'utf8');
+    if (!raw.trim())
+        return fallback;
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${path}: ${error.message}`);
+    }
+}
+function writeJsonFile(path, value) {
+    ensureConfigDir();
+    (0, node_fs_1.writeFileSync)(path, JSON.stringify(value, null, 2));
+    try {
+        (0, node_fs_1.chmodSync)(path, 0o600);
+    }
+    catch {
+        // Best-effort for platforms that don't support chmod.
+    }
+}
+function loadConfig() {
+    const fallback = { active_profile: DEFAULT_PROFILE, profiles: { [DEFAULT_PROFILE]: {} } };
+    const config = readJsonFile(CONFIG_PATH, fallback);
+    config.profiles = config.profiles ?? {};
+    if (!config.active_profile) {
+        const [first] = Object.keys(config.profiles);
+        config.active_profile = first ?? DEFAULT_PROFILE;
+    }
+    if (!config.profiles[config.active_profile]) {
+        config.profiles[config.active_profile] = {};
+    }
+    return config;
+}
+function saveConfig(config) {
+    config.profiles = config.profiles ?? {};
+    if (!config.active_profile) {
+        const [first] = Object.keys(config.profiles);
+        config.active_profile = first ?? DEFAULT_PROFILE;
+    }
+    writeJsonFile(CONFIG_PATH, config);
+}
+function loadCredentials() {
+    const fallback = { profiles: {} };
+    const credentials = readJsonFile(CREDENTIALS_PATH, fallback);
+    credentials.profiles = credentials.profiles ?? {};
+    return credentials;
+}
+function saveCredentials(credentials) {
+    credentials.profiles = credentials.profiles ?? {};
+    writeJsonFile(CREDENTIALS_PATH, credentials);
+}
+function getDefaultProfileName(config) {
+    return config.active_profile ?? DEFAULT_PROFILE;
+}