@cydm/happy-elves 0.1.0-beta.50 → 0.1.0-beta.501

package/README.md

@@ -2,16 +2,19 @@
 
 Public beta CLI for Happy Elves.
 
+## First-time hosted machine attach (Windows)
+
+Run once in the existing user account; it detects %USERPROFILE%\.happy-elves\hosted, keeps the current daemon and sessions running, installs the independent updater, and registers per-user startup.
+
+    npm.cmd install --prefix $HOME\.happy-elves\management-entry --ignore-scripts --no-audit --no-fund --package-lock=false @cydm/happy-elves@0.1.0-beta.501
+    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.501 -- happy-elves-updater install --state-root $HOME\.happy-elves\hosted --autostart
+
+The same updater entrypoint works on macOS after selecting a permanent user prefix.
+
 ## Hosted relay
 
-```bash
-happy-elves account create --relay https://relay.happyelves.ai --device-name "CLI" --json
-```
+    happy-elves account create --relay https://relay.happyelves.ai --device-name CLI --json
 
 ## 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
-```
+    happy-elves relay serve --host 0.0.0.0 --port 8787 --json

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

@@ -49,3 +49,4 @@ export async function handleAccount({ domain, action, flags }) {
     }
     return false;
 }
+//# sourceMappingURL=account.js.map

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

@@ -4,15 +4,22 @@ import { handleAccount } from "./account.js";
 import { handleCollect } from "./collect.js";
 import { handleConfig } from "./config.js";
 import { handleDaemon } from "./daemon.js";
+import { handleDispatch } from "./dispatch.js";
+import { handleArtifact } from "./artifact.js";
+import { handleGateway } from "./gateway.js";
 import { handleLoop } from "./loop.js";
 import { handleMachine } from "./machine.js";
-import { handleOrchestrator } from "./orchestrator.js";
+import { handleMemory } from "./memory.js";
+import { handleQueue } from "./queue.js";
 import { handleRelay } from "./relay.js";
+import { handleRelease } from "./release.js";
+import { handleSchedule } from "./schedule.js";
 import { handleRemote } from "./remote.js";
 import { handleSession } from "./session.js";
-import { handleSkill } from "./skill.js";
+import { handleSidechat } from "./sidechat.js";
 import { handleToken } from "./token.js";
 import { handleTurn } from "./turn.js";
+import { handleWorkspace } from "./workspace.js";
 import { commandUsage, commandUsageText, handleCliError, parseCliFlags, skillText, startBootstrap, topLevelDoctor, topLevelStatus, usage, usageText } from "./lib/index.js";
 export { handleCliError };
 const domainHandlers = [
@@ -20,14 +27,21 @@ const domainHandlers = [
     handleConfig,
     handleRemote,
     handleToken,
+    handleGateway,
     handleLoop,
+    handleDispatch,
+    handleQueue,
+    handleArtifact,
+    handleSidechat,
     handleDaemon,
     handleRelay,
+    handleRelease,
     handleMachine,
-    handleOrchestrator,
+    handleMemory,
+    handleSchedule,
     handleSession,
-    handleSkill,
     handleTurn,
+    handleWorkspace,
     handleCollect,
 ];
 export async function main() {
@@ -35,7 +49,7 @@ export async function main() {
     const [domain] = argv;
     if (!domain)
         usage();
-    if (domain === "--skill") {
+    if (domain === "--skill" || domain === "skill") {
         console.log(skillText());
         return;
     }
@@ -101,3 +115,4 @@ function cliVersion() {
     }
     return "0.1.0";
 }
+//# sourceMappingURL=app.js.map

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

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

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

@@ -0,0 +1,97 @@
+import { CliError, ControllerClient, ok, readConfig, requirePositional, requireString, wantsJson, } from "./lib/index.js";
+export async function handleArtifact({ domain, action, positional, flags }) {
+    if (domain !== "artifact")
+        return false;
+    const config = await readConfig(flags);
+    const client = new ControllerClient(config);
+    if (action === "register") {
+        const machineId = requireString(flags, "machine");
+        const consumerSessionId = requireString(flags, "consumer-session");
+        const file = requireString(flags, "file");
+        const publish = typeof flags.publish === "string" ? flags.publish : undefined;
+        if (publish !== undefined && publish !== "relay") {
+            throw new CliError(`Unsupported --publish value: ${publish}`, "INVALID_ARGUMENT");
+        }
+        const result = await client.artifactRegister({
+            machineId,
+            consumerSessionId,
+            file,
+            ...(typeof flags["artifact-id"] === "string" ? { artifactId: flags["artifact-id"] } : {}),
+            ...(typeof flags["task-id"] === "string" ? { taskId: flags["task-id"] } : {}),
+            ...(typeof flags["crew-session"] === "string" ? { crewSessionId: flags["crew-session"] } : {}),
+            ...(typeof flags["turn-id"] === "string" ? { turnId: flags["turn-id"] } : {}),
+            ...(typeof flags.title === "string" ? { title: flags.title } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+            ...(publish === "relay" ? { publish: "relay" } : {}),
+        });
+        if (!wantsJson(flags)) {
+            console.log(`${result.artifactId}  rev:${result.revision}  ${result.admission}/${result.publishState}  ${result.url}`);
+            if (result.publishState === "failed")
+                process.exitCode = 1;
+            return true;
+        }
+        ok("artifact.register", result, { requestId: result.requestId, machineId }, result.publishState !== "failed");
+        if (result.publishState === "failed")
+            process.exitCode = 1;
+        return true;
+    }
+    if (action === "list") {
+        const machineId = requireString(flags, "machine");
+        const result = await client.artifactList({
+            machineId,
+            ...(typeof flags["consumer-session"] === "string" ? { consumerSessionId: flags["consumer-session"] } : {}),
+            ...(typeof flags["task-id"] === "string" ? { taskId: flags["task-id"] } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            if (result.records.length === 0)
+                console.log("No artifacts.");
+            else
+                for (const record of result.records) {
+                    console.log(`${record.artifactId}  rev:${record.revision}  ${record.publishState}  consumer:${record.consumerSessionId}  task:${record.taskId ?? "-"}`);
+                }
+            return true;
+        }
+        ok("artifact.list", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    if (action === "status") {
+        const machineId = requireString(flags, "machine");
+        const artifactId = requirePositional(positional[0], "artifactId");
+        const result = await client.artifactStatus({
+            machineId,
+            artifactId,
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            const artifact = result.artifact;
+            console.log(artifact ? `${artifact.artifactId}  rev:${artifact.revision}  ${artifact.publishState}  feedback:${artifact.feedbackCursor ?? "-"}` : "Artifact not found.");
+            return true;
+        }
+        ok("artifact.status", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    if (action === "feedback" && positional[0] === "list") {
+        const machineId = requireString(flags, "machine");
+        const artifactId = requirePositional(positional[1], "artifactId");
+        const result = await client.artifactFeedbackList({
+            machineId,
+            artifactId,
+            ...(typeof flags.after === "string" ? { after: flags.after } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            if (result.records.length === 0)
+                console.log("No feedback.");
+            else
+                for (const record of result.records) {
+                    console.log(`${record.feedbackCursor}  ${record.kind}  rev:${record.revision}  ${record.prompt}`);
+                }
+            return true;
+        }
+        ok("artifact.feedback.list", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=artifact.js.map

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

@@ -28,3 +28,4 @@ export async function handleCollect({ domain, action, flags }) {
     }
     return true;
 }
+//# sourceMappingURL=collect.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=command.js.map

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

@@ -1,4 +1,4 @@
-import { configPath, ok, readConfig, redactedControllerConfig, redactedRelayUrl, requireRelayUrl, requireString, wantsJson, writeConfig } from "./lib/index.js";
+import { configPath, ok, readConfig, redactedControllerConfig, requireRelayUrl, requireString, wantsJson, writeConfig } from "./lib/index.js";
 export async function handleConfig({ domain, action, flags }) {
     if (domain === "config" && action === "init") {
         const config = {
@@ -7,7 +7,7 @@ export async function handleConfig({ domain, action, flags }) {
             accountSecret: requireString(flags, "secret"),
         };
         await writeConfig(config);
-        ok("config.init", { path: configPath, relayUrl: redactedRelayUrl(config.relayUrl) });
+        ok("config.init", { path: configPath, relayUrl: config.relayUrl });
         return true;
     }
     if (domain === "config" && action === "show") {
@@ -28,3 +28,4 @@ export async function handleConfig({ domain, action, flags }) {
     }
     return false;
 }
+//# sourceMappingURL=config.js.map

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

@@ -1,6 +1,6 @@
 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";
+import { CliError, compactText, ControllerClient, configDir, configPath, deriveOrchestration, ensureDaemonRunning, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, restartDaemonForNewConfig, showMachine, stopLocalDaemon, throwRelayHttpError, waitForMachineProjection, wantsJson, writeDaemonConfig } from "./lib/index.js";
 export async function handleDaemon({ domain, action, flags }) {
     if (domain === "daemon" && action === "pair") {
         const relayUrl = requireRelayUrl(flags);
@@ -25,11 +25,87 @@ export async function handleDaemon({ domain, action, flags }) {
             machineToken: claimed.machineToken,
             accountSecret,
         };
+        const localBefore = await localDaemonStatus();
         const daemonConfigPath = await writeDaemonConfig(daemonConfig);
-        ok("daemon.pair", {
+        let daemonStart = { skipped: true, reason: "not requested" };
+        let projection = { checked: false, reason: "not checked" };
+        let startError;
+        if (flags["no-start"] === true) {
+            daemonStart = { skipped: true, reason: "--no-start" };
+            projection = { checked: false, reason: "--no-start" };
+        }
+        else {
+            try {
+                const startResult = localBefore.running
+                    ? await restartDaemonForNewConfig(relayUrl)
+                    : await ensureDaemonRunning(relayUrl);
+                daemonStart = {
+                    skipped: false,
+                    restarted: localBefore.running,
+                    local: startResult.local,
+                    started: startResult.started,
+                    ...(startResult.startedPid ? { startedPid: startResult.startedPid } : {}),
+                    ...("stopped" in startResult ? { stop: startResult.stopped } : {}),
+                };
+                try {
+                    const controllerConfig = await readConfig({ relay: relayUrl });
+                    const machine = await waitForMachineProjection(new ControllerClient(controllerConfig), claimed.machineId, 10_000);
+                    projection = {
+                        checked: true,
+                        online: machine?.online === true,
+                        machineId: claimed.machineId,
+                        ...(machine?.lastSeen ? { lastSeen: machine.lastSeen } : {}),
+                    };
+                }
+                catch (error) {
+                    projection = {
+                        checked: false,
+                        reason: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
+            catch (error) {
+                const code = error instanceof CliError ? error.code : "DAEMON_START_FAILED";
+                startError = { code, message: error instanceof Error ? error.message : String(error) };
+                process.exitCode = 1;
+                daemonStart = { skipped: true, reason: "start failed" };
+                projection = { checked: false, reason: "daemon did not start" };
+            }
+        }
+        const data = {
             path: daemonConfigPath,
             config: redactedDaemonConfig(daemonConfig),
-        });
+            daemon: daemonStart,
+            projection,
+            ...(startError ? { error: startError } : {}),
+        };
+        const commandOk = !startError && !(projection.checked && !projection.online);
+        if (!commandOk)
+            process.exitCode = 1;
+        if (!wantsJson(flags)) {
+            console.log(`Paired ${machineName} with ${relayUrl}`);
+            console.log(`Config: ${daemonConfigPath}`);
+            if (startError) {
+                console.error(`Daemon start failed: ${startError.message}`);
+            }
+            else if (daemonStart.skipped) {
+                console.log(`Daemon start: skipped (${daemonStart.reason})`);
+            }
+            else {
+                console.log(`${daemonStart.restarted ? "Restarted" : "Started"} daemon${daemonStart.startedPid ? ` pid ${daemonStart.startedPid}` : ""}`);
+            }
+            if (projection.checked) {
+                console.log(`Relay projection: ${projection.online ? "online" : "offline"} (${projection.machineId})`);
+                if (!projection.online) {
+                    console.log("If this stays offline, run happy-elves daemon logs --tail 100 and happy-elves daemon status --local.");
+                }
+            }
+            else {
+                console.log(`Relay projection: not checked (${projection.reason})`);
+            }
+            return true;
+        }
+        ok("daemon.pair", data, { machineId: claimed.machineId }, commandOk);
         return true;
     }
     if (domain === "daemon" && action === "doctor") {
@@ -57,9 +133,13 @@ export async function handleDaemon({ domain, action, flags }) {
             for (const check of checks) {
                 console.log(`${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`);
             }
+            if (!data.ok)
+                process.exitCode = 1;
             return true;
         }
-        ok("daemon.doctor", data);
+        if (!data.ok)
+            process.exitCode = 1;
+        ok("daemon.doctor", data, {}, data.ok);
         return true;
     }
     if (domain === "daemon" && action === "config") {
@@ -114,13 +194,21 @@ export async function handleDaemon({ domain, action, flags }) {
     if (domain === "daemon" && action === "start") {
         const status = await localDaemonStatus();
         if (status.running) {
+            const existingConfig = await readDaemonConfig();
+            if (typeof flags.relay === "string")
+                existingConfig.relayUrl = requireRelayUrl(flags);
+            const restarted = await ensureDaemonRunning(existingConfig.relayUrl);
+            if (restarted.started) {
+                ok("daemon.start", { ...restarted.local, started: true, startedPid: restarted.startedPid, restartedForChangedConfig: true });
+                return true;
+            }
             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 });
+        const daemonConfig = await readDaemonConfig();
+        const relayUrl = typeof flags.relay === "string" ? requireRelayUrl(flags) : daemonConfig.relayUrl;
+        const started = await ensureDaemonRunning(relayUrl);
+        ok("daemon.start", { ...started.local, started: started.started, startedPid: started.startedPid, startupLogPath: path.join(configDir, "daemon.startup.log") });
         return true;
     }
     if (domain === "daemon" && action === "stop") {
@@ -128,11 +216,10 @@ export async function handleDaemon({ domain, action, flags }) {
         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 });
+        const daemonConfig = await readDaemonConfig();
+        const relayUrl = typeof flags.relay === "string" ? requireRelayUrl(flags) : daemonConfig.relayUrl;
+        const restarted = await restartDaemonForNewConfig(relayUrl);
+        ok("daemon.restart", { stop: restarted.stopped, ...restarted.local, startedPid: restarted.startedPid, startupLogPath: path.join(configDir, "daemon.startup.log") });
         return true;
     }
     if (domain === "daemon" && action === "status" && flags.local === true) {
@@ -216,3 +303,4 @@ export async function handleDaemon({ domain, action, flags }) {
     }
     return false;
 }
+//# sourceMappingURL=daemon.js.map

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

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

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

@@ -0,0 +1,130 @@
+import { CliError, ControllerClient, ok, parsePermissionMode, readConfig, readPromptTextFile, requirePositional, requireString, wantsJson, } from "./lib/index.js";
+export async function handleDispatch({ domain, action, positional, flags }) {
+    if (domain !== "dispatch")
+        return false;
+    const config = await readConfig(flags);
+    const client = new ControllerClient(config);
+    if (action === "run") {
+        const machineId = requireString(flags, "machine");
+        const consumerSessionId = requireString(flags, "consumer-session");
+        const agent = requireString(flags, "agent");
+        const cwd = requireString(flags, "cwd");
+        const briefFile = requireString(flags, "brief-file");
+        const brief = await readPromptTextFile(briefFile);
+        if (!brief.trim())
+            throw new CliError("--brief-file is empty", "MISSING_ARGUMENT");
+        if (typeof flags["crew-session"] === "string" && typeof flags["fork-from-crew"] === "string") {
+            throw new CliError("--crew-session and --fork-from-crew are mutually exclusive", "INVALID_ARGUMENT");
+        }
+        const routeDecision = routeDecisionFromFlags(flags);
+        const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
+        const result = await client.dispatchRun({
+            machineId,
+            consumerSessionId,
+            agent,
+            cwd,
+            brief,
+            ...(typeof flags["task-id"] === "string" ? { taskId: flags["task-id"] } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+            ...(typeof flags["crew-session"] === "string" ? { crewSessionId: flags["crew-session"] } : {}),
+            ...(typeof flags["fork-from-crew"] === "string" ? { forkFromCrewSessionId: flags["fork-from-crew"] } : {}),
+            ...(typeof flags["fork-checkpoint"] === "string" ? { forkCheckpointId: flags["fork-checkpoint"] } : {}),
+            ...(routeDecision ? { routeDecision } : {}),
+            ...(permissionMode ? { permissionMode } : {}),
+            ...(typeof flags.model === "string" ? { model: flags.model } : {}),
+            ...(typeof flags["thinking-level"] === "string" ? { thinkingLevel: flags["thinking-level"] } : {}),
+            subscribe: flags.subscribe !== false,
+        });
+        if (!wantsJson(flags)) {
+            console.log(`${result.taskId}  ${result.admission}/${result.dispatch}  owner:${result.consumerMachineId ?? "-"}  crewMachine:${result.crewMachineId ?? machineId}  crew:${result.crewSessionId ?? "-"}  turn:${result.turnId ?? "-"}`);
+            return true;
+        }
+        ok("dispatch.run", result, {
+            requestId: result.requestId,
+            machineId: result.consumerMachineId ?? machineId,
+            consumerMachineId: result.consumerMachineId ?? machineId,
+            crewMachineId: result.crewMachineId ?? machineId,
+            sessionId: result.crewSessionId,
+            turnId: result.turnId,
+        }, result.dispatch !== "failed");
+        return true;
+    }
+    if (action === "status") {
+        const machineId = requireString(flags, "machine");
+        const taskId = requirePositional(positional[0], "taskId");
+        const result = await client.dispatchStatus({
+            machineId,
+            taskId,
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            const admission = result.admission;
+            const attention = result.attention;
+            console.log(`${result.taskId}  admission:${admission?.admission ?? "-"}  dispatch:${admission?.dispatch ?? "-"}  attention:${attention?.status ?? "-"}`);
+            return true;
+        }
+        ok("dispatch.status", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    if (action === "list") {
+        const machineId = requireString(flags, "machine");
+        const result = await client.dispatchList({
+            machineId,
+            ...(typeof flags["consumer-session"] === "string" ? { consumerSessionId: flags["consumer-session"] } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            for (const record of result.records) {
+                const attention = record.attention;
+                const reason = attention?.reasons.at(-1) ?? record.error ?? record.briefPreview ?? "";
+                console.log([
+                    record.taskId,
+                    `dispatch:${record.dispatch}`,
+                    `attention:${attention?.status ?? "-"}`,
+                    `crew:${record.crewSessionId ?? "-"}`,
+                    reason ? `reason:${reason}` : "",
+                ].filter(Boolean).join("  "));
+            }
+            return true;
+        }
+        ok("dispatch.list", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    return false;
+}
+function routeDecisionFromFlags(flags) {
+    const raw = flags["route-decision"];
+    const ifBusy = flags["if-busy"];
+    if (ifBusy !== undefined && ifBusy !== "queue") {
+        throw new CliError("--if-busy must be queue", "INVALID_ARGUMENT");
+    }
+    if (typeof raw !== "string") {
+        if (ifBusy === "queue" && typeof flags["crew-session"] === "string" && typeof flags["fork-from-crew"] !== "string") {
+            return { kind: "reuse", crewSessionId: flags["crew-session"], ifBusy };
+        }
+        if (ifBusy === "queue")
+            throw new CliError("--if-busy queue requires --crew-session or --route-decision reuse", "INVALID_ARGUMENT");
+        return undefined;
+    }
+    if (raw === "new") {
+        if (ifBusy === "queue")
+            throw new CliError("--if-busy queue is only valid with --route-decision reuse", "INVALID_ARGUMENT");
+        return { kind: "new" };
+    }
+    if (raw === "reuse") {
+        const crewSessionId = requireString(flags, "crew-session");
+        return { kind: "reuse", crewSessionId, ...(ifBusy === "queue" ? { ifBusy } : {}) };
+    }
+    if (ifBusy === "queue")
+        throw new CliError("--if-busy queue is only valid with --route-decision reuse", "INVALID_ARGUMENT");
+    if (raw === "fork") {
+        const crewSessionId = requireString(flags, "fork-from-crew");
+        return {
+            kind: "fork",
+            crewSessionId,
+            ...(typeof flags["fork-checkpoint"] === "string" ? { forkCheckpointId: flags["fork-checkpoint"] } : {}),
+        };
+    }
+    throw new CliError("--route-decision must be one of new, reuse, or fork", "INVALID_ARGUMENT");
+}
+//# sourceMappingURL=dispatch.js.map

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

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