"use strict";Object.defineProperty(exports, "__esModule", { value: true });exports.armPairNotifyOnce = armPairNotifyOnce;exports.formatPendingRequests = formatPendingRequests;exports.handleNotifyCommand = handleNotifyCommand;exports.registerPairingNotifierService = registerPairingNotifierService;var _nodeFs = require("node:fs");
var _nodePath = _interopRequireDefault(require("node:path"));

var _devicePair = require("openclaw/plugin-sdk/device-pair");function _interopRequireDefault(e) {return e && e.__esModule ? e : { default: e };}

const NOTIFY_STATE_FILE = "device-pair-notify.json";
const NOTIFY_POLL_INTERVAL_MS = 10_000;
const NOTIFY_MAX_SEEN_AGE_MS = 24 * 60 * 60 * 1000;























function formatPendingRequests(pending) {
  if (pending.length === 0) {
    return "No pending device pairing requests.";
  }
  const lines = ["Pending device pairing requests:"];
  for (const req of pending) {
    const label = req.displayName?.trim() || req.deviceId;
    const platform = req.platform?.trim();
    const ip = req.remoteIp?.trim();
    const parts = [
    `- ${req.requestId}`,
    label ? `name=${label}` : null,
    platform ? `platform=${platform}` : null,
    ip ? `ip=${ip}` : null].
    filter(Boolean);
    lines.push(parts.join(" · "));
  }
  return lines.join("\n");
}

function resolveNotifyStatePath(stateDir) {
  return _nodePath.default.join(stateDir, NOTIFY_STATE_FILE);
}

function normalizeNotifyState(raw) {
  const root = typeof raw === "object" && raw !== null ? raw : {};
  const subscribersRaw = Array.isArray(root.subscribers) ? root.subscribers : [];
  const notifiedRaw =
  typeof root.notifiedRequestIds === "object" && root.notifiedRequestIds !== null ?
  root.notifiedRequestIds :
  {};

  const subscribers = [];
  for (const item of subscribersRaw) {
    if (typeof item !== "object" || item === null) {
      continue;
    }
    const record = item;
    const to = typeof record.to === "string" ? record.to.trim() : "";
    if (!to) {
      continue;
    }
    const accountId =
    typeof record.accountId === "string" && record.accountId.trim() ?
    record.accountId.trim() :
    undefined;
    const messageThreadId =
    typeof record.messageThreadId === "number" && Number.isFinite(record.messageThreadId) ?
    Math.trunc(record.messageThreadId) :
    undefined;
    const mode = record.mode === "once" ? "once" : "persistent";
    const addedAtMs =
    typeof record.addedAtMs === "number" && Number.isFinite(record.addedAtMs) ?
    Math.trunc(record.addedAtMs) :
    Date.now();
    subscribers.push({
      to,
      accountId,
      messageThreadId,
      mode,
      addedAtMs
    });
  }

  const notifiedRequestIds = {};
  for (const [requestId, ts] of Object.entries(notifiedRaw)) {
    if (!requestId.trim()) {
      continue;
    }
    if (typeof ts !== "number" || !Number.isFinite(ts) || ts <= 0) {
      continue;
    }
    notifiedRequestIds[requestId] = Math.trunc(ts);
  }

  return { subscribers, notifiedRequestIds };
}

async function readNotifyState(filePath) {
  try {
    const content = await _nodeFs.promises.readFile(filePath, "utf8");
    return normalizeNotifyState(JSON.parse(content));
  } catch {
    return { subscribers: [], notifiedRequestIds: {} };
  }
}

async function writeNotifyState(filePath, state) {
  await _nodeFs.promises.mkdir(_nodePath.default.dirname(filePath), { recursive: true });
  const content = JSON.stringify(state, null, 2);
  await _nodeFs.promises.writeFile(filePath, `${content}\n`, "utf8");
}

function notifySubscriberKey(subscriber)



{
  return [subscriber.to, subscriber.accountId ?? "", subscriber.messageThreadId ?? ""].join("|");
}







function resolveNotifyTarget(ctx)





{
  const to = ctx.senderId?.trim() || ctx.from?.trim() || ctx.to?.trim() || "";
  if (!to) {
    return null;
  }
  return {
    to,
    ...(ctx.accountId ? { accountId: ctx.accountId } : {}),
    ...(ctx.messageThreadId != null ? { messageThreadId: ctx.messageThreadId } : {})
  };
}

function upsertNotifySubscriber(
subscribers,
target,
mode)
{
  const key = notifySubscriberKey(target);
  const index = subscribers.findIndex((entry) => notifySubscriberKey(entry) === key);
  const next = {
    ...target,
    mode,
    addedAtMs: Date.now()
  };
  if (index === -1) {
    subscribers.push(next);
    return true;
  }
  const existing = subscribers[index];
  if (existing?.mode === mode) {
    return false;
  }
  subscribers[index] = next;
  return true;
}

function buildPairingRequestNotificationText(request) {
  const label = request.displayName?.trim() || request.deviceId;
  const platform = request.platform?.trim();
  const ip = request.remoteIp?.trim();
  const lines = [
  "📲 New device pairing request",
  `ID: ${request.requestId}`,
  `Name: ${label}`,
  ...(platform ? [`Platform: ${platform}`] : []),
  ...(ip ? [`IP: ${ip}`] : []),
  "",
  `Approve: /pair approve ${request.requestId}`,
  "List pending: /pair pending"];

  return lines.join("\n");
}

function requestTimestampMs(request) {
  if (typeof request.ts !== "number" || !Number.isFinite(request.ts)) {
    return null;
  }
  const ts = Math.trunc(request.ts);
  return ts > 0 ? ts : null;
}

function shouldNotifySubscriberForRequest(
subscriber,
request)
{
  if (subscriber.mode !== "once") {
    return true;
  }
  const ts = requestTimestampMs(request);
  // One-shot subscriptions should only notify for new requests created after arming.
  if (ts == null) {
    return false;
  }
  return ts >= subscriber.addedAtMs;
}

async function notifySubscriber(params)



{
  const send = params.api.runtime?.channel?.telegram?.sendMessageTelegram;
  if (!send) {
    params.api.logger.warn("device-pair: telegram runtime unavailable for pairing notifications");
    return false;
  }

  try {
    await send(params.subscriber.to, params.text, {
      ...(params.subscriber.accountId ? { accountId: params.subscriber.accountId } : {}),
      ...(params.subscriber.messageThreadId != null ?
      { messageThreadId: params.subscriber.messageThreadId } :
      {})
    });
    return true;
  } catch (err) {
    params.api.logger.warn(
      `device-pair: failed to send pairing notification to ${params.subscriber.to}: ${String(
        err?.message ?? err
      )}`
    );
    return false;
  }
}

async function notifyPendingPairingRequests(params)


{
  const state = await readNotifyState(params.statePath);
  const pairing = await (0, _devicePair.listDevicePairing)();
  const pending = pairing.pending;
  const now = Date.now();
  const pendingIds = new Set(pending.map((entry) => entry.requestId));
  let changed = false;

  for (const [requestId, ts] of Object.entries(state.notifiedRequestIds)) {
    if (!pendingIds.has(requestId) || now - ts > NOTIFY_MAX_SEEN_AGE_MS) {
      delete state.notifiedRequestIds[requestId];
      changed = true;
    }
  }

  if (state.subscribers.length > 0) {
    const oneShotDelivered = new Set();
    for (const request of pending) {
      if (state.notifiedRequestIds[request.requestId]) {
        continue;
      }

      const text = buildPairingRequestNotificationText(request);
      let delivered = false;
      for (const subscriber of state.subscribers) {
        if (!shouldNotifySubscriberForRequest(subscriber, request)) {
          continue;
        }
        const sent = await notifySubscriber({
          api: params.api,
          subscriber,
          text
        });
        delivered = delivered || sent;
        if (sent && subscriber.mode === "once") {
          oneShotDelivered.add(notifySubscriberKey(subscriber));
        }
      }

      if (delivered) {
        state.notifiedRequestIds[request.requestId] = now;
        changed = true;
      }
    }
    if (oneShotDelivered.size > 0) {
      const initialCount = state.subscribers.length;
      state.subscribers = state.subscribers.filter(
        (subscriber) => !oneShotDelivered.has(notifySubscriberKey(subscriber))
      );
      if (state.subscribers.length !== initialCount) {
        changed = true;
      }
    }
  }

  if (changed) {
    await writeNotifyState(params.statePath, state);
  }
}

async function armPairNotifyOnce(params)









{
  if (params.ctx.channel !== "telegram") {
    return false;
  }
  const target = resolveNotifyTarget(params.ctx);
  if (!target) {
    return false;
  }

  const stateDir = params.api.runtime.state.resolveStateDir();
  const statePath = resolveNotifyStatePath(stateDir);
  const state = await readNotifyState(statePath);
  let changed = false;

  if (upsertNotifySubscriber(state.subscribers, target, "once")) {
    changed = true;
  }

  if (changed) {
    await writeNotifyState(statePath, state);
  }
  return true;
}

async function handleNotifyCommand(params)










{
  if (params.ctx.channel !== "telegram") {
    return { text: "Pairing notifications are currently supported only on Telegram." };
  }

  const target = resolveNotifyTarget(params.ctx);
  if (!target) {
    return { text: "Could not resolve Telegram target for this chat." };
  }

  const stateDir = params.api.runtime.state.resolveStateDir();
  const statePath = resolveNotifyStatePath(stateDir);
  const state = await readNotifyState(statePath);
  const targetKey = notifySubscriberKey(target);
  const current = state.subscribers.find((entry) => notifySubscriberKey(entry) === targetKey);

  if (params.action === "on" || params.action === "enable") {
    if (upsertNotifySubscriber(state.subscribers, target, "persistent")) {
      await writeNotifyState(statePath, state);
    }
    return {
      text:
      "✅ Pair request notifications enabled for this Telegram chat.\n" +
      "I will ping here when a new device pairing request arrives."
    };
  }

  if (params.action === "off" || params.action === "disable") {
    const currentIndex = state.subscribers.findIndex(
      (entry) => notifySubscriberKey(entry) === targetKey
    );
    if (currentIndex !== -1) {
      state.subscribers.splice(currentIndex, 1);
      await writeNotifyState(statePath, state);
    }
    return { text: "✅ Pair request notifications disabled for this Telegram chat." };
  }

  if (params.action === "once" || params.action === "arm") {
    await armPairNotifyOnce({
      api: params.api,
      ctx: params.ctx
    });
    return {
      text:
      "✅ One-shot pairing notification armed for this Telegram chat.\n" +
      "I will notify on the next new pairing request, then auto-disable."
    };
  }

  if (params.action === "status" || params.action === "") {
    const pending = await (0, _devicePair.listDevicePairing)();
    const enabled = Boolean(current);
    const mode = current?.mode ?? "off";
    return {
      text: [
      `Pair request notifications: ${enabled ? "enabled" : "disabled"} for this chat.`,
      `Mode: ${mode}`,
      `Subscribers: ${state.subscribers.length}`,
      `Pending requests: ${pending.pending.length}`,
      "",
      "Use /pair notify on|off|once"].
      join("\n")
    };
  }

  return { text: "Usage: /pair notify on|off|once|status" };
}

function registerPairingNotifierService(api) {
  let notifyInterval = null;

  api.registerService({
    id: "device-pair-notifier",
    start: async (ctx) => {
      const statePath = resolveNotifyStatePath(ctx.stateDir);
      const tick = async () => {
        await notifyPendingPairingRequests({ api, statePath });
      };

      await tick().catch((err) => {
        api.logger.warn(
          `device-pair: initial notify poll failed: ${String(err?.message ?? err)}`
        );
      });

      notifyInterval = setInterval(() => {
        tick().catch((err) => {
          api.logger.warn(
            `device-pair: notify poll failed: ${String(err?.message ?? err)}`
          );
        });
      }, NOTIFY_POLL_INTERVAL_MS);
      notifyInterval.unref?.();
    },
    stop: async () => {
      if (notifyInterval) {
        clearInterval(notifyInterval);
        notifyInterval = null;
      }
    }
  });
} /* v9-9322c85d0dc49b80 */