@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -2,68 +2,117 @@ import { parseFlags as parseSharedFlags } from "../../../../../packages/shared/d
 import { CliError } from "../../errors.js";
 const valueFlags = new Set([
     "agent",
+    "app-id",
+    "at",
+    "channel",
     "code",
+    "conversation",
+    "cron",
     "controller",
     "cwd",
+    "date",
     "device-id",
     "device-name",
+    "every-ms",
+    "execution",
     "from",
     "host",
+    "domain",
     "invite-secret",
+    "inbound",
     "join-url-base",
+    "label",
+    "layer",
     "limit",
     "machine",
     "machine-id",
+    "memory",
+    "memory-mode",
+    "message-id",
+    "memory-project",
+    "memory-top-n",
     "name",
+    "model",
     "mode",
     "output",
     "path",
     "port",
     "permission",
     "permission-mode",
+    "profile",
+    "project",
+    "query",
     "prompt",
     "prompt-file",
     "every",
     "reason",
+    "release-tag",
+    "reaction-emoji",
     "relay",
     "root",
+    "runtime-limit",
+    "runtime-session",
     "shell",
     "actions",
+    "ack-timeout",
+    "allow-chat",
+    "allow-sender",
     "expires-in",
     "format",
     "loops",
     "machines",
     "sessions",
+    "session",
     "secret",
     "since",
+    "source",
     "stop-on",
     "tail",
+    "tag",
+    "tags",
     "text",
     "text-file",
     "timeout",
     "timeout-ms",
+    "timezone",
     "wait-timeout-ms",
+    "inactivity-timeout",
     "runtime-timeout",
     "to",
     "token",
     "ttl",
+    "title",
     "url",
     "turn",
     "until",
+    "reviewer-tag",
+    "dogfood-tag",
 ]);
 const booleanFlags = new Set([
     "all",
+    "allow-any-sender",
+    "app-secret-stdin",
+    "confirm-risk",
+    "copy-tags",
     "detach",
+    "disable-reaction",
     "help",
+    "hidden",
     "h",
     "include-archived",
+    "include-debug",
     "json",
+    "keep-source",
     "local",
     "no-open",
+    "no-start",
     "no-wait",
+    "repair-head",
+    "strict",
     "summary",
     "verbose",
     "wait",
+    "manual",
 ]);
 const knownFlags = new Set([...valueFlags, ...booleanFlags]);
 const dashPrefixedValueFlags = new Set(["secret"]);

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

@@ -1,5 +1,5 @@
-import type { ControllerClient } from "@happy-elves/client";
-import type { MachineSnapshot } from "@happy-elves/shared";
+import type { ControllerClient } from "../../../../../packages/client/dist/index.js";
+import type { MachineSnapshot } from "../../../../../packages/shared/dist/index.js";
 import { localDaemonStatus, stopLocalDaemon } from "./local-daemon.js";
 export declare function ensureDaemonRunning(relayUrl: string, cwd?: string): Promise<{
     local: Awaited<ReturnType<typeof localDaemonStatus>>;

package/apps/cli/dist/commands/lib/bootstrap-daemon.js

@@ -1,11 +1,11 @@
 import { CliError } from "../../errors.js";
 import { startDaemonTimeoutMs } from "./paths.js";
 import { readDaemonConfig } from "./config.js";
-import { daemonBinaryUpdatedAfterStart, localDaemonStatus, spawnDaemonStart, stopLocalDaemon } from "./local-daemon.js";
+import { daemonBinaryUpdatedAfterStart, daemonConfigUpdatedAfterStart, localDaemonStatus, spawnDaemonStart, stopLocalDaemon } from "./local-daemon.js";
 export async function ensureDaemonRunning(relayUrl, cwd = process.cwd()) {
     const current = await localDaemonStatus();
     if (current.running) {
-        if (await daemonBinaryUpdatedAfterStart(current)) {
+        if ((await daemonBinaryUpdatedAfterStart(current)) || (await daemonConfigUpdatedAfterStart(current))) {
             return await restartDaemonForNewConfig(relayUrl, cwd);
         }
         return { local: current, started: false };

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

@@ -1 +1,12 @@
+type DoctorCheck = {
+    name: string;
+    ok: boolean;
+    severity: "error" | "warning" | "info";
+    layer: "compatible" | "aligned";
+    message: string;
+    details?: unknown;
+};
+export declare function comparePackageVersions(left: string, right: string): number;
+export declare function publishedCliVersionCheck(currentVersion: string, env?: NodeJS.ProcessEnv | Record<string, string | undefined>): Promise<DoctorCheck>;
 export declare function topLevelDoctor(flags: Record<string, string | boolean>): Promise<void>;
+export {};

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

@@ -1,49 +1,314 @@
 import path from "node:path";
+import cliPackage from "../../../package.json" with { type: "json" };
+import { ControllerClient } from "../../../../../packages/client/dist/index.js";
 import { configDir, configPath } from "./paths.js";
 import { redactedControllerConfig, redactedDaemonConfig } from "./config.js";
 import { ok, wantsJson } from "./json.js";
-import { localDaemonStatus } from "./local-daemon.js";
+import { daemonBinaryUpdatedAfterStart, localDaemonStatus } from "./local-daemon.js";
 import { readExistingControllerConfig, readExistingDaemonConfig, relayHealth } from "./relay-http.js";
 import { startRelayUrl } from "./bootstrap-config.js";
+const publicPackageName = "@cydm/happy-elves";
+const npmLatestUrl = "https://registry.npmjs.org/@cydm%2Fhappy-elves/latest";
+const latestVersionEnv = "HAPPY_ELVES_DOCTOR_LATEST_VERSION";
+const latestVersionTimeoutEnv = "HAPPY_ELVES_DOCTOR_LATEST_TIMEOUT_MS";
+function parsedPackageVersion(value) {
+    const normalized = value.trim().replace(/^v/, "").split("+", 1)[0] ?? "";
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(normalized);
+    if (!match)
+        return undefined;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4]?.split(".") ?? [],
+    };
+}
+function comparePrerelease(left, right) {
+    if (left.length === 0 && right.length === 0)
+        return 0;
+    if (left.length === 0)
+        return 1;
+    if (right.length === 0)
+        return -1;
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart === undefined)
+            return -1;
+        if (rightPart === undefined)
+            return 1;
+        if (leftPart === rightPart)
+            continue;
+        const leftNumeric = /^\d+$/.test(leftPart);
+        const rightNumeric = /^\d+$/.test(rightPart);
+        if (leftNumeric && rightNumeric)
+            return Number(leftPart) < Number(rightPart) ? -1 : 1;
+        if (leftNumeric)
+            return -1;
+        if (rightNumeric)
+            return 1;
+        return leftPart < rightPart ? -1 : 1;
+    }
+    return 0;
+}
+export function comparePackageVersions(left, right) {
+    const leftParsed = parsedPackageVersion(left);
+    const rightParsed = parsedPackageVersion(right);
+    if (!leftParsed || !rightParsed)
+        return left.localeCompare(right);
+    for (const key of ["major", "minor", "patch"]) {
+        if (leftParsed[key] < rightParsed[key])
+            return -1;
+        if (leftParsed[key] > rightParsed[key])
+            return 1;
+    }
+    return comparePrerelease(leftParsed.prerelease, rightParsed.prerelease);
+}
+function latestVersionTimeoutMs(env) {
+    const raw = env[latestVersionTimeoutEnv];
+    if (!raw)
+        return 2_500;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 2_500;
+}
+async function readLatestPackageVersion(env) {
+    const override = env[latestVersionEnv]?.trim();
+    if (override) {
+        if (override === "skip")
+            return undefined;
+        return { version: override, source: latestVersionEnv };
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), latestVersionTimeoutMs(env));
+    try {
+        const response = await fetch(npmLatestUrl, {
+            signal: controller.signal,
+            headers: { accept: "application/json" },
+        });
+        if (!response.ok)
+            throw new Error(`npm registry HTTP ${response.status}`);
+        const body = await response.json();
+        if (typeof body.version !== "string" || !body.version.trim())
+            throw new Error("npm registry response did not include a version");
+        return { version: body.version.trim(), source: npmLatestUrl };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function publishedCliVersionCheck(currentVersion, env = process.env) {
+    try {
+        const latest = await readLatestPackageVersion(env);
+        if (!latest) {
+            return {
+                name: "cli-published-version",
+                ok: true,
+                severity: "info",
+                layer: "aligned",
+                message: "latest published CLI version check skipped",
+                details: { cliVersion: currentVersion, packageName: publicPackageName, source: latestVersionEnv },
+            };
+        }
+        const behind = comparePackageVersions(currentVersion, latest.version) < 0;
+        return {
+            name: "cli-published-version",
+            ok: !behind,
+            severity: behind ? "warning" : "info",
+            layer: "aligned",
+            message: behind
+                ? `CLI ${currentVersion} is older than published ${publicPackageName} ${latest.version}; upgrade this installation`
+                : `CLI ${currentVersion} is aligned with published ${publicPackageName} ${latest.version}`,
+            details: { cliVersion: currentVersion, latestVersion: latest.version, packageName: publicPackageName, source: latest.source },
+        };
+    }
+    catch (error) {
+        return {
+            name: "cli-published-version",
+            ok: true,
+            severity: "info",
+            layer: "aligned",
+            message: "latest published CLI version check unavailable",
+            details: { cliVersion: currentVersion, packageName: publicPackageName, error: error instanceof Error ? error.message : String(error) },
+        };
+    }
+}
 export async function topLevelDoctor(flags) {
+    const strict = flags.strict === true;
     const checks = [];
     const existingController = await readExistingControllerConfig().catch((error) => {
-        checks.push({ name: "controller-config", ok: false, message: error instanceof Error ? error.message : String(error) });
+        checks.push({
+            name: "controller-config",
+            ok: false,
+            severity: "error",
+            layer: "compatible",
+            message: error instanceof Error ? error.message : String(error),
+        });
         return undefined;
     });
     if (existingController) {
-        checks.push({ name: "controller-config", ok: true, message: configPath, details: redactedControllerConfig(existingController) });
+        checks.push({
+            name: "controller-config",
+            ok: true,
+            severity: "info",
+            layer: "compatible",
+            message: configPath,
+            details: redactedControllerConfig(existingController),
+        });
     }
     const relay = startRelayUrl(flags, existingController);
+    let relayReachable = false;
     try {
         const health = await relayHealth(relay.relayUrl);
+        relayReachable = health.ok;
         checks.push({
             name: "relay",
             ok: health.ok,
+            severity: health.ok ? "info" : "error",
+            layer: "compatible",
             message: health.ok ? "reachable" : `HTTP ${health.status}`,
             details: { relayUrl: relay.relayUrl, body: health.body },
         });
     }
     catch (error) {
-        checks.push({ name: "relay", ok: false, message: error instanceof Error ? error.message : String(error), details: { relayUrl: relay.relayUrl } });
+        checks.push({
+            name: "relay",
+            ok: false,
+            severity: "error",
+            layer: "compatible",
+            message: error instanceof Error ? error.message : String(error),
+            details: { relayUrl: relay.relayUrl },
+        });
+    }
+    let snapshot;
+    if (existingController && relayReachable) {
+        try {
+            snapshot = await new ControllerClient({ ...existingController, relayUrl: relay.relayUrl }).snapshot();
+            checks.push({
+                name: "controller-snapshot",
+                ok: true,
+                severity: "info",
+                layer: "compatible",
+                message: "controller token accepted",
+                details: { machines: snapshot.machines.length, sessions: snapshot.sessions.length },
+            });
+        }
+        catch (error) {
+            checks.push({
+                name: "controller-snapshot",
+                ok: false,
+                severity: "error",
+                layer: "compatible",
+                message: error instanceof Error ? error.message : String(error),
+                details: { relayUrl: relay.relayUrl },
+            });
+        }
     }
     const existingDaemon = await readExistingDaemonConfig().catch((error) => {
-        checks.push({ name: "daemon-config", ok: false, message: error instanceof Error ? error.message : String(error) });
+        checks.push({
+            name: "daemon-config",
+            ok: false,
+            severity: "error",
+            layer: "compatible",
+            message: error instanceof Error ? error.message : String(error),
+        });
         return undefined;
     });
     if (existingDaemon) {
-        checks.push({ name: "daemon-config", ok: true, message: path.join(configDir, "daemon.json"), details: redactedDaemonConfig(existingDaemon) });
+        checks.push({
+            name: "daemon-config",
+            ok: true,
+            severity: "info",
+            layer: "compatible",
+            message: path.join(configDir, "daemon.json"),
+            details: redactedDaemonConfig(existingDaemon),
+        });
     }
     const local = await localDaemonStatus();
-    checks.push({ name: "daemon-process", ok: local.running, message: local.running ? "running" : "not running", details: local });
+    checks.push({
+        name: "daemon-process",
+        ok: local.running,
+        severity: local.running ? "info" : "error",
+        layer: "compatible",
+        message: local.running ? "running" : "not running",
+        details: local,
+    });
+    const binaryStale = await daemonBinaryUpdatedAfterStart(local);
+    checks.push({
+        name: "daemon-binary-alignment",
+        ok: !binaryStale,
+        severity: binaryStale ? "warning" : "info",
+        layer: "aligned",
+        message: binaryStale ? "daemon binary changed after daemon start; restart daemon to align" : "daemon binary is not newer than running daemon",
+    });
+    checks.push(await publishedCliVersionCheck(cliPackage.version));
+    if (existingDaemon && snapshot) {
+        const daemonMachine = snapshot.machines.find((machine) => machine.id === existingDaemon.machineId);
+        checks.push({
+            name: "daemon-projection",
+            ok: daemonMachine?.online === true,
+            severity: daemonMachine?.online === true ? "info" : "error",
+            layer: "compatible",
+            message: !daemonMachine
+                ? "daemon machine is not visible to this controller; daemon may be paired to a different account"
+                : daemonMachine.online
+                    ? "daemon machine is online in the controller account"
+                    : "daemon machine exists in the controller account but is offline",
+            details: {
+                machineId: existingDaemon.machineId,
+                controllerMachineCount: snapshot.machines.length,
+                ...(daemonMachine ? { online: daemonMachine.online, lastSeen: daemonMachine.lastSeen } : {}),
+            },
+        });
+        const daemonVersion = daemonMachine?.capabilities.daemonVersion;
+        const aligned = !daemonVersion || daemonVersion === cliPackage.version;
+        checks.push({
+            name: "cli-daemon-version-alignment",
+            ok: aligned,
+            severity: aligned ? "info" : "warning",
+            layer: "aligned",
+            message: aligned
+                ? "CLI and daemon package versions are aligned or daemon version is unavailable"
+                : `CLI ${cliPackage.version} differs from daemon ${daemonVersion}`,
+            details: { cliVersion: cliPackage.version, daemonVersion, machineId: existingDaemon.machineId },
+        });
+    }
+    const compatible = checks.filter((check) => check.layer === "compatible" && check.severity === "error").every((check) => check.ok);
+    const aligned = checks.filter((check) => check.layer === "aligned" && check.severity === "warning").every((check) => check.ok);
+    const warnings = checks.filter((check) => !check.ok && check.severity === "warning").map((check) => ({
+        name: check.name,
+        message: check.message,
+        details: check.details,
+    }));
+    const healthy = compatible && (strict ? aligned : true);
     if (wantsJson(flags)) {
-        ok("doctor", { ok: checks.every((check) => check.ok), checks });
+        if (!healthy)
+            process.exitCode = 1;
+        ok("doctor", { ok: healthy, compatible, aligned, strict, warnings, checks }, {}, healthy);
         return;
     }
-    const allOk = checks.every((check) => check.ok);
-    console.log(`Happy Elves doctor: ${allOk ? "ok" : "issues found"}`);
+    console.log(`Happy Elves doctor: ${healthy ? "ok" : "issues found"}`);
+    console.log(`compatible: ${compatible ? "yes" : "no"}`);
+    console.log(`aligned: ${aligned ? "yes" : "no"}${strict ? " (strict)" : ""}`);
+    const failures = checks.filter((check) => !check.ok && check.severity === "error");
+    if (failures.length > 0)
+        console.log("Failures:");
+    for (const check of failures) {
+        console.log(`fail ${check.name}: ${check.message}`);
+    }
+    const warningChecks = checks.filter((check) => !check.ok && check.severity === "warning");
+    if (warningChecks.length > 0)
+        console.log("Warnings:");
+    for (const check of warningChecks) {
+        console.log(`warn ${check.name}: ${check.message}`);
+    }
+    if (failures.length === 0 && warningChecks.length === 0)
+        console.log("Checks:");
     for (const check of checks) {
-        console.log(`${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`);
+        if (check.ok)
+            console.log(`ok ${check.name}: ${check.message}`);
     }
+    if (!healthy)
+        process.exitCode = 1;
 }
 //# sourceMappingURL=doctor.js.map

package/apps/cli/dist/commands/lib/gateway-store.d.ts

@@ -0,0 +1,38 @@
+export type GatewayChannelType = "fake" | "lark";
+export type GatewayChannelConfig = {
+    id: string;
+    type: GatewayChannelType;
+    enabled: boolean;
+    targetMachineId: string;
+    targetCwd: string;
+    defaultAgent: string;
+    defaultModel?: string;
+    localToken?: string;
+    localSecret?: string;
+    lastError?: string;
+    lastDeliveredMessage?: {
+        externalConversationId: string;
+        externalMessageId: string;
+        requestId: string;
+        sessionId: string;
+        turnId: string;
+        deliveredAt: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+};
+export type GatewayConversationMapping = {
+    channelId: string;
+    externalConversationId: string;
+    sessionId: string;
+    createRequestId: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type GatewayStore = {
+    version: 1;
+    channels: GatewayChannelConfig[];
+    mappings: GatewayConversationMapping[];
+};
+export declare function readGatewayStore(): Promise<GatewayStore>;
+export declare function updateGatewayStore(update: (store: GatewayStore) => GatewayStore | Promise<GatewayStore>): Promise<GatewayStore>;

package/apps/cli/dist/commands/lib/gateway-store.js

@@ -0,0 +1,33 @@
+import fs from "node:fs/promises";
+import { configDir, gatewayStorePath } from "./paths.js";
+function emptyGatewayStore() {
+    return { version: 1, channels: [], mappings: [] };
+}
+export async function readGatewayStore() {
+    try {
+        const parsed = JSON.parse(await fs.readFile(gatewayStorePath, "utf8"));
+        if (parsed.version !== 1 || !Array.isArray(parsed.channels) || !Array.isArray(parsed.mappings)) {
+            return emptyGatewayStore();
+        }
+        return { version: 1, channels: parsed.channels, mappings: parsed.mappings };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return emptyGatewayStore();
+        throw error;
+    }
+}
+async function writeGatewayStore(store) {
+    await fs.mkdir(configDir, { recursive: true });
+    const tmpPath = `${gatewayStorePath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.writeFile(tmpPath, JSON.stringify(store, null, 2) + "\n", { mode: 0o600 });
+    await fs.rename(tmpPath, gatewayStorePath);
+    await fs.chmod(gatewayStorePath, 0o600);
+}
+export async function updateGatewayStore(update) {
+    const current = await readGatewayStore();
+    const next = await update(current);
+    await writeGatewayStore(next);
+    return next;
+}
+//# sourceMappingURL=gateway-store.js.map

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

@@ -1,5 +1,5 @@
-export { ControllerClient, type ScopedTokenScope } from "@happy-elves/client";
-export { generateAccountSecret, randomId } from "@happy-elves/shared";
+export { ControllerClient, type ScopedTokenScope } from "../../../../../packages/client/dist/index.js";
+export { generateAccountSecret, randomId } from "../../../../../packages/shared/dist/index.js";
 export { CliError } from "../../errors.js";
 export * from "./args.js";
 export * from "./audit.js";
@@ -10,10 +10,12 @@ export * from "./bootstrap-output.js";
 export * from "./config.js";
 export * from "./doctor.js";
 export * from "./exit.js";
+export * from "./gateway-store.js";
 export * from "./json.js";
 export * from "./local-daemon.js";
 export * from "./loop-store.js";
 export * from "./paths.js";
+export * from "./relay-db-audit.js";
 export * from "./relay-http.js";
 export * from "./scope.js";
 export * from "./session-output.js";

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

@@ -10,10 +10,12 @@ export * from "./bootstrap-output.js";
 export * from "./config.js";
 export * from "./doctor.js";
 export * from "./exit.js";
+export * from "./gateway-store.js";
 export * from "./json.js";
 export * from "./local-daemon.js";
 export * from "./loop-store.js";
 export * from "./paths.js";
+export * from "./relay-db-audit.js";
 export * from "./relay-http.js";
 export * from "./scope.js";
 export * from "./session-output.js";

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

@@ -1,5 +1,5 @@
-import type { JsonEnvelope } from "@happy-elves/shared";
-export declare function ok<T>(type: string, data: T, meta?: JsonEnvelope["meta"]): void;
+import type { JsonEnvelope } from "../../../../../packages/shared/dist/index.js";
+export declare function ok<T>(type: string, data: T, meta?: JsonEnvelope["meta"], success?: boolean): void;
 export declare function writeError(code: string, message: string, meta?: JsonEnvelope["meta"], capability?: string): void;
 export declare function wantsJson(flags: Record<string, string | boolean>): boolean;
 export declare function wantsVerbose(flags: Record<string, string | boolean>): boolean;

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

@@ -1,5 +1,8 @@
-export function ok(type, data, meta = {}) {
-    console.log(JSON.stringify({ ok: true, type, data, meta }, null, 2));
+export function ok(type, data, meta = {}, success = true) {
+    const envelope = success
+        ? { ok: true, type, data, meta }
+        : { ok: false, type, data, meta };
+    console.log(JSON.stringify(envelope, null, 2));
 }
 export function writeError(code, message, meta = {}, capability) {
     console.error(JSON.stringify({

package/apps/cli/dist/commands/lib/local-daemon.d.ts

@@ -4,6 +4,7 @@ export declare function localDaemonStatus(): Promise<{
     running: boolean;
 }>;
 export declare function daemonBinaryUpdatedAfterStart(status: Awaited<ReturnType<typeof localDaemonStatus>>): Promise<boolean>;
+export declare function daemonConfigUpdatedAfterStart(status: Awaited<ReturnType<typeof localDaemonStatus>>): Promise<boolean>;
 export declare function spawnDaemonStart(args: string[], cwd?: string): number;
 export declare function stopLocalDaemon(timeoutMs?: number): Promise<{
     pidPath: string;

package/apps/cli/dist/commands/lib/local-daemon.js

@@ -102,6 +102,20 @@ export async function daemonBinaryUpdatedAfterStart(status) {
         return false;
     }
 }
+export async function daemonConfigUpdatedAfterStart(status) {
+    if (!status.running || !status.pid)
+        return false;
+    const startedAt = readProcessStartedAtMs(status.pid);
+    if (!startedAt)
+        return false;
+    try {
+        const config = await fs.stat(path.join(configDir, "daemon.json"));
+        return config.mtimeMs > startedAt + 1000;
+    }
+    catch {
+        return false;
+    }
+}
 export function spawnDaemonStart(args, cwd = process.cwd()) {
     const child = spawn(process.execPath, [daemonCliPath(), "start", ...args], {
         cwd,

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

@@ -7,3 +7,5 @@ export declare const startDaemonTimeoutMs = 10000;
 export declare const daemonPidPath: string;
 export declare const loopStorePath: string;
 export declare const loopStoreLockPath: string;
+export declare const gatewayStorePath: string;
+export declare const releaseProfilesPath: string;

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

@@ -11,4 +11,6 @@ export const startDaemonTimeoutMs = 10_000;
 export const daemonPidPath = path.join(configDir, "daemon.pid");
 export const loopStorePath = path.join(configDir, "loops.json");
 export const loopStoreLockPath = path.join(configDir, "loops.json.lock");
+export const gatewayStorePath = path.join(configDir, "gateway.json");
+export const releaseProfilesPath = path.join(configDir, "release-profiles.json");
 //# sourceMappingURL=paths.js.map