@cydm/happy-elves 0.1.0-beta.5 → 0.1.0-beta.51

package/README.md

@@ -11,5 +11,7 @@ happy-elves account create --relay https://relay.happyelves.ai --device-name "CL
 ## Self-host relay
 
 ```bash
+HAPPY_ELVES_ENV=production \
+HAPPY_ELVES_ALLOWED_ORIGINS=https://your-controller.example \
 happy-elves relay serve --host 0.0.0.0 --port 8787 --json
 ```

package/apps/cli/dist/commands/account.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleAccount({ domain, action, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/account.js

@@ -0,0 +1,51 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { configDir, configPath, generateAccountSecret, ok, parsePairingStartResponse, randomId, readRelayJson, requireRelayUrl, stopLocalDaemon, throwRelayHttpError, writeConfig } from "./lib/index.js";
+export async function handleAccount({ domain, action, flags }) {
+    if (domain === "account" && action === "create") {
+        const relayUrl = requireRelayUrl(flags);
+        const deviceId = typeof flags["device-id"] === "string" ? flags["device-id"] : randomId("dev");
+        const deviceName = typeof flags["device-name"] === "string" ? flags["device-name"] : os.hostname();
+        const accountSecret = generateAccountSecret();
+        const response = await fetch(`${relayUrl}/api/pairing/start`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ deviceId, deviceName }),
+        });
+        if (!response.ok) {
+            await throwRelayHttpError(response, "Account creation failed");
+        }
+        const paired = parsePairingStartResponse(await readRelayJson(response, "Account creation response is not valid JSON"));
+        const config = {
+            relayUrl,
+            controllerToken: paired.controllerToken,
+            accountSecret,
+        };
+        await writeConfig(config);
+        ok("account.create", {
+            accountId: paired.accountId,
+            configPath,
+            relayUrl,
+            deviceId,
+            controllerToken: paired.controllerToken,
+            accountSecret,
+            pairingCode: paired.pairingCode,
+            expiresAt: paired.expiresAt,
+        });
+        return true;
+    }
+    if (domain === "account" && action === "reset") {
+        const stop = await stopLocalDaemon().catch((error) => ({
+            error: error instanceof Error ? error.message : String(error),
+        }));
+        await fs.rm(configPath, { force: true });
+        await fs.rm(path.join(configDir, "daemon.json"), { force: true });
+        ok("account.reset", {
+            removed: [configPath, path.join(configDir, "daemon.json")],
+            stop,
+        });
+        return true;
+    }
+    return false;
+}

package/apps/cli/dist/commands/app.d.ts

@@ -0,0 +1,3 @@
+import { handleCliError } from "./lib/index.js";
+export { handleCliError };
+export declare function main(): Promise<void>;

package/apps/cli/dist/commands/app.js

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import path from "node:path";
+import { handleAccount } from "./account.js";
+import { handleCollect } from "./collect.js";
+import { handleConfig } from "./config.js";
+import { handleDaemon } from "./daemon.js";
+import { handleLoop } from "./loop.js";
+import { handleMachine } from "./machine.js";
+import { handleOrchestrator } from "./orchestrator.js";
+import { handleRelay } from "./relay.js";
+import { handleRemote } from "./remote.js";
+import { handleSession } from "./session.js";
+import { handleSkill } from "./skill.js";
+import { handleToken } from "./token.js";
+import { handleTurn } from "./turn.js";
+import { commandUsage, commandUsageText, handleCliError, parseCliFlags, skillText, startBootstrap, topLevelDoctor, topLevelStatus, usage, usageText } from "./lib/index.js";
+export { handleCliError };
+const domainHandlers = [
+    handleAccount,
+    handleConfig,
+    handleRemote,
+    handleToken,
+    handleLoop,
+    handleDaemon,
+    handleRelay,
+    handleMachine,
+    handleOrchestrator,
+    handleSession,
+    handleSkill,
+    handleTurn,
+    handleCollect,
+];
+export async function main() {
+    const argv = process.argv.slice(2);
+    const [domain] = argv;
+    if (!domain)
+        usage();
+    if (domain === "--skill") {
+        console.log(skillText());
+        return;
+    }
+    if (domain === "--help" || domain === "-h" || domain === "help") {
+        console.log(usageText());
+        return;
+    }
+    if (domain === "--version" || domain === "-v" || domain === "version") {
+        console.log(cliVersion());
+        return;
+    }
+    const topLevelHelpRequested = argv[1] === "help" || argv.slice(1).some((arg) => arg === "--help" || arg === "-h");
+    if (topLevelHelpRequested && commandUsageText(domain)) {
+        console.log(commandUsageText(domain));
+        return;
+    }
+    if (domain === "start") {
+        const { flags } = parseCliFlags(argv.slice(1));
+        await startBootstrap(flags);
+        return;
+    }
+    if (domain === "doctor") {
+        const { flags } = parseCliFlags(argv.slice(1));
+        await topLevelDoctor(flags);
+        return;
+    }
+    if (domain === "status") {
+        const { flags } = parseCliFlags(argv.slice(1));
+        await topLevelStatus(flags);
+        return;
+    }
+    const action = argv[1];
+    const rest = argv.slice(2);
+    if ((!action || action.startsWith("-")) && commandUsageText(domain)) {
+        commandUsage(domain);
+    }
+    const { positional, flags } = parseCliFlags(rest);
+    if (action === "--help" || action === "-h" || action === "help" || flags.help === true || flags.h === true) {
+        console.log(commandUsageText(domain) ?? usageText());
+        return;
+    }
+    const input = { domain, action, positional, flags };
+    for (const handle of domainHandlers) {
+        if (await handle(input))
+            return;
+    }
+    usage();
+}
+function cliVersion() {
+    for (const candidate of [
+        path.resolve(import.meta.dirname, "..", "..", "..", "..", "package.json"),
+        path.resolve(import.meta.dirname, "..", "..", "..", "package.json"),
+        path.resolve(import.meta.dirname, "..", "..", "package.json"),
+    ]) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+            if (typeof parsed.version === "string" && parsed.version.trim())
+                return parsed.version.trim();
+        }
+        catch {
+            // Try the next packaged/source layout.
+        }
+    }
+    return "0.1.0";
+}

package/apps/cli/dist/commands/collect.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleCollect({ domain, action, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/collect.js

@@ -0,0 +1,30 @@
+import { CliError, ControllerClient, conciseEvents, ok, parseEventCursor, printConciseEvents, readConfig, requirePositional, wantsJson, wantsVerbose } from "./lib/index.js";
+export async function handleCollect({ domain, action, flags }) {
+    if (domain !== "collect")
+        return false;
+    const config = await readConfig(flags);
+    const client = new ControllerClient(config);
+    const sessionId = requirePositional(action, "sessionId");
+    const since = parseEventCursor(flags.since);
+    const limit = typeof flags.limit === "string" ? Number(flags.limit) : undefined;
+    if (limit !== undefined && (!Number.isInteger(limit) || limit <= 0)) {
+        throw new CliError(`Invalid --limit: ${flags.limit}`, "INVALID_ARGUMENT");
+    }
+    const events = await client.collect(sessionId, { since, limit });
+    const lastEventId = events.at(-1)?.id;
+    const nextSince = lastEventId === undefined ? (since ?? null) : `cursor_${lastEventId}`;
+    if (wantsJson(flags) || wantsVerbose(flags)) {
+        ok("session.collect", {
+            sessionId,
+            debugOnly: true,
+            cursor: nextSince,
+            nextSince,
+            ...(wantsVerbose(flags) ? { events } : { events: conciseEvents(events) }),
+        }, { sessionId });
+    }
+    else {
+        printConciseEvents(events);
+        console.log(`nextSince: ${nextSince ?? "none"}`);
+    }
+    return true;
+}

package/apps/cli/dist/commands/command.d.ts

@@ -0,0 +1,6 @@
+export type CommandInput = {
+    domain: string;
+    action: string | undefined;
+    positional: string[];
+    flags: Record<string, string | boolean>;
+};

package/apps/cli/dist/commands/command.js

@@ -0,0 +1 @@
+export {};

package/apps/cli/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleConfig({ domain, action, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/config.js

@@ -0,0 +1,30 @@
+import { configPath, ok, readConfig, redactedControllerConfig, redactedRelayUrl, requireRelayUrl, requireString, wantsJson, writeConfig } from "./lib/index.js";
+export async function handleConfig({ domain, action, flags }) {
+    if (domain === "config" && action === "init") {
+        const config = {
+            relayUrl: requireRelayUrl(flags),
+            controllerToken: requireString(flags, "token"),
+            accountSecret: requireString(flags, "secret"),
+        };
+        await writeConfig(config);
+        ok("config.init", { path: configPath, relayUrl: redactedRelayUrl(config.relayUrl) });
+        return true;
+    }
+    if (domain === "config" && action === "show") {
+        const config = await readConfig(flags);
+        if (!wantsJson(flags)) {
+            const redacted = redactedControllerConfig(config);
+            console.log(`Config: ${configPath}`);
+            console.log(`Relay: ${redacted.relayUrl}`);
+            console.log(`Controller token: ${redacted.hasControllerToken ? "configured" : "missing"}`);
+            console.log(`Account secret: ${redacted.hasAccountSecret ? "configured" : "missing"}`);
+            return true;
+        }
+        ok("config.show", {
+            path: configPath,
+            config: redactedControllerConfig(config),
+        });
+        return true;
+    }
+    return false;
+}

package/apps/cli/dist/commands/daemon.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleDaemon({ domain, action, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/daemon.js

@@ -0,0 +1,218 @@
+import os from "node:os";
+import path from "node:path";
+import { CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, showMachine, spawnDaemonStart, stopLocalDaemon, throwRelayHttpError, wantsJson, writeDaemonConfig } from "./lib/index.js";
+export async function handleDaemon({ domain, action, flags }) {
+    if (domain === "daemon" && action === "pair") {
+        const relayUrl = requireRelayUrl(flags);
+        const code = requireString(flags, "code");
+        const accountSecret = requireString(flags, "secret");
+        const machineName = typeof flags.name === "string" && flags.name.trim() ? flags.name.trim() : os.hostname();
+        const machineId = typeof flags["machine-id"] === "string" ? flags["machine-id"] : randomId("mach");
+        const response = await fetch(`${relayUrl}/api/pairing/claim`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ code, machineId }),
+        });
+        if (!response.ok) {
+            await throwRelayHttpError(response, "Pairing failed");
+        }
+        const claimed = parsePairingClaimResponse(await readRelayJson(response, "Pairing response is not valid JSON"));
+        const daemonConfig = {
+            relayUrl,
+            accountId: claimed.accountId,
+            machineId: claimed.machineId,
+            machineName,
+            machineToken: claimed.machineToken,
+            accountSecret,
+        };
+        const daemonConfigPath = await writeDaemonConfig(daemonConfig);
+        ok("daemon.pair", {
+            path: daemonConfigPath,
+            config: redactedDaemonConfig(daemonConfig),
+        });
+        return true;
+    }
+    if (domain === "daemon" && action === "doctor") {
+        const checks = [];
+        let config;
+        try {
+            config = await readConfig(flags);
+            checks.push({ name: "config", ok: true, message: configPath });
+        }
+        catch (error) {
+            checks.push({ name: "config", ok: false, message: error instanceof Error ? error.message : String(error) });
+        }
+        if (config) {
+            try {
+                const response = await fetch(`${config.relayUrl}/health`);
+                checks.push({ name: "relay", ok: response.ok, message: response.ok ? "reachable" : await response.text() });
+            }
+            catch (error) {
+                checks.push({ name: "relay", ok: false, message: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        const data = { ok: checks.every((check) => check.ok), checks };
+        if (!wantsJson(flags)) {
+            console.log(`Daemon doctor: ${data.ok ? "ok" : "issues found"}`);
+            for (const check of checks) {
+                console.log(`${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`);
+            }
+            return true;
+        }
+        ok("daemon.doctor", data);
+        return true;
+    }
+    if (domain === "daemon" && action === "config") {
+        const daemonConfig = await readDaemonConfig();
+        const redacted = redactedDaemonConfig(daemonConfig);
+        if (!wantsJson(flags)) {
+            console.log(`Config: ${path.join(configDir, "daemon.json")}`);
+            console.log(`Relay: ${redacted.relayUrl}`);
+            console.log(`Account: ${redacted.accountId}`);
+            console.log(`Machine: ${redacted.machineName} (${redacted.machineId})`);
+            console.log(`Machine token: ${redacted.hasMachineToken ? "configured" : "missing"}`);
+            console.log(`Account secret: ${redacted.hasAccountSecret ? "configured" : "missing"}`);
+            return true;
+        }
+        ok("daemon.config", {
+            path: path.join(configDir, "daemon.json"),
+            config: redacted,
+        });
+        return true;
+    }
+    if (domain === "daemon" && action === "logs") {
+        const tail = typeof flags.tail === "string" ? Number(flags.tail) : 100;
+        if (!Number.isInteger(tail) || tail <= 0) {
+            throw new CliError(`Invalid --tail: ${flags.tail}`, "INVALID_ARGUMENT");
+        }
+        const entries = await readLocalAuditLog(tail);
+        if (!wantsJson(flags)) {
+            if (entries.length === 0) {
+                console.log("No daemon audit log entries.");
+                return true;
+            }
+            for (const entry of entries) {
+                const record = entry;
+                const createdAt = typeof record.createdAt === "string" ? record.createdAt : "-";
+                const action = typeof record.action === "string" ? record.action : "unknown";
+                const actor = typeof record.actor === "string" ? record.actor : "unknown";
+                const sessionId = typeof record.sessionId === "string" ? record.sessionId : undefined;
+                const summary = typeof record.summary === "string" ? record.summary : JSON.stringify(record);
+                console.log(`${createdAt}  ${action}  ${actor}`);
+                if (sessionId)
+                    console.log(`  session: ${sessionId}`);
+                console.log(`  ${compactText(summary, 160)}`);
+            }
+            return true;
+        }
+        ok("daemon.logs", {
+            path: path.join(configDir, "audit.jsonl"),
+            entries,
+        });
+        return true;
+    }
+    if (domain === "daemon" && action === "start") {
+        const status = await localDaemonStatus();
+        if (status.running) {
+            ok("daemon.start", { ...status, started: false });
+            return true;
+        }
+        await readDaemonConfig();
+        const startArgs = typeof flags.relay === "string" ? ["--relay", flags.relay] : [];
+        const pid = spawnDaemonStart(startArgs);
+        ok("daemon.start", { pid, pidPath: daemonPidPath, started: true });
+        return true;
+    }
+    if (domain === "daemon" && action === "stop") {
+        ok("daemon.stop", await stopLocalDaemon());
+        return true;
+    }
+    if (domain === "daemon" && action === "restart") {
+        await readDaemonConfig();
+        const stop = await stopLocalDaemon();
+        const startArgs = typeof flags.relay === "string" ? ["--relay", flags.relay] : [];
+        const pid = spawnDaemonStart(startArgs);
+        ok("daemon.restart", { stop, startedPid: pid, pidPath: daemonPidPath });
+        return true;
+    }
+    if (domain === "daemon" && action === "status" && flags.local === true) {
+        const local = await localDaemonStatus();
+        if (!wantsJson(flags)) {
+            console.log(local.running ? `Daemon: running${local.pid ? ` pid ${local.pid}` : ""}` : "Daemon: stopped");
+            console.log(`Pid file: ${local.pidPath}`);
+            return true;
+        }
+        ok("daemon.status", { local });
+        return true;
+    }
+    if (domain === "daemon" && action === "status") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const local = await localDaemonStatus();
+        const response = await fetch(`${config.relayUrl}/health`);
+        const snapshot = await client.snapshot();
+        const machineFilter = flags.machine === true ? requirePositional(undefined, "machineId") : typeof flags.machine === "string" ? flags.machine : undefined;
+        const machines = machineFilter
+            ? snapshot.machines.filter((machine) => machine.id === machineFilter)
+            : snapshot.machines;
+        if (machineFilter && machines.length === 0)
+            throw new CliError("Machine not found", "MACHINE_NOT_FOUND");
+        const machineIds = new Set(machines.map((machine) => machine.id));
+        const sessions = snapshot.sessions.filter((session) => machineIds.has(session.machineId));
+        const projectedMachines = await Promise.all(machines.map((machine) => showMachine(client, machine)));
+        const projectedSessions = await Promise.all(sessions.map(async (session) => ({
+            sessionId: session.id,
+            machineId: session.machineId,
+            agent: session.agent,
+            status: session.status,
+            orchestration: deriveOrchestration(session, await client.history(session.id, 20)),
+            updatedAt: session.updatedAt,
+            capabilities: session.capabilities,
+        })));
+        const data = {
+            configPath,
+            local,
+            relayUrl: config.relayUrl,
+            relayReachable: response.ok,
+            relay: response.ok ? await response.json() : await response.text(),
+            machines: projectedMachines.map((machine) => ({
+                machineId: machine.id,
+                name: machine.metadata.name ?? machine.name,
+                online: machine.online,
+                lastSeen: machine.lastSeen,
+                defaultCwd: machine.defaultCwd,
+                daemonVersion: machine.capabilities.daemonVersion,
+                acpxVersion: machine.capabilities.acpxVersion,
+                sessionPrimitives: machine.capabilities.sessionPrimitives,
+                agents: machine.capabilities.agents,
+                metadata: machine.metadata,
+            })),
+            sessions: projectedSessions,
+            summary: {
+                machineCount: machines.length,
+                onlineMachineCount: machines.filter((machine) => machine.online).length,
+                sessionCount: projectedSessions.length,
+                runningSessionCount: projectedSessions.filter((session) => session.status === "running").length,
+                idleSessionCount: projectedSessions.filter((session) => idleSessionStatuses.includes(session.status)).length,
+                blockedSessionCount: projectedSessions.filter((session) => session.orchestration.blocked).length,
+                activeSessionCount: projectedSessions.filter((session) => session.orchestration.state === "active").length,
+                completedSessionCount: projectedSessions.filter((session) => session.orchestration.completed).length,
+                needsUserSessionCount: projectedSessions.filter((session) => session.orchestration.needsUser).length,
+            },
+        };
+        if (!wantsJson(flags)) {
+            console.log(`Relay: ${data.relayUrl} ${data.relayReachable ? "ok" : "unreachable"}`);
+            console.log(data.local.running ? `Local daemon: running${data.local.pid ? ` pid ${data.local.pid}` : ""}` : "Local daemon: stopped");
+            console.log(`Machines: ${data.summary.onlineMachineCount}/${data.summary.machineCount} online`);
+            console.log(`Sessions: ${data.summary.sessionCount} total, ${data.summary.runningSessionCount} running, ${data.summary.needsUserSessionCount} needs user`);
+            for (const machine of data.machines) {
+                console.log(`- ${machine.name} (${machine.machineId}) ${machine.online ? "online" : "offline"}`);
+                console.log(`  cwd: ${machine.defaultCwd ?? "-"}`);
+            }
+            return true;
+        }
+        ok("daemon.status", data, machineFilter ? { machineId: machineFilter } : {});
+        return true;
+    }
+    return false;
+}

package/apps/cli/dist/commands/lib/args.d.ts

@@ -0,0 +1,4 @@
+export declare function parseCliFlags(argv: string[]): {
+    positional: string[];
+    flags: Record<string, string | boolean>;
+};

package/apps/cli/dist/commands/lib/args.js

@@ -0,0 +1,88 @@
+import { parseFlags as parseSharedFlags } from "../../../../../packages/shared/dist/index.js";
+import { CliError } from "../../errors.js";
+const valueFlags = new Set([
+    "agent",
+    "code",
+    "controller",
+    "cwd",
+    "device-id",
+    "device-name",
+    "from",
+    "host",
+    "invite-secret",
+    "join-url-base",
+    "limit",
+    "machine",
+    "machine-id",
+    "name",
+    "mode",
+    "output",
+    "path",
+    "port",
+    "permission",
+    "permission-mode",
+    "prompt",
+    "prompt-file",
+    "query",
+    "request-id",
+    "every",
+    "reason",
+    "relay",
+    "root",
+    "runtime-limit",
+    "runtime-session",
+    "shell",
+    "actions",
+    "expires-in",
+    "format",
+    "loops",
+    "machines",
+    "messages",
+    "sessions",
+    "secret",
+    "since",
+    "stop-on",
+    "tail",
+    "tag",
+    "tags",
+    "text",
+    "text-file",
+    "timeout",
+    "timeout-ms",
+    "wait-timeout-ms",
+    "runtime-timeout",
+    "to",
+    "token",
+    "ttl",
+    "url",
+    "turn",
+    "until",
+]);
+const booleanFlags = new Set([
+    "all",
+    "detach",
+    "force",
+    "help",
+    "h",
+    "include-output",
+    "include-archived",
+    "json",
+    "keep-source",
+    "local",
+    "no-open",
+    "no-wait",
+    "repair-head",
+    "summary",
+    "verbose",
+    "wait",
+]);
+const knownFlags = new Set([...valueFlags, ...booleanFlags]);
+const dashPrefixedValueFlags = new Set(["secret"]);
+export function parseCliFlags(argv) {
+    const parsed = parseSharedFlags(argv, { valueFlags, dashPrefixedValueFlags });
+    const unknown = Object.keys(parsed.flags).filter((flag) => !knownFlags.has(flag));
+    if (unknown.length > 0) {
+        throw new CliError(`Unknown flag: --${unknown[0]}`, "UNKNOWN_FLAG");
+    }
+    return parsed;
+}

package/apps/cli/dist/commands/lib/audit.d.ts

@@ -0,0 +1 @@
+export declare function readLocalAuditLog(tail?: number): Promise<unknown[]>;

package/apps/cli/dist/commands/lib/audit.js

@@ -0,0 +1,25 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CliError } from "../../errors.js";
+import { configDir } from "./paths.js";
+export async function readLocalAuditLog(tail = 100) {
+    const auditPath = path.join(configDir, "audit.jsonl");
+    let content = "";
+    try {
+        content = await fs.readFile(auditPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    try {
+        return content.trim().split("\n").filter(Boolean).slice(-tail).map((line) => JSON.parse(line));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new CliError("Local audit log contains invalid JSON.", "AUDIT_LOG_INVALID");
+        }
+        throw error;
+    }
+}

package/apps/cli/dist/commands/lib/bootstrap-config.d.ts

@@ -0,0 +1,28 @@
+import type { CliConfig, DaemonConfig } from "./types.js";
+export type ConfigBackup = {
+    path: string;
+    backupPath: string;
+    reason: string;
+};
+export declare function ensureControllerConfig(params: {
+    relayUrl: string;
+    explicitRelay: boolean;
+    deviceName: string;
+}): Promise<{
+    config: CliConfig;
+    created: boolean;
+    accountId?: string;
+    backup?: ConfigBackup;
+    reconfigured: boolean;
+}>;
+export declare function ensureDaemonPaired(config: CliConfig, machineName: string): Promise<{
+    config: DaemonConfig;
+    created: boolean;
+    backup?: ConfigBackup;
+    reconfigured: boolean;
+}>;
+export declare function controllerBaseUrl(flags: Record<string, string | boolean>): string;
+export declare function startRelayUrl(flags: Record<string, string | boolean>, existing?: CliConfig): {
+    relayUrl: string;
+    explicit: boolean;
+};