hydra-os-cli 0.1.0

package/dist/commands/core.js

@@ -0,0 +1,79 @@
+/**
+ * Core commands: /help, /clear, /compact, /doctor
+ */
+import { registerCommand, getCommandsByCategory } from "./registry.js";
+export function registerCoreCommands() {
+    registerCommand({
+        name: "help",
+        description: "Show all commands",
+        usage: "/help",
+        category: "core",
+        handler: async ({ store }) => {
+            const categories = ["core", "workflow", "agent", "artifact", "memory", "config", "session"];
+            const lines = ["Available commands:\n"];
+            for (const cat of categories) {
+                const cmds = getCommandsByCategory(cat);
+                if (cmds.length === 0)
+                    continue;
+                lines.push(`  ${cat.toUpperCase()}`);
+                for (const cmd of cmds) {
+                    lines.push(`    /${cmd.name.padEnd(12)} ${cmd.description}`);
+                }
+                lines.push("");
+            }
+            lines.push("Keyboard shortcuts:");
+            lines.push("  Ctrl+P     Toggle side panels");
+            lines.push("  Ctrl+D     Exit");
+            store.addMessage({ role: "system", content: lines.join("\n") });
+        },
+    });
+    registerCommand({
+        name: "clear",
+        description: "Clear chat output",
+        usage: "/clear",
+        category: "core",
+        handler: async ({ store }) => {
+            store.clearMessages();
+        },
+    });
+    registerCommand({
+        name: "compact",
+        description: "Compress conversation context",
+        usage: "/compact [focus]",
+        category: "core",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Compact is not yet available (Phase 2)." });
+        },
+    });
+    registerCommand({
+        name: "doctor",
+        description: "Health check (Temporal, Qdrant, API, workers)",
+        usage: "/doctor",
+        category: "core",
+        handler: async ({ store, api }) => {
+            store.addMessage({ role: "system", content: "Running health checks..." });
+            try {
+                const health = await api.healthCheck();
+                const lines = ["Service health:"];
+                lines.push(`  API: ${health.status ?? "ok"}`);
+                if (health.version)
+                    lines.push(`  Version: ${health.version}`);
+                // Try to get agents to verify Temporal connectivity
+                try {
+                    const agentsResp = await api.getAgents();
+                    lines.push(`  Temporal: connected (${agentsResp.agents.length} roles)`);
+                }
+                catch {
+                    lines.push("  Temporal: unreachable");
+                }
+                store.addMessage({ role: "system", content: lines.join("\n") });
+                store.setApiStatus("connected");
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                store.addMessage({ role: "error", content: `Health check failed: ${msg}` });
+                store.setApiStatus("error");
+            }
+        },
+    });
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Register all slash commands.
+ */
+export declare function registerAllCommands(): void;
+export { getCommand, getAllCommands, getCompletions } from "./registry.js";
+export type { CommandContext, CommandDef } from "./registry.js";

package/dist/commands/index.js

@@ -0,0 +1,20 @@
+/**
+ * Register all slash commands.
+ */
+import { registerCoreCommands } from "./core.js";
+import { registerWorkflowCommands } from "./workflow.js";
+import { registerAgentCommands } from "./agent.js";
+import { registerArtifactCommands } from "./artifact.js";
+import { registerMemoryCommands } from "./memory.js";
+import { registerConfigCommands } from "./config.js";
+import { registerSessionCommands } from "./session.js";
+export function registerAllCommands() {
+    registerCoreCommands();
+    registerWorkflowCommands();
+    registerAgentCommands();
+    registerArtifactCommands();
+    registerMemoryCommands();
+    registerConfigCommands();
+    registerSessionCommands();
+}
+export { getCommand, getAllCommands, getCompletions } from "./registry.js";

package/dist/commands/memory.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Memory commands: /memory search|add|pin|forget, /decisions
+ */
+export declare function registerMemoryCommands(): void;

package/dist/commands/memory.js

@@ -0,0 +1,24 @@
+/**
+ * Memory commands: /memory search|add|pin|forget, /decisions
+ */
+import { registerCommand } from "./registry.js";
+export function registerMemoryCommands() {
+    registerCommand({
+        name: "memory",
+        description: "Search, add, pin, or forget memories",
+        usage: "/memory <search|add|pin|forget> <args>",
+        category: "memory",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Memory commands are not yet available (Phase 3)." });
+        },
+    });
+    registerCommand({
+        name: "decisions",
+        description: "Show decisions made in a workflow",
+        usage: "/decisions [workflow-id]",
+        category: "memory",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Decisions display is not yet available (Phase 3)." });
+        },
+    });
+}

package/dist/commands/registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Slash command registry.
+ * Central registry for all TUI commands with autocomplete support.
+ */
+import type { HydraStore } from "../store.js";
+import type { HydraApiClient } from "../clients/api.js";
+export interface CommandContext {
+    store: HydraStore;
+    api: HydraApiClient;
+    args: string[];
+}
+export interface CommandDef {
+    name: string;
+    description: string;
+    usage: string;
+    handler: (ctx: CommandContext) => Promise<void>;
+    category: "core" | "workflow" | "agent" | "artifact" | "memory" | "config" | "session";
+}
+export declare function registerCommand(def: CommandDef): void;
+export declare function getCommand(name: string): CommandDef | undefined;
+export declare function getAllCommands(): CommandDef[];
+export declare function getCommandsByCategory(category: CommandDef["category"]): CommandDef[];
+export declare function getCompletions(prefix: string): string[];

package/dist/commands/registry.js

@@ -0,0 +1,23 @@
+/**
+ * Slash command registry.
+ * Central registry for all TUI commands with autocomplete support.
+ */
+const commands = new Map();
+export function registerCommand(def) {
+    commands.set(def.name, def);
+}
+export function getCommand(name) {
+    return commands.get(name);
+}
+export function getAllCommands() {
+    return Array.from(commands.values());
+}
+export function getCommandsByCategory(category) {
+    return getAllCommands().filter((cmd) => cmd.category === category);
+}
+export function getCompletions(prefix) {
+    return getAllCommands()
+        .map((cmd) => `/${cmd.name}`)
+        .filter((name) => name.startsWith(prefix))
+        .sort();
+}

package/dist/commands/session.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Session commands: /session save|load|list|export
+ */
+export declare function registerSessionCommands(): void;

package/dist/commands/session.js

@@ -0,0 +1,15 @@
+/**
+ * Session commands: /session save|load|list|export
+ */
+import { registerCommand } from "./registry.js";
+export function registerSessionCommands() {
+    registerCommand({
+        name: "session",
+        description: "Save, load, list, or export sessions",
+        usage: "/session <save|load|list|export> [name]",
+        category: "session",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Session management is not yet available (Phase 4)." });
+        },
+    });
+}

package/dist/commands/workflow.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Workflow commands: /start, /status, /list, /approve, /deny, /correct,
+ * /pause, /resume, /cancel, /attach, /detach, /history
+ */
+export declare function registerWorkflowCommands(): void;

package/dist/commands/workflow.js

@@ -0,0 +1,301 @@
+/**
+ * Workflow commands: /start, /status, /list, /approve, /deny, /correct,
+ * /pause, /resume, /cancel, /attach, /detach, /history
+ */
+import { randomUUID } from "node:crypto";
+import { registerCommand } from "./registry.js";
+import { subscribeToWorkflow } from "../sse.js";
+function resolveWorkflowId(ctx) {
+    const fromArgs = ctx.args[0];
+    if (fromArgs)
+        return fromArgs;
+    const active = ctx.store.activeWorkflowId;
+    if (active)
+        return active;
+    ctx.store.addMessage({ role: "error", content: "No workflow ID specified and no active workflow. Usage: /<command> <workflow-id>" });
+    return null;
+}
+export function registerWorkflowCommands() {
+    registerCommand({
+        name: "start",
+        description: "Start a new workflow from natural language",
+        usage: "/start <description>",
+        category: "workflow",
+        handler: async ({ store, api, args }) => {
+            const description = args.join(" ").trim();
+            if (!description) {
+                store.addMessage({ role: "error", content: "Usage: /start <description>" });
+                return;
+            }
+            store.addMessage({ role: "system", content: `Starting workflow: ${description}` });
+            try {
+                const wfId = `wf-${randomUUID()}`;
+                const result = await api.startWorkflow("DynamicWorkflow", wfId, {
+                    idea: description,
+                });
+                store.setActiveWorkflowId(result.workflow_id);
+                store.addMessage({
+                    role: "agent",
+                    content: `Workflow started: ${result.workflow_id}\nRun ID: ${result.run_id}\nUse /status to check progress or /attach ${result.workflow_id} to stream live updates.`,
+                    agent: "orchestrator",
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                store.addMessage({ role: "error", content: `Failed to start workflow: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "status",
+        description: "Show workflow status (defaults to active)",
+        usage: "/status [workflow-id]",
+        category: "workflow",
+        handler: async (ctx) => {
+            const wfId = resolveWorkflowId(ctx);
+            if (!wfId)
+                return;
+            try {
+                const resp = await ctx.api.getWorkflowStatus(wfId);
+                const status = resp.status;
+                const lines = [`Workflow: ${wfId}`];
+                if (typeof status === "object" && status !== null) {
+                    const s = status;
+                    if (s.phase)
+                        lines.push(`Phase: ${s.phase}`);
+                    if (s.current_phase)
+                        lines.push(`Current phase: ${s.current_phase}`);
+                    if (s.waiting_for_approval)
+                        lines.push("** Waiting for approval **");
+                    if (s.total_cost != null)
+                        lines.push(`Cost: $${Number(s.total_cost).toFixed(4)}`);
+                    if (s.total_tokens != null)
+                        lines.push(`Tokens: ${s.total_tokens}`);
+                    const steps = s.steps;
+                    if (Array.isArray(steps) && steps.length > 0) {
+                        lines.push("\nSteps:");
+                        for (const step of steps) {
+                            const st = step;
+                            const icon = st.status === "completed" ? "  ✓" : st.status === "running" ? "  ⏳" : "  ○";
+                            lines.push(`${icon} ${st.role ?? st.name ?? "step"} [${st.status}]`);
+                        }
+                    }
+                    // Update agent panel
+                    if (Array.isArray(steps)) {
+                        ctx.store.setAgents(steps.map((st) => ({
+                            id: String(st.role ?? ""),
+                            role_id: String(st.role ?? ""),
+                            queue: String(st.role ?? ""),
+                            status: String(st.status === "completed" ? "idle" : st.status === "running" ? "active" : "idle"),
+                            model: "",
+                            active_sessions: st.status === "running" ? 1 : 0,
+                            total_tokens_used: Number(st.tokens ?? 0),
+                            current_workflow: st.status === "running" ? wfId : null,
+                            skill_packs: [],
+                        })));
+                    }
+                }
+                else {
+                    lines.push(`Status: ${JSON.stringify(status)}`);
+                }
+                ctx.store.addMessage({ role: "system", content: lines.join("\n") });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.store.addMessage({ role: "error", content: `Failed to get status: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "list",
+        description: "List all workflows",
+        usage: "/list",
+        category: "workflow",
+        handler: async ({ store, api }) => {
+            try {
+                const tasks = await api.listTasks({ limit: 20 });
+                if (tasks.length === 0) {
+                    store.addMessage({ role: "system", content: "No workflows found." });
+                    return;
+                }
+                store.setWorkflows(tasks);
+                const lines = ["Workflows:\n"];
+                lines.push("  ID                           | Status      | Type             | Step");
+                lines.push("  " + "-".repeat(80));
+                for (const t of tasks) {
+                    const id = t.workflow_id.slice(0, 28).padEnd(28);
+                    const status = (t.status ?? "unknown").padEnd(11);
+                    const type = (t.workflow_type ?? "").slice(0, 16).padEnd(16);
+                    const step = t.current_step ?? "";
+                    lines.push(`  ${id} | ${status} | ${type} | ${step}`);
+                }
+                store.addMessage({ role: "system", content: lines.join("\n") });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                store.addMessage({ role: "error", content: `Failed to list workflows: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "approve",
+        description: "Approve pending approval",
+        usage: "/approve [workflow-id]",
+        category: "workflow",
+        handler: async (ctx) => {
+            const wfId = resolveWorkflowId(ctx);
+            if (!wfId)
+                return;
+            try {
+                await ctx.api.approveWorkflow(wfId, "approved");
+                ctx.store.addMessage({ role: "system", content: `Approved workflow: ${wfId}` });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.store.addMessage({ role: "error", content: `Failed to approve: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "deny",
+        description: "Deny pending approval",
+        usage: "/deny [workflow-id]",
+        category: "workflow",
+        handler: async (ctx) => {
+            const wfId = resolveWorkflowId(ctx);
+            if (!wfId)
+                return;
+            const feedback = ctx.args.slice(1).join(" ") || undefined;
+            try {
+                await ctx.api.approveWorkflow(wfId, "denied", feedback);
+                ctx.store.addMessage({ role: "system", content: `Denied workflow: ${wfId}${feedback ? ` (feedback: ${feedback})` : ""}` });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.store.addMessage({ role: "error", content: `Failed to deny: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "correct",
+        description: "Send correction to current agent",
+        usage: "/correct <message>",
+        category: "workflow",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "Correct is not yet available (Phase 2)." });
+        },
+    });
+    registerCommand({
+        name: "pause",
+        description: "Pause a running workflow",
+        usage: "/pause [workflow-id]",
+        category: "workflow",
+        handler: async (ctx) => {
+            const wfId = resolveWorkflowId(ctx);
+            if (!wfId)
+                return;
+            try {
+                const result = await ctx.api.pauseWorkflow(wfId);
+                ctx.store.addMessage({ role: "system", content: `Paused workflow: ${wfId} (${result.status})` });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.store.addMessage({ role: "error", content: `Failed to pause: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "resume",
+        description: "Resume a paused workflow",
+        usage: "/resume [workflow-id]",
+        category: "workflow",
+        handler: async (ctx) => {
+            const wfId = resolveWorkflowId(ctx);
+            if (!wfId)
+                return;
+            try {
+                const result = await ctx.api.resumeWorkflow(wfId);
+                ctx.store.addMessage({ role: "system", content: `Resumed workflow: ${wfId} (${result.status})` });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.store.addMessage({ role: "error", content: `Failed to resume: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "cancel",
+        description: "Cancel a workflow (requires confirm)",
+        usage: "/cancel confirm [workflow-id]",
+        category: "workflow",
+        handler: async (ctx) => {
+            // Require explicit "confirm" as first arg to prevent accidental cancellation
+            if (ctx.args[0] !== "confirm") {
+                const wfId = ctx.args[0] ?? ctx.store.activeWorkflowId ?? "<workflow-id>";
+                ctx.store.addMessage({
+                    role: "system",
+                    content: `This will permanently cancel workflow ${wfId}.\nTo confirm, run: /cancel confirm ${wfId}`,
+                });
+                return;
+            }
+            // "confirm" consumed — remaining args are the workflow ID
+            const shiftedCtx = { ...ctx, args: ctx.args.slice(1) };
+            const wfId = resolveWorkflowId(shiftedCtx);
+            if (!wfId)
+                return;
+            try {
+                const result = await ctx.api.cancelWorkflow(wfId);
+                ctx.store.addMessage({ role: "system", content: `Cancelled workflow: ${wfId} (${result.status})` });
+                if (ctx.store.activeWorkflowId === wfId) {
+                    ctx.store.setActiveWorkflowId(null);
+                    ctx.store.setActiveWorkflow(null);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.store.addMessage({ role: "error", content: `Failed to cancel: ${msg}` });
+            }
+        },
+    });
+    registerCommand({
+        name: "attach",
+        description: "Attach to a workflow's live stream",
+        usage: "/attach <workflow-id>",
+        category: "workflow",
+        handler: async (ctx) => {
+            const wfId = resolveWorkflowId(ctx);
+            if (!wfId)
+                return;
+            ctx.store.setActiveWorkflowId(wfId);
+            ctx.store.addMessage({ role: "system", content: `Attaching to workflow: ${wfId}...` });
+            const controller = subscribeToWorkflow(ctx.store.apiUrl, wfId, ctx.store);
+            ctx.store.addSseController(wfId, controller);
+        },
+    });
+    registerCommand({
+        name: "detach",
+        description: "Detach from live stream",
+        usage: "/detach",
+        category: "workflow",
+        handler: async ({ store }) => {
+            const wfId = store.activeWorkflowId;
+            if (wfId) {
+                store.removeSseController(wfId);
+                store.addMessage({ role: "system", content: `Detached from workflow: ${wfId}` });
+            }
+            else {
+                store.abortAllSse();
+                store.addMessage({ role: "system", content: "Detached from all streams." });
+            }
+        },
+    });
+    registerCommand({
+        name: "history",
+        description: "Show full workflow event history",
+        usage: "/history [workflow-id]",
+        category: "workflow",
+        handler: async ({ store }) => {
+            store.addMessage({ role: "system", content: "History is not yet available (Phase 2)." });
+        },
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Configuration loading and validation for the Hydra TUI.
+ *
+ * Config file: ~/.hydra/config.yaml
+ * Overridable via environment variables.
+ */
+import { z } from "zod";
+export declare const TuiConfigSchema: z.ZodObject<{
+    temporal: z.ZodDefault<z.ZodObject<{
+        address: z.ZodDefault<z.ZodString>;
+        namespace: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        namespace: string;
+    }, {
+        address?: string | undefined;
+        namespace?: string | undefined;
+    }>>;
+    api: z.ZodDefault<z.ZodObject<{
+        url: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+    }, {
+        url?: string | undefined;
+    }>>;
+    qdrant: z.ZodDefault<z.ZodObject<{
+        url: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+    }, {
+        url?: string | undefined;
+    }>>;
+    tui: z.ZodDefault<z.ZodObject<{
+        theme: z.ZodDefault<z.ZodEnum<["dark", "light", "solarized", "monokai", "hydra"]>>;
+        layout: z.ZodDefault<z.ZodEnum<["split", "full"]>>;
+        rightPanel: z.ZodDefault<z.ZodBoolean>;
+        vimMode: z.ZodDefault<z.ZodBoolean>;
+        syntaxHighlighting: z.ZodDefault<z.ZodBoolean>;
+        maxHistory: z.ZodDefault<z.ZodNumber>;
+        spinnerStyle: z.ZodDefault<z.ZodEnum<["dots", "line", "arc", "bounce"]>>;
+    }, "strip", z.ZodTypeAny, {
+        maxHistory: number;
+        theme: "dark" | "light" | "solarized" | "monokai" | "hydra";
+        layout: "split" | "full";
+        rightPanel: boolean;
+        vimMode: boolean;
+        syntaxHighlighting: boolean;
+        spinnerStyle: "dots" | "line" | "arc" | "bounce";
+    }, {
+        maxHistory?: number | undefined;
+        theme?: "dark" | "light" | "solarized" | "monokai" | "hydra" | undefined;
+        layout?: "split" | "full" | undefined;
+        rightPanel?: boolean | undefined;
+        vimMode?: boolean | undefined;
+        syntaxHighlighting?: boolean | undefined;
+        spinnerStyle?: "dots" | "line" | "arc" | "bounce" | undefined;
+    }>>;
+    workflow: z.ZodDefault<z.ZodObject<{
+        defaultModel: z.ZodDefault<z.ZodString>;
+        autoApproveReads: z.ZodDefault<z.ZodBoolean>;
+        qualityThreshold: z.ZodDefault<z.ZodNumber>;
+        costWarning: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        defaultModel: string;
+        autoApproveReads: boolean;
+        qualityThreshold: number;
+        costWarning: number;
+    }, {
+        defaultModel?: string | undefined;
+        autoApproveReads?: boolean | undefined;
+        qualityThreshold?: number | undefined;
+        costWarning?: number | undefined;
+    }>>;
+    notifications: z.ZodDefault<z.ZodObject<{
+        sound: z.ZodDefault<z.ZodBoolean>;
+        desktop: z.ZodDefault<z.ZodBoolean>;
+        idleAlert: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        sound: boolean;
+        desktop: boolean;
+        idleAlert: number;
+    }, {
+        sound?: boolean | undefined;
+        desktop?: boolean | undefined;
+        idleAlert?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    workflow: {
+        defaultModel: string;
+        autoApproveReads: boolean;
+        qualityThreshold: number;
+        costWarning: number;
+    };
+    api: {
+        url: string;
+    };
+    temporal: {
+        address: string;
+        namespace: string;
+    };
+    qdrant: {
+        url: string;
+    };
+    tui: {
+        maxHistory: number;
+        theme: "dark" | "light" | "solarized" | "monokai" | "hydra";
+        layout: "split" | "full";
+        rightPanel: boolean;
+        vimMode: boolean;
+        syntaxHighlighting: boolean;
+        spinnerStyle: "dots" | "line" | "arc" | "bounce";
+    };
+    notifications: {
+        sound: boolean;
+        desktop: boolean;
+        idleAlert: number;
+    };
+}, {
+    workflow?: {
+        defaultModel?: string | undefined;
+        autoApproveReads?: boolean | undefined;
+        qualityThreshold?: number | undefined;
+        costWarning?: number | undefined;
+    } | undefined;
+    api?: {
+        url?: string | undefined;
+    } | undefined;
+    temporal?: {
+        address?: string | undefined;
+        namespace?: string | undefined;
+    } | undefined;
+    qdrant?: {
+        url?: string | undefined;
+    } | undefined;
+    tui?: {
+        maxHistory?: number | undefined;
+        theme?: "dark" | "light" | "solarized" | "monokai" | "hydra" | undefined;
+        layout?: "split" | "full" | undefined;
+        rightPanel?: boolean | undefined;
+        vimMode?: boolean | undefined;
+        syntaxHighlighting?: boolean | undefined;
+        spinnerStyle?: "dots" | "line" | "arc" | "bounce" | undefined;
+    } | undefined;
+    notifications?: {
+        sound?: boolean | undefined;
+        desktop?: boolean | undefined;
+        idleAlert?: number | undefined;
+    } | undefined;
+}>;
+export type TuiConfig = z.infer<typeof TuiConfigSchema>;
+export declare function getEnvOverrides(): Record<string, unknown>;
+export declare function loadConfig(): TuiConfig;