@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/cli/cron-cli/register.cron-add.js

@@ -59,8 +59,10 @@ export function registerCronAddCommand(cron) {
         .option("--wake <mode>", "Wake mode (now|next-heartbeat)", "now")
         .option("--at <when>", "Run once at time (ISO) or +duration (e.g. 20m)")
         .option("--every <duration>", "Run every duration (e.g. 10m, 1h)")
-        .option("--cron <expr>", "Cron expression (5-field)")
+        .option("--cron <expr>", "Cron expression (5-field or 6-field with seconds)")
         .option("--tz <iana>", "Timezone for cron expressions (IANA)", "")
+        .option("--stagger <duration>", "Cron stagger window (e.g. 30s, 5m)")
+        .option("--exact", "Disable cron staggering (set stagger to 0)", false)
         .option("--system-event <text>", "System event payload (main session)")
         .option("--message <text>", "Agent message payload")
         .option("--thinking <level>", "Thinking level for agent jobs (off|minimal|low|medium|high)")
@@ -75,6 +77,11 @@ export function registerCronAddCommand(cron) {
         .option("--json", "Output JSON", false)
         .action(async (opts, cmd) => {
         try {
+            const staggerRaw = typeof opts.stagger === "string" ? opts.stagger.trim() : "";
+            const useExact = Boolean(opts.exact);
+            if (staggerRaw && useExact) {
+                throw new Error("Choose either --stagger or --exact, not both");
+            }
             const schedule = (() => {
                 const at = typeof opts.at === "string" ? opts.at : "";
                 const every = typeof opts.every === "string" ? opts.every : "";
@@ -83,6 +90,9 @@ export function registerCronAddCommand(cron) {
                 if (chosen !== 1) {
                     throw new Error("Choose exactly one schedule: --at, --every, or --cron");
                 }
+                if ((useExact || staggerRaw) && !cronExpr) {
+                    throw new Error("--stagger/--exact are only valid with --cron");
+                }
                 if (at) {
                     const atIso = parseAt(at);
                     if (!atIso) {
@@ -97,10 +107,24 @@ export function registerCronAddCommand(cron) {
                     }
                     return { kind: "every", everyMs };
                 }
+                const staggerMs = (() => {
+                    if (useExact) {
+                        return 0;
+                    }
+                    if (!staggerRaw) {
+                        return undefined;
+                    }
+                    const parsed = parseDurationMs(staggerRaw);
+                    if (!parsed) {
+                        throw new Error("Invalid --stagger; use e.g. 30s, 1m, 5m");
+                    }
+                    return parsed;
+                })();
                 return {
                     kind: "cron",
                     expr: cronExpr,
                     tz: typeof opts.tz === "string" && opts.tz.trim() ? opts.tz.trim() : undefined,
+                    staggerMs,
                 };
             })();
             const wakeModeRaw = typeof opts.wake === "string" ? opts.wake : "now";

package/dist/cli/cron-cli/register.cron-edit.js

@@ -27,6 +27,8 @@ export function registerCronEditCommand(cron) {
         .option("--every <duration>", "Set interval duration like 10m")
         .option("--cron <expr>", "Set cron expression")
         .option("--tz <iana>", "Timezone for cron expressions (IANA)")
+        .option("--stagger <duration>", "Cron stagger window (e.g. 30s, 5m)")
+        .option("--exact", "Disable cron staggering (set stagger to 0)")
         .option("--system-event <text>", "Set systemEvent payload")
         .option("--message <text>", "Set agentTurn payload message")
         .option("--thinking <level>", "Thinking level for agent jobs")
@@ -50,6 +52,24 @@ export function registerCronEditCommand(cron) {
             if (opts.announce && typeof opts.deliver === "boolean") {
                 throw new Error("Choose --announce or --no-deliver (not multiple).");
             }
+            const staggerRaw = typeof opts.stagger === "string" ? opts.stagger.trim() : "";
+            const useExact = Boolean(opts.exact);
+            if (staggerRaw && useExact) {
+                throw new Error("Choose either --stagger or --exact, not both");
+            }
+            const requestedStaggerMs = (() => {
+                if (useExact) {
+                    return 0;
+                }
+                if (!staggerRaw) {
+                    return undefined;
+                }
+                const parsed = parseDurationMs(staggerRaw);
+                if (!parsed) {
+                    throw new Error("Invalid --stagger; use e.g. 30s, 1m, 5m");
+                }
+                return parsed;
+            })();
             const patch = {};
             if (typeof opts.name === "string") {
                 patch.name = opts.name;
@@ -94,6 +114,10 @@ export function registerCronEditCommand(cron) {
             if (scheduleChosen > 1) {
                 throw new Error("Choose at most one schedule change");
             }
+            if ((requestedStaggerMs !== undefined || typeof opts.tz === "string") &&
+                (opts.at || opts.every)) {
+                throw new Error("--stagger/--exact/--tz are only valid for cron schedules");
+            }
             if (opts.at) {
                 const atIso = parseAt(String(opts.at));
                 if (!atIso) {
@@ -113,6 +137,26 @@ export function registerCronEditCommand(cron) {
                     kind: "cron",
                     expr: String(opts.cron),
                     tz: typeof opts.tz === "string" && opts.tz.trim() ? opts.tz.trim() : undefined,
+                    staggerMs: requestedStaggerMs,
+                };
+            }
+            else if (requestedStaggerMs !== undefined || typeof opts.tz === "string") {
+                const listed = (await callGatewayFromCli("cron.list", opts, {
+                    includeDisabled: true,
+                }));
+                const existing = (listed?.jobs ?? []).find((job) => job.id === id);
+                if (!existing) {
+                    throw new Error(`unknown cron job id: ${id}`);
+                }
+                if (existing.schedule.kind !== "cron") {
+                    throw new Error("Current job is not a cron schedule; use --cron to convert first");
+                }
+                const tz = typeof opts.tz === "string" ? opts.tz.trim() || undefined : existing.schedule.tz;
+                patch.schedule = {
+                    kind: "cron",
+                    expr: existing.schedule.expr,
+                    tz,
+                    staggerMs: requestedStaggerMs !== undefined ? requestedStaggerMs : existing.schedule.staggerMs,
                 };
             }
             const hasSystemEventPatch = typeof opts.systemEvent === "string";

package/dist/cli/cron-cli/shared.js

@@ -1,5 +1,6 @@
 import { listChannelPlugins } from "../../channels/plugins/index.js";
 import { parseAbsoluteTimeMs } from "../../cron/parse.js";
+import { resolveCronStaggerMs } from "../../cron/stagger.js";
 import { formatDurationHuman } from "../../infra/format-time/format-duration.js";
 import { defaultRuntime } from "../../runtime.js";
 import { colorize, isRich, theme } from "../../terminal/theme.js";
@@ -118,7 +119,12 @@ const formatSchedule = (schedule) => {
     if (schedule.kind === "every") {
         return `every ${formatDurationHuman(schedule.everyMs)}`;
     }
-    return schedule.tz ? `cron ${schedule.expr} @ ${schedule.tz}` : `cron ${schedule.expr}`;
+    const base = schedule.tz ? `cron ${schedule.expr} @ ${schedule.tz}` : `cron ${schedule.expr}`;
+    const staggerMs = resolveCronStaggerMs(schedule);
+    if (staggerMs <= 0) {
+        return `${base} (exact)`;
+    }
+    return `${base} (stagger ${formatDurationHuman(staggerMs)})`;
 };
 const formatStatus = (job) => {
     if (!job.enabled) {

package/dist/cli/daemon-cli/lifecycle-core.js

@@ -205,31 +205,33 @@ export async function runServiceRestart(params) {
         });
         return false;
     }
-    // Check for token drift before restart (service token vs config token)
     const warnings = [];
-    try {
-        const command = await params.service.readCommand(process.env);
-        const serviceToken = command?.environment?.POOLBOT_GATEWAY_TOKEN;
-        const cfg = loadConfig();
-        const configToken = cfg.gateway?.auth?.token ||
-            process.env.POOLBOT_GATEWAY_TOKEN ||
-            process.env.CLAWDBOT_GATEWAY_TOKEN;
-        const driftIssue = checkTokenDrift({ serviceToken, configToken });
-        if (driftIssue) {
-            const warning = driftIssue.detail
-                ? `${driftIssue.message} ${driftIssue.detail}`
-                : driftIssue.message;
-            warnings.push(warning);
-            if (!json) {
-                defaultRuntime.log(`\n⚠️  ${driftIssue.message}`);
-                if (driftIssue.detail) {
-                    defaultRuntime.log(`   ${driftIssue.detail}\n`);
+    if (params.checkTokenDrift) {
+        // Check for token drift before restart (service token vs config token)
+        try {
+            const command = await params.service.readCommand(process.env);
+            const serviceToken = command?.environment?.POOLBOT_GATEWAY_TOKEN;
+            const cfg = loadConfig();
+            const configToken = cfg.gateway?.auth?.token ||
+                process.env.POOLBOT_GATEWAY_TOKEN ||
+                process.env.CLAWDBOT_GATEWAY_TOKEN;
+            const driftIssue = checkTokenDrift({ serviceToken, configToken });
+            if (driftIssue) {
+                const warning = driftIssue.detail
+                    ? `${driftIssue.message} ${driftIssue.detail}`
+                    : driftIssue.message;
+                warnings.push(warning);
+                if (!json) {
+                    defaultRuntime.log(`\n⚠️  ${driftIssue.message}`);
+                    if (driftIssue.detail) {
+                        defaultRuntime.log(`   ${driftIssue.detail}\n`);
+                    }
                 }
             }
         }
-    }
-    catch {
-        // Non-fatal: token drift check is best-effort
+        catch {
+            // Non-fatal: token drift check is best-effort
+        }
     }
     try {
         await params.service.restart({ env: process.env, stdout });

package/dist/cli/daemon-cli/lifecycle.js

@@ -1,192 +1,28 @@
-import { resolveIsNixMode } from "../../config/paths.js";
 import { resolveGatewayService } from "../../daemon/service.js";
-import { isSystemdUserServiceAvailable } from "../../daemon/systemd.js";
-import { renderSystemdUnavailableHints } from "../../daemon/systemd-hints.js";
-import { isWSL } from "../../infra/wsl.js";
-import { defaultRuntime } from "../../runtime.js";
-import { buildDaemonServiceSnapshot, createNullWriter, emitDaemonActionJson } from "./response.js";
+import { runServiceRestart, runServiceStart, runServiceStop, runServiceUninstall, } from "./lifecycle-core.js";
 import { renderGatewayServiceStartHints } from "./shared.js";
 export async function runDaemonUninstall(opts = {}) {
-    const json = Boolean(opts.json);
-    const stdout = json ? createNullWriter() : process.stdout;
-    const emit = (payload) => {
-        if (!json)
-            return;
-        emitDaemonActionJson({ action: "uninstall", ...payload });
-    };
-    const fail = (message) => {
-        if (json)
-            emit({ ok: false, error: message });
-        else
-            defaultRuntime.error(message);
-        defaultRuntime.exit(1);
-    };
-    if (resolveIsNixMode(process.env)) {
-        fail("Nix mode detected; service uninstall is disabled.");
-        return;
-    }
-    const service = resolveGatewayService();
-    let loaded = false;
-    try {
-        loaded = await service.isLoaded({ env: process.env });
-    }
-    catch {
-        loaded = false;
-    }
-    if (loaded) {
-        try {
-            await service.stop({ env: process.env, stdout });
-        }
-        catch {
-            // Best-effort stop; final loaded check gates success.
-        }
-    }
-    try {
-        await service.uninstall({ env: process.env, stdout });
-    }
-    catch (err) {
-        fail(`Gateway uninstall failed: ${String(err)}`);
-        return;
-    }
-    loaded = false;
-    try {
-        loaded = await service.isLoaded({ env: process.env });
-    }
-    catch {
-        loaded = false;
-    }
-    if (loaded) {
-        fail("Gateway service still loaded after uninstall.");
-        return;
-    }
-    emit({
-        ok: true,
-        result: "uninstalled",
-        service: buildDaemonServiceSnapshot(service, loaded),
+    return await runServiceUninstall({
+        serviceNoun: "Gateway",
+        service: resolveGatewayService(),
+        opts,
+        stopBeforeUninstall: true,
+        assertNotLoadedAfterUninstall: true,
     });
 }
 export async function runDaemonStart(opts = {}) {
-    const json = Boolean(opts.json);
-    const stdout = json ? createNullWriter() : process.stdout;
-    const emit = (payload) => {
-        if (!json)
-            return;
-        emitDaemonActionJson({ action: "start", ...payload });
-    };
-    const fail = (message, hints) => {
-        if (json)
-            emit({ ok: false, error: message, hints });
-        else
-            defaultRuntime.error(message);
-        defaultRuntime.exit(1);
-    };
-    const service = resolveGatewayService();
-    let loaded = false;
-    try {
-        loaded = await service.isLoaded({ env: process.env });
-    }
-    catch (err) {
-        fail(`Gateway service check failed: ${String(err)}`);
-        return;
-    }
-    if (!loaded) {
-        let hints = renderGatewayServiceStartHints();
-        if (process.platform === "linux") {
-            const systemdAvailable = await isSystemdUserServiceAvailable().catch(() => false);
-            if (!systemdAvailable) {
-                hints = [...hints, ...renderSystemdUnavailableHints({ wsl: await isWSL() })];
-            }
-        }
-        emit({
-            ok: true,
-            result: "not-loaded",
-            message: `Gateway service ${service.notLoadedText}.`,
-            hints,
-            service: buildDaemonServiceSnapshot(service, loaded),
-        });
-        if (!json) {
-            defaultRuntime.log(`Gateway service ${service.notLoadedText}.`);
-            for (const hint of hints) {
-                defaultRuntime.log(`Start with: ${hint}`);
-            }
-        }
-        return;
-    }
-    try {
-        await service.restart({ env: process.env, stdout });
-    }
-    catch (err) {
-        const hints = renderGatewayServiceStartHints();
-        fail(`Gateway start failed: ${String(err)}`, hints);
-        return;
-    }
-    let started = true;
-    try {
-        started = await service.isLoaded({ env: process.env });
-    }
-    catch {
-        started = true;
-    }
-    emit({
-        ok: true,
-        result: "started",
-        service: buildDaemonServiceSnapshot(service, started),
+    return await runServiceStart({
+        serviceNoun: "Gateway",
+        service: resolveGatewayService(),
+        renderStartHints: renderGatewayServiceStartHints,
+        opts,
     });
 }
 export async function runDaemonStop(opts = {}) {
-    const json = Boolean(opts.json);
-    const stdout = json ? createNullWriter() : process.stdout;
-    const emit = (payload) => {
-        if (!json)
-            return;
-        emitDaemonActionJson({ action: "stop", ...payload });
-    };
-    const fail = (message) => {
-        if (json)
-            emit({ ok: false, error: message });
-        else
-            defaultRuntime.error(message);
-        defaultRuntime.exit(1);
-    };
-    const service = resolveGatewayService();
-    let loaded = false;
-    try {
-        loaded = await service.isLoaded({ env: process.env });
-    }
-    catch (err) {
-        fail(`Gateway service check failed: ${String(err)}`);
-        return;
-    }
-    if (!loaded) {
-        emit({
-            ok: true,
-            result: "not-loaded",
-            message: `Gateway service ${service.notLoadedText}.`,
-            service: buildDaemonServiceSnapshot(service, loaded),
-        });
-        if (!json) {
-            defaultRuntime.log(`Gateway service ${service.notLoadedText}.`);
-        }
-        return;
-    }
-    try {
-        await service.stop({ env: process.env, stdout });
-    }
-    catch (err) {
-        fail(`Gateway stop failed: ${String(err)}`);
-        return;
-    }
-    let stopped = false;
-    try {
-        stopped = await service.isLoaded({ env: process.env });
-    }
-    catch {
-        stopped = false;
-    }
-    emit({
-        ok: true,
-        result: "stopped",
-        service: buildDaemonServiceSnapshot(service, stopped),
+    return await runServiceStop({
+        serviceNoun: "Gateway",
+        service: resolveGatewayService(),
+        opts,
     });
 }
 /**
@@ -195,71 +31,11 @@ export async function runDaemonStop(opts = {}) {
  * Throws/exits on check or restart failures.
  */
 export async function runDaemonRestart(opts = {}) {
-    const json = Boolean(opts.json);
-    const stdout = json ? createNullWriter() : process.stdout;
-    const emit = (payload) => {
-        if (!json)
-            return;
-        emitDaemonActionJson({ action: "restart", ...payload });
-    };
-    const fail = (message, hints) => {
-        if (json)
-            emit({ ok: false, error: message, hints });
-        else
-            defaultRuntime.error(message);
-        defaultRuntime.exit(1);
-    };
-    const service = resolveGatewayService();
-    let loaded = false;
-    try {
-        loaded = await service.isLoaded({ env: process.env });
-    }
-    catch (err) {
-        fail(`Gateway service check failed: ${String(err)}`);
-        return false;
-    }
-    if (!loaded) {
-        let hints = renderGatewayServiceStartHints();
-        if (process.platform === "linux") {
-            const systemdAvailable = await isSystemdUserServiceAvailable().catch(() => false);
-            if (!systemdAvailable) {
-                hints = [...hints, ...renderSystemdUnavailableHints({ wsl: await isWSL() })];
-            }
-        }
-        emit({
-            ok: true,
-            result: "not-loaded",
-            message: `Gateway service ${service.notLoadedText}.`,
-            hints,
-            service: buildDaemonServiceSnapshot(service, loaded),
-        });
-        if (!json) {
-            defaultRuntime.log(`Gateway service ${service.notLoadedText}.`);
-            for (const hint of hints) {
-                defaultRuntime.log(`Start with: ${hint}`);
-            }
-        }
-        return false;
-    }
-    try {
-        await service.restart({ env: process.env, stdout });
-        let restarted = true;
-        try {
-            restarted = await service.isLoaded({ env: process.env });
-        }
-        catch {
-            restarted = true;
-        }
-        emit({
-            ok: true,
-            result: "restarted",
-            service: buildDaemonServiceSnapshot(service, restarted),
-        });
-        return true;
-    }
-    catch (err) {
-        const hints = renderGatewayServiceStartHints();
-        fail(`Gateway restart failed: ${String(err)}`, hints);
-        return false;
-    }
+    return await runServiceRestart({
+        serviceNoun: "Gateway",
+        service: resolveGatewayService(),
+        renderStartHints: renderGatewayServiceStartHints,
+        opts,
+        checkTokenDrift: true,
+    });
 }

package/dist/cli/daemon-cli/register-service-commands.js

@@ -1,4 +1,25 @@
+import { inheritOptionFromParent } from "../command-options.js";
 import { runDaemonInstall, runDaemonRestart, runDaemonStart, runDaemonStatus, runDaemonStop, runDaemonUninstall, } from "./runners.js";
+function resolveInstallOptions(cmdOpts, command) {
+    const parentForce = inheritOptionFromParent(command, "force");
+    const parentPort = inheritOptionFromParent(command, "port");
+    const parentToken = inheritOptionFromParent(command, "token");
+    return {
+        ...cmdOpts,
+        force: Boolean(cmdOpts.force || parentForce),
+        port: cmdOpts.port ?? parentPort,
+        token: cmdOpts.token ?? parentToken,
+    };
+}
+function resolveRpcOptions(cmdOpts, command) {
+    const parentToken = inheritOptionFromParent(command, "token");
+    const parentPassword = inheritOptionFromParent(command, "password");
+    return {
+        ...cmdOpts,
+        token: cmdOpts.token ?? parentToken,
+        password: cmdOpts.password ?? parentPassword,
+    };
+}
 export function addGatewayServiceCommands(parent, opts) {
     parent
         .command("status")
@@ -10,9 +31,9 @@ export function addGatewayServiceCommands(parent, opts) {
         .option("--no-probe", "Skip RPC probe")
         .option("--deep", "Scan system-level services", false)
         .option("--json", "Output JSON", false)
-        .action(async (cmdOpts) => {
+        .action(async (cmdOpts, command) => {
         await runDaemonStatus({
-            rpc: cmdOpts,
+            rpc: resolveRpcOptions(cmdOpts, command),
             probe: Boolean(cmdOpts.probe),
             deep: Boolean(cmdOpts.deep),
             json: Boolean(cmdOpts.json),
@@ -26,8 +47,8 @@ export function addGatewayServiceCommands(parent, opts) {
         .option("--token <token>", "Gateway token (token auth)")
         .option("--force", "Reinstall/overwrite if already installed", false)
         .option("--json", "Output JSON", false)
-        .action(async (cmdOpts) => {
-        await runDaemonInstall(cmdOpts);
+        .action(async (cmdOpts, command) => {
+        await runDaemonInstall(resolveInstallOptions(cmdOpts, command));
     });
     parent
         .command("uninstall")

package/dist/cli/daemon-cli.js

@@ -1,2 +1,3 @@
 export { registerDaemonCli } from "./daemon-cli/register.js";
+export { addGatewayServiceCommands } from "./daemon-cli/register-service-commands.js";
 export { runDaemonInstall, runDaemonRestart, runDaemonStart, runDaemonStatus, runDaemonStop, runDaemonUninstall, } from "./daemon-cli/runners.js";

package/dist/cli/devices-cli.js

@@ -1,22 +1,10 @@
 import { callGateway } from "../gateway/call.js";
-import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";
+import { formatTimeAgo } from "../infra/format-time/format-relative.js";
 import { defaultRuntime } from "../runtime.js";
 import { renderTable } from "../terminal/table.js";
 import { theme } from "../terminal/theme.js";
+import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";
 import { withProgress } from "./progress.js";
-function formatAge(msAgo) {
-    const s = Math.max(0, Math.floor(msAgo / 1000));
-    if (s < 60)
-        return `${s}s`;
-    const m = Math.floor(s / 60);
-    if (m < 60)
-        return `${m}m`;
-    const h = Math.floor(m / 60);
-    if (h < 24)
-        return `${h}h`;
-    const d = Math.floor(h / 24);
-    return `${d}d`;
-}
 const devicesCallOpts = (cmd, defaults) => cmd
     .option("--url <url>", "Gateway WebSocket URL (defaults to gateway.remote.url when configured)")
     .option("--token <token>", "Gateway token (if required)")
@@ -44,12 +32,23 @@ function parseDevicePairingList(value) {
         paired: Array.isArray(obj.paired) ? obj.paired : [],
     };
 }
+function selectLatestPendingRequest(pending) {
+    if (!pending?.length) {
+        return null;
+    }
+    return pending.reduce((latest, current) => {
+        const latestTs = typeof latest.ts === "number" ? latest.ts : 0;
+        const currentTs = typeof current.ts === "number" ? current.ts : 0;
+        return currentTs > latestTs ? current : latest;
+    });
+}
 function formatTokenSummary(tokens) {
-    if (!tokens || tokens.length === 0)
+    if (!tokens || tokens.length === 0) {
         return "none";
+    }
     const parts = tokens
         .map((t) => `${t.role}${t.revokedAtMs ? " (revoked)" : ""}`)
-        .sort((a, b) => a.localeCompare(b));
+        .toSorted((a, b) => a.localeCompare(b));
     return parts.join(", ");
 }
 export function registerDevicesCli(program) {
@@ -82,7 +81,7 @@ export function registerDevicesCli(program) {
                     Device: req.displayName || req.deviceId,
                     Role: req.role ?? "",
                     IP: req.remoteIp ?? "",
-                    Age: typeof req.ts === "number" ? `${formatAge(Date.now() - req.ts)} ago` : "",
+                    Age: typeof req.ts === "number" ? formatTimeAgo(Date.now() - req.ts) : "",
                     Flags: req.isRepair ? "repair" : "",
                 })),
             }).trimEnd());
@@ -115,15 +114,29 @@ export function registerDevicesCli(program) {
     devicesCallOpts(devices
         .command("approve")
         .description("Approve a pending device pairing request")
-        .argument("<requestId>", "Pending request id")
+        .argument("[requestId]", "Pending request id")
+        .option("--latest", "Approve the most recent pending request", false)
         .action(async (requestId, opts) => {
-        const result = await callGatewayCli("device.pair.approve", opts, { requestId });
+        let resolvedRequestId = requestId?.trim();
+        if (!resolvedRequestId || opts.latest) {
+            const listResult = await callGatewayCli("device.pair.list", opts, {});
+            const latest = selectLatestPendingRequest(parseDevicePairingList(listResult).pending);
+            resolvedRequestId = latest?.requestId?.trim();
+        }
+        if (!resolvedRequestId) {
+            defaultRuntime.error("No pending device pairing requests to approve");
+            defaultRuntime.exit(1);
+            return;
+        }
+        const result = await callGatewayCli("device.pair.approve", opts, {
+            requestId: resolvedRequestId,
+        });
         if (opts.json) {
             defaultRuntime.log(JSON.stringify(result, null, 2));
             return;
         }
         const deviceId = result?.device?.deviceId;
-        defaultRuntime.log(`${theme.success("Approved")} ${theme.command(deviceId ?? "ok")}`);
+        defaultRuntime.log(`${theme.success("Approved")} ${theme.command(deviceId ?? "ok")} ${theme.muted(`(${resolvedRequestId})`)}`);
     }));
     devicesCallOpts(devices
         .command("reject")