@camerontaylor/paseo-cli 0.8.0-fork.1

package/dist/commands/daemon/status.js

@@ -0,0 +1,363 @@
+import { createRequire } from "node:module";
+import { getOrCreateServerId, findExecutable, execCommand } from "@camerontaylor/paseo-server";
+import { connectToDaemon } from "../../utils/client.js";
+import { resolveLocalDaemonState } from "./local-daemon.js";
+import { resolveNodePathFromPid } from "./runtime-toolchain.js";
+const DAEMON_STATUS_PROBE_TIMEOUT_MS = 1500;
+const require = createRequire(import.meta.url);
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function shortenMessage(message, max = 120) {
+    const normalized = message.replace(/\s+/g, " ").trim();
+    if (normalized.length <= max) {
+        return normalized;
+    }
+    return `${normalized.slice(0, max - 3)}...`;
+}
+function appendNote(current, next) {
+    if (!next)
+        return current;
+    if (!current)
+        return next;
+    return `${current}; ${next}`;
+}
+function resolveCliVersion() {
+    try {
+        const packageJson = require("../../../package.json");
+        if (typeof packageJson.version === "string" && packageJson.version.trim().length > 0) {
+            return packageJson.version.trim();
+        }
+    }
+    catch {
+        // Fall through.
+    }
+    return "unknown";
+}
+function createStatusSchema(status) {
+    return {
+        idField: "key",
+        columns: [
+            { header: "KEY", field: "key" },
+            {
+                header: "VALUE",
+                field: "value",
+                color: (_, item) => {
+                    if (item.key === "Local Daemon") {
+                        if (item.value === "running")
+                            return "green";
+                        if (item.value === "unresponsive")
+                            return "yellow";
+                        return "red";
+                    }
+                    if (item.key === "Connected Daemon") {
+                        if (item.value === "reachable")
+                            return "green";
+                        if (item.value === "not_probed" || item.value === "auth_required")
+                            return "yellow";
+                        return "red";
+                    }
+                    if (item.key.startsWith("  ")) {
+                        if (item.value === "not found" || item.value === "not found (daemon)")
+                            return "red";
+                        if (item.value.endsWith("(--version failed)"))
+                            return "yellow";
+                        return "green";
+                    }
+                    return undefined;
+                },
+            },
+        ],
+        serialize: () => status,
+    };
+}
+function toStatusRows(status) {
+    const rows = [
+        { key: "Server ID", value: status.serverId ?? "-" },
+        { key: "Local Daemon", value: status.localDaemon },
+        { key: "Connected Daemon", value: status.connectedDaemon },
+        { key: "Home", value: status.home },
+        { key: "Listen", value: status.listen },
+        { key: "Relay", value: status.relay },
+        { key: "Hostname", value: status.hostname ?? "-" },
+        { key: "PID", value: status.pid === null ? "-" : String(status.pid) },
+        { key: "Started", value: status.startedAt ?? "-" },
+        { key: "Owner", value: status.owner ?? "-" },
+        { key: "Logs", value: status.logPath },
+        { key: "Daemon Node", value: status.daemonNode },
+        { key: "CLI Node", value: status.cliNode },
+        { key: "CLI", value: status.cliVersion },
+        { key: "Daemon Version", value: status.daemonVersion ?? "-" },
+    ];
+    if (status.note) {
+        rows.push({ key: "Note", value: status.note });
+    }
+    rows.push({ key: "", value: "" });
+    rows.push({ key: "Providers", value: "" });
+    for (const provider of status.providers) {
+        if (provider.source === "daemon") {
+            if (!provider.path) {
+                rows.push({ key: `  ${provider.label}`, value: "not found (daemon)" });
+            }
+            else {
+                rows.push({ key: `  ${provider.label}`, value: `${provider.path} (daemon)` });
+            }
+        }
+        else if (!provider.path) {
+            rows.push({ key: `  ${provider.label}`, value: "not found" });
+        }
+        else if (!provider.version) {
+            rows.push({ key: `  ${provider.label}`, value: `${provider.path} (--version failed)` });
+        }
+        else {
+            rows.push({ key: `  ${provider.label}`, value: `${provider.path} (${provider.version})` });
+        }
+    }
+    return rows;
+}
+const PROVIDER_BINARIES = [
+    { label: "Claude", binary: "claude" },
+    { label: "Codex", binary: "codex" },
+    { label: "OpenCode", binary: "opencode" },
+];
+async function checkProviderBinary(binary) {
+    const binaryPath = await findExecutable(binary);
+    if (!binaryPath) {
+        return { path: null, version: null };
+    }
+    try {
+        const { stdout } = await execCommand(binaryPath, ["--version"], {
+            timeout: 5000,
+        });
+        return { path: binaryPath, version: stdout.trim() || null };
+    }
+    catch {
+        return { path: binaryPath, version: null };
+    }
+}
+async function checkProviderBinaries() {
+    const results = await Promise.all(PROVIDER_BINARIES.map(async ({ label, binary }) => {
+        const result = await checkProviderBinary(binary);
+        return Object.assign({ label }, result);
+    }));
+    return results;
+}
+function resolveOwnerLabel(uid, hostname) {
+    if (uid === undefined && !hostname) {
+        return null;
+    }
+    const uidPart = uid === undefined ? "?" : String(uid);
+    const hostPart = hostname ?? "unknown-host";
+    return `${uidPart}@${hostPart}`;
+}
+function classifyDaemonAuthProbeFailure(error) {
+    if (!(error instanceof Error))
+        return null;
+    if (error.message === "Password required")
+        return "auth_required";
+    if (error.message === "Incorrect password")
+        return "auth_failed";
+    return null;
+}
+function describeDaemonAuthProbeFailure(host, failure) {
+    if (failure === "auth_required") {
+        return `Daemon is reachable at ${host} but requires a password. Set PASEO_PASSWORD and retry.`;
+    }
+    return `Daemon is reachable at ${host} but the supplied password was rejected. Check PASEO_PASSWORD and retry.`;
+}
+async function probeDaemonOverWebsocket(args) {
+    const { host, state } = args;
+    let client;
+    try {
+        client = await connectToDaemon({ host, timeout: 1500 });
+    }
+    catch (error) {
+        const authFailure = classifyDaemonAuthProbeFailure(error);
+        if (authFailure) {
+            return {
+                connectedDaemon: authFailure,
+                note: describeDaemonAuthProbeFailure(host, authFailure),
+            };
+        }
+        if (state.running) {
+            return {
+                connectedDaemon: "unreachable",
+                localDaemonOverride: "unresponsive",
+                note: `Local daemon PID is running but websocket at ${host} is not reachable`,
+            };
+        }
+        return { connectedDaemon: "unreachable" };
+    }
+    const daemonVersion = client.getLastServerInfoMessage()?.version ?? null;
+    try {
+        const statusPayload = await client.getDaemonStatus({
+            timeout: DAEMON_STATUS_PROBE_TIMEOUT_MS,
+        });
+        const labelMap = new Map(PROVIDER_BINARIES.map((p) => [p.binary, p.label]));
+        const daemonProviders = statusPayload.providers.map((p) => ({
+            label: labelMap.get(p.provider) ?? p.provider,
+            path: p.available ? "available" : null,
+            version: p.available ? null : (p.error ?? null),
+            source: "daemon",
+        }));
+        const relayStatus = statusPayload.relay == null
+            ? undefined
+            : selectRelayStatus({
+                persisted: relayConfigFromLocalState(state),
+                live: statusPayload.relay,
+            });
+        if (!state.running) {
+            return {
+                connectedDaemon: "reachable",
+                daemonVersion: statusPayload.version ?? daemonVersion,
+                daemonNodeOverride: statusPayload.nodePath,
+                daemonProviders,
+                relayStatus,
+                note: state.pidInfo
+                    ? `Connected daemon is reachable at ${host} even though local daemon PID ${state.pidInfo.pid} is stale`
+                    : `Connected daemon is reachable at ${host} but no local daemon PID file was found`,
+            };
+        }
+        return {
+            connectedDaemon: "reachable",
+            daemonVersion: statusPayload.version ?? daemonVersion,
+            daemonNodeOverride: statusPayload.nodePath,
+            daemonProviders,
+            relayStatus,
+        };
+    }
+    catch {
+        return {
+            connectedDaemon: "reachable",
+            daemonVersion,
+            note: state.running
+                ? `Local daemon PID is running but daemon detail request to ${host} failed`
+                : `Connected daemon websocket is reachable at ${host} but daemon status request failed`,
+        };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+function applyProbeToStatus(input) {
+    const { probe } = input;
+    return {
+        connectedDaemon: probe.connectedDaemon,
+        localDaemon: probe.localDaemonOverride ?? input.localDaemon,
+        daemonNode: probe.daemonNodeOverride ?? input.daemonNode,
+        daemonVersion: probe.daemonVersion !== undefined ? probe.daemonVersion : input.daemonVersion,
+        daemonProviders: probe.daemonProviders ?? input.daemonProviders,
+        relayStatus: probe.relayStatus ?? input.relayStatus,
+        note: probe.note ? appendNote(input.note, probe.note) : input.note,
+    };
+}
+function resolveServerIdSafely(home) {
+    try {
+        return { serverId: getOrCreateServerId(home), error: null };
+    }
+    catch (error) {
+        return {
+            serverId: null,
+            error: `serverId unavailable: ${shortenMessage(normalizeError(error))}`,
+        };
+    }
+}
+async function resolveDaemonNodeLabel(state) {
+    if (!state.running)
+        return "-";
+    if (!state.pidInfo?.pid)
+        return "unknown (no PID available)";
+    const fromPid = await resolveNodePathFromPid(state.pidInfo.pid);
+    return fromPid.nodePath ?? `unknown (${fromPid.error ?? "could not resolve from PID"})`;
+}
+function relayConfigFromLocalState(state) {
+    return {
+        enabled: state.relayEnabled,
+        endpoint: state.relayEndpoint,
+        publicEndpoint: state.relayEndpoint,
+        useTls: state.relayUseTls,
+        publicUseTls: state.relayPublicUseTls,
+    };
+}
+export function selectRelayStatus(input) {
+    const relay = input.live ?? input.persisted;
+    if (!relay.enabled)
+        return "disabled";
+    const scheme = relay.publicUseTls ? "wss" : "ws";
+    return `${scheme}://${relay.publicEndpoint}`;
+}
+export async function runStatusCommand(options, _command) {
+    const home = typeof options.home === "string" ? options.home : undefined;
+    const state = resolveLocalDaemonState({ home });
+    const daemonTarget = state.listen.trim();
+    const owner = resolveOwnerLabel(state.pidInfo?.uid, state.pidInfo?.hostname);
+    let daemonNode = await resolveDaemonNodeLabel(state);
+    const cliNode = process.execPath;
+    let localDaemon = state.running ? "running" : "stopped";
+    let connectedDaemon = "not_probed";
+    let daemonVersion = null;
+    let daemonProviders;
+    let relayStatus = selectRelayStatus({ persisted: relayConfigFromLocalState(state) });
+    let note;
+    if (!state.running && state.stalePidFile && state.pidInfo) {
+        localDaemon = "stale_pid";
+        note = `Stale PID file found for PID ${state.pidInfo.pid}`;
+    }
+    if (daemonTarget) {
+        const probe = await probeDaemonOverWebsocket({ host: daemonTarget, state });
+        ({
+            connectedDaemon,
+            localDaemon,
+            daemonNode,
+            daemonVersion,
+            daemonProviders,
+            relayStatus,
+            note,
+        } = applyProbeToStatus({
+            probe,
+            connectedDaemon,
+            localDaemon,
+            daemonNode,
+            daemonVersion,
+            daemonProviders,
+            relayStatus,
+            note,
+        }));
+    }
+    const cliVersion = resolveCliVersion();
+    const serverIdResult = resolveServerIdSafely(state.home);
+    const serverId = serverIdResult.serverId;
+    if (serverIdResult.error) {
+        note = appendNote(note, serverIdResult.error);
+    }
+    const providers = daemonProviders ?? (await checkProviderBinaries());
+    const daemonStatus = {
+        serverId,
+        localDaemon,
+        connectedDaemon,
+        home: state.home,
+        listen: state.listen,
+        relay: relayStatus,
+        hostname: state.pidInfo?.hostname ?? null,
+        pid: state.pidInfo?.pid ?? null,
+        startedAt: state.pidInfo?.startedAt ?? null,
+        owner,
+        logPath: state.logPath,
+        daemonNode,
+        cliNode,
+        cliVersion,
+        daemonVersion,
+        desktopManaged: state.pidInfo?.desktopManaged === true,
+        providers,
+        note,
+    };
+    return {
+        type: "list",
+        data: toStatusRows(daemonStatus),
+        schema: createStatusSchema(daemonStatus),
+    };
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/daemon/stop.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface StopResult {
+    action: "stopped" | "not_running";
+    home: string;
+    pid: string;
+    forced: boolean;
+    usedLifecycleRpc: boolean;
+    reason: "not_running" | "lifecycle_shutdown_rpc" | "owner_pid_signal" | "owner_pid_sigkill";
+    message: string;
+}
+export type StopCommandResult = SingleResult<StopResult>;
+export declare function runStopCommand(options: CommandOptions, _command: Command): Promise<StopCommandResult>;
+export {};
+//# sourceMappingURL=stop.d.ts.map

package/dist/commands/daemon/stop.js

@@ -0,0 +1,60 @@
+import { stopLocalDaemon, DEFAULT_STOP_TIMEOUT_MS, DEFAULT_KILL_TIMEOUT_MS, } from "./local-daemon.js";
+const stopResultSchema = {
+    idField: "action",
+    columns: [
+        {
+            header: "STATUS",
+            field: "action",
+            color: (value) => (value === "stopped" ? "green" : "yellow"),
+        },
+        { header: "HOME", field: "home" },
+        { header: "PID", field: "pid" },
+        { header: "MESSAGE", field: "message" },
+    ],
+};
+function parseSecondsOption(raw, fallbackMs, label) {
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        return fallbackMs;
+    }
+    const seconds = Number(raw);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        const error = {
+            code: "INVALID_TIMEOUT",
+            message: `Invalid ${label} value: ${raw}`,
+            details: `${label} must be a positive number of seconds`,
+        };
+        throw error;
+    }
+    return Math.ceil(seconds * 1000);
+}
+export async function runStopCommand(options, _command) {
+    const home = typeof options.home === "string" ? options.home : undefined;
+    const force = options.force === true;
+    const timeoutMs = parseSecondsOption(options.timeout, DEFAULT_STOP_TIMEOUT_MS, "timeout");
+    const killTimeoutMs = parseSecondsOption(options.killTimeout, DEFAULT_KILL_TIMEOUT_MS, "kill-timeout");
+    try {
+        const result = await stopLocalDaemon({ home, force, timeoutMs, killTimeoutMs });
+        return {
+            type: "single",
+            data: {
+                action: result.action,
+                home: result.home,
+                pid: result.pid === null ? "-" : String(result.pid),
+                forced: result.forced,
+                usedLifecycleRpc: result.usedLifecycleRpc,
+                reason: result.reason,
+                message: result.message,
+            },
+            schema: stopResultSchema,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "STOP_FAILED",
+            message: `Failed to stop local daemon: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=stop.js.map

package/dist/commands/heartbeat/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createHeartbeatCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/heartbeat/index.js

@@ -0,0 +1,139 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { parseDuration } from "../../utils/duration.js";
+import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "../schedule/shared.js";
+import { scheduleSchema } from "../schedule/schema.js";
+const heartbeatDeleteSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id" },
+        { header: "STATUS", field: "status" },
+    ],
+};
+function requireCallerAgentId() {
+    const agentId = process.env.PASEO_AGENT_ID?.trim();
+    if (!agentId) {
+        throw new Error("Heartbeat commands must run inside a Paseo agent");
+    }
+    return agentId;
+}
+async function requireOwnedHeartbeat(client, id, agentId) {
+    const payload = await client.scheduleInspect({ id });
+    if (payload.error || !payload.schedule) {
+        throw new Error(payload.error ?? `Heartbeat not found: ${id}`);
+    }
+    if (payload.schedule.target.type !== "agent" || payload.schedule.target.agentId !== agentId) {
+        throw new Error(`Heartbeat ${id} does not belong to agent ${agentId}`);
+    }
+}
+async function runCreateHeartbeat(prompt, options, _command) {
+    const agentId = requireCallerAgentId();
+    const cron = options.cron?.trim();
+    if (!cron) {
+        throw new Error("--cron is required");
+    }
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const maxRuns = options.maxRuns ? Number.parseInt(options.maxRuns, 10) : undefined;
+        if (maxRuns !== undefined && (!Number.isSafeInteger(maxRuns) || maxRuns <= 0)) {
+            throw new Error("--max-runs must be a positive integer");
+        }
+        const payload = await client.scheduleCreate({
+            prompt: prompt.trim(),
+            cadence: {
+                type: "cron",
+                expression: cron,
+                ...(options.timezone?.trim() ? { timezone: options.timezone.trim() } : {}),
+            },
+            target: { type: "agent", agentId },
+            ...(options.name?.trim() ? { name: options.name.trim() } : {}),
+            ...(maxRuns ? { maxRuns } : {}),
+            ...(options.expiresIn
+                ? { expiresAt: new Date(Date.now() + parseDuration(options.expiresIn)).toISOString() }
+                : {}),
+        });
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? "Heartbeat creation failed");
+        }
+        return { type: "single", data: toScheduleRow(payload.schedule), schema: scheduleSchema };
+    }
+    catch (error) {
+        throw toScheduleCommandError("HEARTBEAT_CREATE_FAILED", "create heartbeat", error);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+async function runUpdateHeartbeat(id, options, _command) {
+    const agentId = requireCallerAgentId();
+    const cron = options.cron?.trim();
+    if (!cron) {
+        throw new Error("--cron is required");
+    }
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        await requireOwnedHeartbeat(client, id, agentId);
+        const payload = await client.scheduleUpdate({
+            id,
+            cadence: {
+                type: "cron",
+                expression: cron,
+                ...(options.timezone?.trim() ? { timezone: options.timezone.trim() } : {}),
+            },
+        });
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? `Heartbeat update failed: ${id}`);
+        }
+        return { type: "single", data: toScheduleRow(payload.schedule), schema: scheduleSchema };
+    }
+    catch (error) {
+        throw toScheduleCommandError("HEARTBEAT_UPDATE_FAILED", "update heartbeat", error);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+async function runDeleteHeartbeat(id, options, _command) {
+    const agentId = requireCallerAgentId();
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        await requireOwnedHeartbeat(client, id, agentId);
+        const payload = await client.scheduleDelete({ id });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return {
+            type: "single",
+            data: { id: payload.scheduleId, status: "deleted" },
+            schema: heartbeatDeleteSchema,
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("HEARTBEAT_DELETE_FAILED", "delete heartbeat", error);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+export function createHeartbeatCommand() {
+    const heartbeat = new Command("heartbeat").description("Manage this agent's heartbeats");
+    addJsonAndDaemonHostOptions(heartbeat
+        .command("create")
+        .description("Create a recurring prompt for this agent")
+        .argument("<prompt>", "Prompt to send")
+        .requiredOption("--cron <expr>", "Five-field cron cadence")
+        .option("--timezone <iana>", "IANA time zone")
+        .option("--name <name>", "Heartbeat name")
+        .option("--max-runs <n>", "Maximum number of runs")
+        .option("--expires-in <duration>", "Time to live")).action(withOutput(runCreateHeartbeat));
+    addJsonAndDaemonHostOptions(heartbeat
+        .command("update")
+        .description("Change a heartbeat cron cadence")
+        .argument("<id>", "Heartbeat ID")
+        .requiredOption("--cron <expr>", "Five-field cron cadence")
+        .option("--timezone <iana>", "IANA time zone")).action(withOutput(runUpdateHeartbeat));
+    addJsonAndDaemonHostOptions(heartbeat.command("delete").description("Delete a heartbeat").argument("<id>", "Heartbeat ID")).action(withOutput(runDeleteHeartbeat));
+    return heartbeat;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/hooks.d.ts

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+interface HookEnvironment {
+    PASEO_TERMINAL_ID?: string;
+    PASEO_ACTIVITY_TOKEN?: string;
+    PASEO_TERMINAL_ACTIVITY_URL?: string;
+}
+interface HookInput {
+    [Symbol.asyncIterator](): AsyncIterator<string | Buffer>;
+    isTTY?: boolean;
+}
+interface HooksRuntime {
+    env: HookEnvironment;
+    input: HookInput;
+    fetch: typeof fetch;
+}
+export declare function createHooksCommand(): Command;
+export declare function runHooksCommand(agent: string, event: string, runtime?: HooksRuntime): Promise<void>;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/commands/hooks.js

@@ -0,0 +1,89 @@
+import { Command } from "commander";
+import { resolveHookActivity } from "@camerontaylor/paseo-server/agent-hooks";
+export function createHooksCommand() {
+    return new Command("hooks")
+        .description("Record agent hook activity")
+        .argument("<agent>", "Agent hook source")
+        .argument("<event>", "Agent hook event")
+        .action((agent, event) => runHooksCommand(agent, event));
+}
+export async function runHooksCommand(agent, event, runtime = {
+    env: process.env,
+    input: process.stdin,
+    fetch,
+}) {
+    const target = resolveTarget(runtime.env);
+    if (!target)
+        return;
+    const state = await resolveHookActivity({
+        provider: agent,
+        event,
+        input: {
+            isTTY: runtime.input.isTTY,
+            read: () => readInput(runtime.input),
+        },
+    });
+    if (!state)
+        return;
+    await postActivity(target, state, runtime.fetch);
+}
+function resolveTarget(env) {
+    const terminalId = env.PASEO_TERMINAL_ID;
+    const token = env.PASEO_ACTIVITY_TOKEN;
+    const url = env.PASEO_TERMINAL_ACTIVITY_URL;
+    if (!terminalId || !token || !url)
+        return null;
+    return { terminalId, token, url };
+}
+async function readInput(input) {
+    const iterator = input[Symbol.asyncIterator]();
+    const chunks = [];
+    while (true) {
+        const next = await withTimeout(iterator.next(), 100);
+        if (!next) {
+            await iterator.return?.();
+            return null;
+        }
+        if (next.done)
+            return chunks.join("");
+        chunks.push(String(next.value));
+    }
+}
+async function withTimeout(promise, ms) {
+    let timeout;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(null), ms);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+async function postActivity(target, state, send) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 500);
+    try {
+        await send(target.url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                terminalId: target.terminalId,
+                token: target.token,
+                state,
+            }),
+            signal: controller.signal,
+        });
+    }
+    catch {
+        return;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+//# sourceMappingURL=hooks.js.map